Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Update crossterm, use more terminal features #13223

Closed
wants to merge 4 commits into from

Conversation

the-mikedavis
Copy link
Member

@the-mikedavis the-mikedavis commented Mar 29, 2025

This is a rollup of a few crossterm related changes. It also switches us to use https://github.com/helix-editor/crossterm instead of upstream crossterm - the idea is to maintain a soft fork where we can experiment with features before sending them upstream.

Historically we haven't wanted to add light/dark mode since it required
platform-specific dependencies. The Contour terminal [proposed] a VT
extension to query for the current mode and subscribe to future changes,
however, which can be supported squarely in Crossterm with no new deps.
Currently at least Contour, Kitty and Ghostty support this on the
terminal emulator side and Neovim on the client side.

This patch allows configuring multiple themes:

    # this is still accepted:
    # theme = "ayu_dark"
    theme = { dark = "ayu_dark", light = "ayu_light" }

On startup we query the terminal for the current mode and choose that
theme. We then receive events from crossterm whenever the terminal
changes theme.

[proposed]: https://github.com/contour-terminal/contour/blob/master/docs/vt-extensions/color-palette-update-notifications.md
`cossterm::terminal::terminal_features` queries for all VT extension
features at once and gives back a small struct with the current state of
each feature. We can use this struct to determine which features the
terminal supports. This patch changes to prefer this feature over
individual queries like `supports_keyboard_enhancement` and
`query_terminal_theme_mode`.

This also updates our handling of the Kitty keyboard protocol. Once we
enable the protocol we ask the terminal for the currently enabled flags.
If we see that the terminal hasn't enabled the requested flags then we
turn off the feature. This is intended for Zellij which doesn't support
the `REPORT_ALTERNATE_KEYS` flag. When `DISAMBIGUATE_ESCAPE_CODES` is
enabled but not `REPORT_ALTERNATE_KEYS` we get key combinations like
`A-S-9` instead of `A-(` (which we also get without the enhanced
keyboard protocol). Disabling the protocol is simpler in this case than
normalizing based on the keyboard.
This takes advantage of the synchronized output commands from crossterm
to tell the terminal emulator when to pause and resume drawing. This
should feel snappier and have fewer visual artifacts like tearing when
we update the screen with many changes (scrolling or changing theme for
example).
@@ -47,6 +47,7 @@ unicode-segmentation = "1.2"
ropey = { version = "1.6.1", default-features = false, features = ["simd"] }
foldhash = "0.1"
parking_lot = "0.12"
crossterm = { package = "helix-crossterm", version = "0.1.0-beta.1" }
Copy link
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Before merging this we should publish 0.1.0

@@ -13,6 +13,7 @@ use crate::{
},
};

use arc_swap::access::DynAccess;
Copy link
Contributor

@RoloEdits RoloEdits Mar 29, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I think importing this as is can ruin some type inference for some instances of DynGuard (let bindings would then need a fully specified type which, can be long nested types for this kind of use case)? Sort of a precautionary measure, but I would just fully qualify the two instances of the use here.

edit: Yeah, just cherry-picked this and did see this when I am loading from my icons branch.

@RoloEdits
Copy link
Contributor

RoloEdits commented Mar 29, 2025

Hmm, im using wezterm, which should support (I think) everything here, but am getting back:

2025-03-29T06:49:06.980 helix_tui::backend::crossterm [DEBUG] Detected terminal features in 8.6µs. Enhanced keyboard support: false, Synchronized output support: false. Theme mode updates support: false

For the synchronized output:

Entering print "\e[?2026\$p" I got back [?2026;2$y which seems like it should be "supported"?
image

Running:

print "\e[?2026h"  # Enable sync mode
for i in 1..5 {
    print $"Line ($i)"
    sleep 500ms
}
print "\e[?2026l"  # Disable sync mode

The lines were printed all at once, so seems like its working?

edit:

Just saw

// Queries the terminal's support for synchronized output sequences.
 ///
 /// This always returns `Ok(false)` on Windows.
 #[cfg(feature = "events")]
 pub fn supports_synchronized_output() -> io::Result<bool> {
     Ok(false)
 }

Does this mean it won't work for windows? Or just that it cannot report if it does work or not?

@arthsmn
Copy link
Contributor

arthsmn commented Mar 29, 2025

The light/dark switching is not working in Ghostty 1.1.3 on NixOS.

Here are the logs:

2025-03-29T11:50:24.964 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted before optimization: Seq[E("rs"), E("rust")]
2025-03-29T11:50:24.964 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted after optimization: Seq[E("rs"), E("rust")]
2025-03-29T11:50:24.965 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 2 literals: [E("rs"), E("rust")]
2025-03-29T11:50:24.965 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.965 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("sway")]
2025-03-29T11:50:24.965 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("sway")]
2025-03-29T11:50:24.965 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("sway")]
2025-03-29T11:50:24.965 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.965 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("toml")]
2025-03-29T11:50:24.965 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("toml")]
2025-03-29T11:50:24.965 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("toml")]
2025-03-29T11:50:24.965 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.965 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("awk")]
2025-03-29T11:50:24.965 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("awk")]
2025-03-29T11:50:24.965 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("awk")]
2025-03-29T11:50:24.965 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.965 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("proto")]
2025-03-29T11:50:24.965 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("proto")]
2025-03-29T11:50:24.965 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("proto")]
2025-03-29T11:50:24.965 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.965 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted before optimization: Seq[E("elixir"), E("ex")]
2025-03-29T11:50:24.965 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted after optimization: Seq[E("elixir"), E("ex")]
2025-03-29T11:50:24.965 regex_cursor::engines::meta::strategy [DEBUG] creating prefilter from 2 literals: [E("elixir"), E("ex")]
2025-03-29T11:50:24.965 regex_cursor::engines::meta::wrappers [DEBUG] PikeVM built
2025-03-29T11:50:24.965 regex_cursor::engines::meta::wrappers [DEBUG] fully compiled forward and reverse DFAs built, 1976 bytes
2025-03-29T11:50:24.965 regex_cursor::engines::meta::strategy [DEBUG] skipping lazy DFA because we have a full DFA
2025-03-29T11:50:24.965 regex_cursor::engines::meta::strategy [DEBUG] skipping reverse anchored optimization because the regex is not always anchored at the end
2025-03-29T11:50:24.965 regex_cursor::engines::meta::strategy [DEBUG] using core strategy
2025-03-29T11:50:24.965 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("fish")]
2025-03-29T11:50:24.965 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("fish")]
2025-03-29T11:50:24.965 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("fish")]
2025-03-29T11:50:24.965 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.965 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("mint")]
2025-03-29T11:50:24.965 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("mint")]
2025-03-29T11:50:24.965 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("mint")]
2025-03-29T11:50:24.965 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.965 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("mojo")]
2025-03-29T11:50:24.965 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("mojo")]
2025-03-29T11:50:24.965 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("mojo")]
2025-03-29T11:50:24.965 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.965 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("janet")]
2025-03-29T11:50:24.965 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("janet")]
2025-03-29T11:50:24.965 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("janet")]
2025-03-29T11:50:24.965 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.966 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("json")]
2025-03-29T11:50:24.966 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("json")]
2025-03-29T11:50:24.966 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("json")]
2025-03-29T11:50:24.966 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.966 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("jsonc")]
2025-03-29T11:50:24.966 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("jsonc")]
2025-03-29T11:50:24.966 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("jsonc")]
2025-03-29T11:50:24.966 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.966 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("json5")]
2025-03-29T11:50:24.966 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("json5")]
2025-03-29T11:50:24.966 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("json5")]
2025-03-29T11:50:24.966 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.966 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("c")]
2025-03-29T11:50:24.966 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("c")]
2025-03-29T11:50:24.966 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("c")]
2025-03-29T11:50:24.966 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.966 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("cpp")]
2025-03-29T11:50:24.966 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("cpp")]
2025-03-29T11:50:24.966 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("cpp")]
2025-03-29T11:50:24.966 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.966 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted before optimization: Seq[E("c-sharp"), E("csharp")]
2025-03-29T11:50:24.966 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted after optimization: Seq[E("c-sharp"), E("csharp")]
2025-03-29T11:50:24.966 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 2 literals: [E("c-sharp"), E("csharp")]
2025-03-29T11:50:24.966 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.966 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("cel")]
2025-03-29T11:50:24.966 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("cel")]
2025-03-29T11:50:24.966 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("cel")]
2025-03-29T11:50:24.966 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.966 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("spicedb")]
2025-03-29T11:50:24.966 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("spicedb")]
2025-03-29T11:50:24.966 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("spicedb")]
2025-03-29T11:50:24.966 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.966 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("go")]
2025-03-29T11:50:24.966 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("go")]
2025-03-29T11:50:24.966 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("go")]
2025-03-29T11:50:24.966 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.966 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("gomod")]
2025-03-29T11:50:24.966 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("gomod")]
2025-03-29T11:50:24.966 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("gomod")]
2025-03-29T11:50:24.966 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.966 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("gotmpl")]
2025-03-29T11:50:24.966 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("gotmpl")]
2025-03-29T11:50:24.966 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("gotmpl")]
2025-03-29T11:50:24.966 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.966 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("gowork")]
2025-03-29T11:50:24.966 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("gowork")]
2025-03-29T11:50:24.966 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("gowork")]
2025-03-29T11:50:24.966 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.966 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted before optimization: Seq[E("js"), E("javascript")]
2025-03-29T11:50:24.966 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=false) extracted after optimization: Seq[I("j")]
2025-03-29T11:50:24.966 regex_cursor::engines::meta::strategy [DEBUG] creating prefilter from 1 literals: [I("j")]
2025-03-29T11:50:24.966 regex_cursor::engines::meta::wrappers [DEBUG] PikeVM built
2025-03-29T11:50:24.967 regex_cursor::engines::meta::wrappers [DEBUG] fully compiled forward and reverse DFAs built, 5304 bytes
2025-03-29T11:50:24.967 regex_cursor::engines::meta::strategy [DEBUG] skipping lazy DFA because we have a full DFA
2025-03-29T11:50:24.967 regex_cursor::engines::meta::strategy [DEBUG] skipping reverse anchored optimization because the regex is not always anchored at the end
2025-03-29T11:50:24.967 regex_cursor::engines::meta::strategy [DEBUG] using core strategy
2025-03-29T11:50:24.967 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("jsx")]
2025-03-29T11:50:24.967 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("jsx")]
2025-03-29T11:50:24.967 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("jsx")]
2025-03-29T11:50:24.967 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.967 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted before optimization: Seq[E("ts"), E("typescript")]
2025-03-29T11:50:24.967 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted after optimization: Seq[E("ts"), E("typescript")]
2025-03-29T11:50:24.967 regex_cursor::engines::meta::strategy [DEBUG] creating prefilter from 2 literals: [E("ts"), E("typescript")]
2025-03-29T11:50:24.967 regex_cursor::engines::meta::wrappers [DEBUG] PikeVM built
2025-03-29T11:50:24.967 regex_cursor::engines::meta::wrappers [DEBUG] fully compiled forward and reverse DFAs built, 2808 bytes
2025-03-29T11:50:24.967 regex_cursor::engines::meta::strategy [DEBUG] skipping lazy DFA because we have a full DFA
2025-03-29T11:50:24.967 regex_cursor::engines::meta::strategy [DEBUG] skipping reverse anchored optimization because the regex is not always anchored at the end
2025-03-29T11:50:24.967 regex_cursor::engines::meta::strategy [DEBUG] using core strategy
2025-03-29T11:50:24.967 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted before optimization: Seq[E("tsp"), E("typespec")]
2025-03-29T11:50:24.967 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted after optimization: Seq[E("tsp"), E("typespec")]
2025-03-29T11:50:24.967 regex_cursor::engines::meta::strategy [DEBUG] creating prefilter from 2 literals: [E("tsp"), E("typespec")]
2025-03-29T11:50:24.967 regex_cursor::engines::meta::wrappers [DEBUG] PikeVM built
2025-03-29T11:50:24.967 regex_cursor::engines::meta::wrappers [DEBUG] fully compiled forward and reverse DFAs built, 2552 bytes
2025-03-29T11:50:24.967 regex_cursor::engines::meta::strategy [DEBUG] skipping lazy DFA because we have a full DFA
2025-03-29T11:50:24.967 regex_cursor::engines::meta::strategy [DEBUG] skipping reverse anchored optimization because the regex is not always anchored at the end
2025-03-29T11:50:24.967 regex_cursor::engines::meta::strategy [DEBUG] using core strategy
2025-03-29T11:50:24.967 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("tsx")]
2025-03-29T11:50:24.967 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("tsx")]
2025-03-29T11:50:24.967 regex_cursor::engines::meta::strategy [DEBUG] creating prefilter from 1 literals: [E("tsx")]
2025-03-29T11:50:24.967 regex_cursor::engines::meta::wrappers [DEBUG] PikeVM built
2025-03-29T11:50:24.967 regex_cursor::engines::meta::wrappers [DEBUG] fully compiled forward and reverse DFAs built, 760 bytes
2025-03-29T11:50:24.967 regex_cursor::engines::meta::strategy [DEBUG] skipping lazy DFA because we have a full DFA
2025-03-29T11:50:24.967 regex_cursor::engines::meta::strategy [DEBUG] skipping reverse anchored optimization because the regex is not always anchored at the end
2025-03-29T11:50:24.967 regex_cursor::engines::meta::strategy [DEBUG] using core strategy
2025-03-29T11:50:24.967 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("css")]
2025-03-29T11:50:24.967 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("css")]
2025-03-29T11:50:24.967 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("css")]
2025-03-29T11:50:24.967 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.967 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("scss")]
2025-03-29T11:50:24.967 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("scss")]
2025-03-29T11:50:24.967 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("scss")]
2025-03-29T11:50:24.967 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.967 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("html")]
2025-03-29T11:50:24.967 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("html")]
2025-03-29T11:50:24.967 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("html")]
2025-03-29T11:50:24.967 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.967 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted before optimization: Seq[E("python"), E("py")]
2025-03-29T11:50:24.967 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted after optimization: Seq[E("python"), E("py")]
2025-03-29T11:50:24.967 regex_cursor::engines::meta::strategy [DEBUG] creating prefilter from 2 literals: [E("python"), E("py")]
2025-03-29T11:50:24.968 regex_cursor::engines::meta::wrappers [DEBUG] PikeVM built
2025-03-29T11:50:24.968 regex_cursor::engines::meta::wrappers [DEBUG] fully compiled forward and reverse DFAs built, 1668 bytes
2025-03-29T11:50:24.968 regex_cursor::engines::meta::strategy [DEBUG] skipping lazy DFA because we have a full DFA
2025-03-29T11:50:24.968 regex_cursor::engines::meta::strategy [DEBUG] skipping reverse anchored optimization because the regex is not always anchored at the end
2025-03-29T11:50:24.968 regex_cursor::engines::meta::strategy [DEBUG] using core strategy
2025-03-29T11:50:24.968 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("nickel")]
2025-03-29T11:50:24.968 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("nickel")]
2025-03-29T11:50:24.968 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("nickel")]
2025-03-29T11:50:24.968 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.968 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("nix")]
2025-03-29T11:50:24.968 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("nix")]
2025-03-29T11:50:24.968 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("nix")]
2025-03-29T11:50:24.968 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.968 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("ruby")]
2025-03-29T11:50:24.968 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("ruby")]
2025-03-29T11:50:24.968 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("ruby")]
2025-03-29T11:50:24.968 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.968 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(4), exact=true) extracted before optimization: Seq[E("shell"), E("bash"), E("zsh"), E("sh")]
2025-03-29T11:50:24.968 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(4), exact=true) extracted after optimization: Seq[E("shell"), E("bash"), E("zsh"), E("sh")]
2025-03-29T11:50:24.968 regex_cursor::engines::meta::strategy [DEBUG] creating prefilter from 4 literals: [E("shell"), E("bash"), E("zsh"), E("sh")]
2025-03-29T11:50:24.968 regex_cursor::engines::meta::wrappers [DEBUG] PikeVM built
2025-03-29T11:50:24.968 regex_cursor::engines::meta::wrappers [DEBUG] fully compiled forward and reverse DFAs built, 2524 bytes
2025-03-29T11:50:24.968 regex_cursor::engines::meta::strategy [DEBUG] skipping lazy DFA because we have a full DFA
2025-03-29T11:50:24.968 regex_cursor::engines::meta::strategy [DEBUG] skipping reverse anchored optimization because the regex is not always anchored at the end
2025-03-29T11:50:24.968 regex_cursor::engines::meta::strategy [DEBUG] using core strategy
2025-03-29T11:50:24.968 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("php")]
2025-03-29T11:50:24.968 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("php")]
2025-03-29T11:50:24.968 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("php")]
2025-03-29T11:50:24.968 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.968 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("php-only")]
2025-03-29T11:50:24.968 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("php-only")]
2025-03-29T11:50:24.968 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("php-only")]
2025-03-29T11:50:24.968 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.968 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("blade")]
2025-03-29T11:50:24.968 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("blade")]
2025-03-29T11:50:24.968 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("blade")]
2025-03-29T11:50:24.968 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.968 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("twig")]
2025-03-29T11:50:24.968 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("twig")]
2025-03-29T11:50:24.968 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("twig")]
2025-03-29T11:50:24.968 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.968 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("tex")]
2025-03-29T11:50:24.968 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("tex")]
2025-03-29T11:50:24.968 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("tex")]
2025-03-29T11:50:24.968 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.968 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("bib")]
2025-03-29T11:50:24.968 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("bib")]
2025-03-29T11:50:24.968 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("bib")]
2025-03-29T11:50:24.968 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.968 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("lean")]
2025-03-29T11:50:24.968 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("lean")]
2025-03-29T11:50:24.968 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("lean")]
2025-03-29T11:50:24.968 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.968 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("julia")]
2025-03-29T11:50:24.968 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("julia")]
2025-03-29T11:50:24.968 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("julia")]
2025-03-29T11:50:24.968 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("java")]
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("java")]
2025-03-29T11:50:24.969 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("java")]
2025-03-29T11:50:24.969 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("smali")]
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("smali")]
2025-03-29T11:50:24.969 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("smali")]
2025-03-29T11:50:24.969 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("ledger")]
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("ledger")]
2025-03-29T11:50:24.969 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("ledger")]
2025-03-29T11:50:24.969 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("beancount")]
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("beancount")]
2025-03-29T11:50:24.969 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("beancount")]
2025-03-29T11:50:24.969 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("ocaml")]
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("ocaml")]
2025-03-29T11:50:24.969 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("ocaml")]
2025-03-29T11:50:24.969 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("lua")]
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("lua")]
2025-03-29T11:50:24.969 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("lua")]
2025-03-29T11:50:24.969 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("teal")]
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("teal")]
2025-03-29T11:50:24.969 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("teal")]
2025-03-29T11:50:24.969 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("svelte")]
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("svelte")]
2025-03-29T11:50:24.969 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("svelte")]
2025-03-29T11:50:24.969 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("vue")]
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("vue")]
2025-03-29T11:50:24.969 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("vue")]
2025-03-29T11:50:24.969 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted before optimization: Seq[E("yml"), E("yaml")]
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted after optimization: Seq[E("yml"), E("yaml")]
2025-03-29T11:50:24.969 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 2 literals: [E("yml"), E("yaml")]
2025-03-29T11:50:24.969 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("nestedtext")]
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("nestedtext")]
2025-03-29T11:50:24.969 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("nestedtext")]
2025-03-29T11:50:24.969 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted before optimization: Seq[E("hs"), E("haskell")]
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted after optimization: Seq[E("hs"), E("haskell")]
2025-03-29T11:50:24.969 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 2 literals: [E("hs"), E("haskell")]
2025-03-29T11:50:24.969 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("purescript")]
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("purescript")]
2025-03-29T11:50:24.969 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("purescript")]
2025-03-29T11:50:24.969 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("zig")]
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("zig")]
2025-03-29T11:50:24.969 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("zig")]
2025-03-29T11:50:24.969 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("tsq")]
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("tsq")]
2025-03-29T11:50:24.969 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("tsq")]
2025-03-29T11:50:24.969 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("cmake")]
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("cmake")]
2025-03-29T11:50:24.969 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("cmake")]
2025-03-29T11:50:24.969 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(4), exact=true) extracted before optimization: Seq[E("make"), E("makefile"), E("Makefile"), E("mk")]
2025-03-29T11:50:24.969 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(3), exact=true) extracted after optimization: Seq[E("make"), E("Makefile"), E("mk")]
2025-03-29T11:50:24.969 regex_cursor::engines::meta::strategy [DEBUG] creating prefilter from 3 literals: [E("make"), E("Makefile"), E("mk")]
2025-03-29T11:50:24.970 regex_cursor::engines::meta::wrappers [DEBUG] PikeVM built
2025-03-29T11:50:24.970 regex_cursor::engines::meta::wrappers [DEBUG] fully compiled forward and reverse DFAs built, 3000 bytes
2025-03-29T11:50:24.970 regex_cursor::engines::meta::strategy [DEBUG] skipping lazy DFA because we have a full DFA
2025-03-29T11:50:24.970 regex_cursor::engines::meta::strategy [DEBUG] skipping reverse anchored optimization because the regex is not always anchored at the end
2025-03-29T11:50:24.970 regex_cursor::engines::meta::strategy [DEBUG] using core strategy
2025-03-29T11:50:24.970 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("glsl")]
2025-03-29T11:50:24.970 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("glsl")]
2025-03-29T11:50:24.970 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("glsl")]
2025-03-29T11:50:24.970 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.970 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("pod")]
2025-03-29T11:50:24.970 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("pod")]
2025-03-29T11:50:24.970 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("pod")]
2025-03-29T11:50:24.970 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.970 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("comment")]
2025-03-29T11:50:24.970 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("comment")]
2025-03-29T11:50:24.970 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("comment")]
2025-03-29T11:50:24.970 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.970 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("llvm")]
2025-03-29T11:50:24.970 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("llvm")]
2025-03-29T11:50:24.970 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("llvm")]
2025-03-29T11:50:24.970 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.970 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("mir")]
2025-03-29T11:50:24.970 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("mir")]
2025-03-29T11:50:24.970 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("mir")]
2025-03-29T11:50:24.970 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.970 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("tablegen")]
2025-03-29T11:50:24.970 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("tablegen")]
2025-03-29T11:50:24.970 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("tablegen")]
2025-03-29T11:50:24.970 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.970 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(3), exact=true) extracted before optimization: Seq[E("mail"), E("eml"), E("email")]
2025-03-29T11:50:24.970 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(3), exact=true) extracted after optimization: Seq[E("mail"), E("eml"), E("email")]
2025-03-29T11:50:24.970 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 3 literals: [E("mail"), E("eml"), E("email")]
2025-03-29T11:50:24.970 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.970 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted before optimization: Seq[E("md"), E("markdown")]
2025-03-29T11:50:24.970 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted after optimization: Seq[E("md"), E("markdown")]
2025-03-29T11:50:24.970 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 2 literals: [E("md"), E("markdown")]
2025-03-29T11:50:24.970 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.970 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("markdown.inline")]
2025-03-29T11:50:24.970 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("markdown.inline")]
2025-03-29T11:50:24.970 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("markdown.inline")]
2025-03-29T11:50:24.970 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.970 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted before optimization: Seq[E("dj"), E("djot")]
2025-03-29T11:50:24.970 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("dj")]
2025-03-29T11:50:24.970 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("dj")]
2025-03-29T11:50:24.970 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.970 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted before optimization: Seq[E("docker"), E("dockerfile")]
2025-03-29T11:50:24.970 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("docker")]
2025-03-29T11:50:24.970 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("docker")]
2025-03-29T11:50:24.970 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.970 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("diff")]
2025-03-29T11:50:24.970 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("diff")]
2025-03-29T11:50:24.970 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("diff")]
2025-03-29T11:50:24.970 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.970 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("git-rebase")]
2025-03-29T11:50:24.970 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("git-rebase")]
2025-03-29T11:50:24.970 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("git-rebase")]
2025-03-29T11:50:24.970 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.970 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("regex")]
2025-03-29T11:50:24.970 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("regex")]
2025-03-29T11:50:24.970 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("regex")]
2025-03-29T11:50:24.970 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.970 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("git-config")]
2025-03-29T11:50:24.971 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("git-config")]
2025-03-29T11:50:24.971 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("git-config")]
2025-03-29T11:50:24.971 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.971 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("git-attributes")]
2025-03-29T11:50:24.971 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("git-attributes")]
2025-03-29T11:50:24.971 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("git-attributes")]
2025-03-29T11:50:24.971 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.971 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("git-ignore")]
2025-03-29T11:50:24.971 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("git-ignore")]
2025-03-29T11:50:24.971 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("git-ignore")]
2025-03-29T11:50:24.971 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.971 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("graphql")]
2025-03-29T11:50:24.971 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("graphql")]
2025-03-29T11:50:24.971 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("graphql")]
2025-03-29T11:50:24.971 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.971 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("elm")]
2025-03-29T11:50:24.971 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("elm")]
2025-03-29T11:50:24.971 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("elm")]
2025-03-29T11:50:24.971 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.971 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("iex")]
2025-03-29T11:50:24.971 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("iex")]
2025-03-29T11:50:24.971 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("iex")]
2025-03-29T11:50:24.971 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.971 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("rescript")]
2025-03-29T11:50:24.971 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("rescript")]
2025-03-29T11:50:24.971 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("rescript")]
2025-03-29T11:50:24.971 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.971 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted before optimization: Seq[E("erlang"), E("erl")]
2025-03-29T11:50:24.971 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted after optimization: Seq[E("erlang"), E("erl")]
2025-03-29T11:50:24.971 regex_cursor::engines::meta::strategy [DEBUG] creating prefilter from 2 literals: [E("erlang"), E("erl")]
2025-03-29T11:50:24.971 regex_cursor::engines::meta::wrappers [DEBUG] PikeVM built
2025-03-29T11:50:24.971 regex_cursor::engines::meta::wrappers [DEBUG] fully compiled forward and reverse DFAs built, 1732 bytes
2025-03-29T11:50:24.971 regex_cursor::engines::meta::strategy [DEBUG] skipping lazy DFA because we have a full DFA
2025-03-29T11:50:24.971 regex_cursor::engines::meta::strategy [DEBUG] skipping reverse anchored optimization because the regex is not always anchored at the end
2025-03-29T11:50:24.971 regex_cursor::engines::meta::strategy [DEBUG] using core strategy
2025-03-29T11:50:24.971 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(3), exact=true) extracted before optimization: Seq[E("hcl"), E("tf"), E("nomad")]
2025-03-29T11:50:24.971 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(3), exact=true) extracted after optimization: Seq[E("hcl"), E("tf"), E("nomad")]
2025-03-29T11:50:24.971 regex_cursor::engines::meta::strategy [DEBUG] creating prefilter from 3 literals: [E("hcl"), E("tf"), E("nomad")]
2025-03-29T11:50:24.971 regex_cursor::engines::meta::wrappers [DEBUG] PikeVM built
2025-03-29T11:50:24.971 regex_cursor::engines::meta::wrappers [DEBUG] fully compiled forward and reverse DFAs built, 4408 bytes
2025-03-29T11:50:24.971 regex_cursor::engines::meta::strategy [DEBUG] skipping lazy DFA because we have a full DFA
2025-03-29T11:50:24.971 regex_cursor::engines::meta::strategy [DEBUG] skipping reverse anchored optimization because the regex is not always anchored at the end
2025-03-29T11:50:24.971 regex_cursor::engines::meta::strategy [DEBUG] using core strategy
2025-03-29T11:50:24.971 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("org")]
2025-03-29T11:50:24.971 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("org")]
2025-03-29T11:50:24.971 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("org")]
2025-03-29T11:50:24.971 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.971 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted before optimization: Seq[E("sol"), E("solidity")]
2025-03-29T11:50:24.971 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("sol")]
2025-03-29T11:50:24.971 regex_cursor::engines::meta::strategy [DEBUG] creating prefilter from 1 literals: [E("sol")]
2025-03-29T11:50:24.971 regex_cursor::engines::meta::wrappers [DEBUG] PikeVM built
2025-03-29T11:50:24.971 regex_cursor::engines::meta::wrappers [DEBUG] fully compiled forward and reverse DFAs built, 1784 bytes
2025-03-29T11:50:24.971 regex_cursor::engines::meta::strategy [DEBUG] skipping lazy DFA because we have a full DFA
2025-03-29T11:50:24.971 regex_cursor::engines::meta::strategy [DEBUG] skipping reverse anchored optimization because the regex is not always anchored at the end
2025-03-29T11:50:24.971 regex_cursor::engines::meta::strategy [DEBUG] using core strategy
2025-03-29T11:50:24.971 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("gleam")]
2025-03-29T11:50:24.971 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("gleam")]
2025-03-29T11:50:24.971 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("gleam")]
2025-03-29T11:50:24.971 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.972 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("ron")]
2025-03-29T11:50:24.972 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("ron")]
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("ron")]
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.972 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("robot")]
2025-03-29T11:50:24.972 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("robot")]
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("robot")]
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.972 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted before optimization: Seq[E("R"), E("r")]
2025-03-29T11:50:24.972 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted after optimization: Seq[E("R"), E("r")]
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] creating prefilter from 2 literals: [E("R"), E("r")]
2025-03-29T11:50:24.972 regex_cursor::engines::meta::wrappers [DEBUG] PikeVM built
2025-03-29T11:50:24.972 regex_cursor::engines::meta::wrappers [DEBUG] fully compiled forward and reverse DFAs built, 568 bytes
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] skipping lazy DFA because we have a full DFA
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] skipping reverse anchored optimization because the regex is not always anchored at the end
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] using core strategy
2025-03-29T11:50:24.972 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted before optimization: Seq[E("Rmd"), E("rmd")]
2025-03-29T11:50:24.972 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted after optimization: Seq[E("Rmd"), E("rmd")]
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] creating prefilter from 2 literals: [E("Rmd"), E("rmd")]
2025-03-29T11:50:24.972 regex_cursor::engines::meta::wrappers [DEBUG] PikeVM built
2025-03-29T11:50:24.972 regex_cursor::engines::meta::wrappers [DEBUG] fully compiled forward and reverse DFAs built, 1336 bytes
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] skipping lazy DFA because we have a full DFA
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] skipping reverse anchored optimization because the regex is not always anchored at the end
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] using core strategy
2025-03-29T11:50:24.972 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("swift")]
2025-03-29T11:50:24.972 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("swift")]
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("swift")]
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.972 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("erb")]
2025-03-29T11:50:24.972 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("erb")]
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("erb")]
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.972 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("ejs")]
2025-03-29T11:50:24.972 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("ejs")]
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("ejs")]
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.972 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("eex")]
2025-03-29T11:50:24.972 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("eex")]
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("eex")]
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.972 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("heex")]
2025-03-29T11:50:24.972 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("heex")]
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("heex")]
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.972 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("sql")]
2025-03-29T11:50:24.972 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("sql")]
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("sql")]
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.972 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("gdscript")]
2025-03-29T11:50:24.972 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("gdscript")]
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("gdscript")]
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.972 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("godot")]
2025-03-29T11:50:24.972 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("godot")]
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("godot")]
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.972 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("nu")]
2025-03-29T11:50:24.972 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("nu")]
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("nu")]
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.972 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("vala")]
2025-03-29T11:50:24.972 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("vala")]
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("vala")]
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.972 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("hare")]
2025-03-29T11:50:24.972 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("hare")]
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("hare")]
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.972 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(4), exact=true) extracted before optimization: Seq[E("dtsi"), E("dts"), E("devicetree"), E("fdt")]
2025-03-29T11:50:24.972 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(4), exact=true) extracted after optimization: Seq[E("dtsi"), E("dts"), E("devicetree"), E("fdt")]
2025-03-29T11:50:24.972 regex_cursor::engines::meta::strategy [DEBUG] creating prefilter from 4 literals: [E("dtsi"), E("dts"), E("devicetree"), E("fdt")]
2025-03-29T11:50:24.973 regex_cursor::engines::meta::wrappers [DEBUG] PikeVM built
2025-03-29T11:50:24.973 regex_cursor::engines::meta::wrappers [DEBUG] fully compiled forward and reverse DFAs built, 3652 bytes
2025-03-29T11:50:24.973 regex_cursor::engines::meta::strategy [DEBUG] skipping lazy DFA because we have a full DFA
2025-03-29T11:50:24.973 regex_cursor::engines::meta::strategy [DEBUG] skipping reverse anchored optimization because the regex is not always anchored at the end
2025-03-29T11:50:24.973 regex_cursor::engines::meta::strategy [DEBUG] using core strategy
2025-03-29T11:50:24.973 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("cairo")]
2025-03-29T11:50:24.973 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("cairo")]
2025-03-29T11:50:24.973 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("cairo")]
2025-03-29T11:50:24.973 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.973 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("cpon")]
2025-03-29T11:50:24.973 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("cpon")]
2025-03-29T11:50:24.973 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("cpon")]
2025-03-29T11:50:24.973 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.973 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("meson")]
2025-03-29T11:50:24.973 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("meson")]
2025-03-29T11:50:24.973 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("meson")]
2025-03-29T11:50:24.973 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.973 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("scheme")]
2025-03-29T11:50:24.973 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("scheme")]
2025-03-29T11:50:24.973 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("scheme")]
2025-03-29T11:50:24.973 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.973 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("verilog")]
2025-03-29T11:50:24.973 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("verilog")]
2025-03-29T11:50:24.973 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("verilog")]
2025-03-29T11:50:24.973 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.973 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("edoc")]
2025-03-29T11:50:24.973 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("edoc")]
2025-03-29T11:50:24.973 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("edoc")]
2025-03-29T11:50:24.973 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.973 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("jsdoc")]
2025-03-29T11:50:24.973 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("jsdoc")]
2025-03-29T11:50:24.973 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("jsdoc")]
2025-03-29T11:50:24.973 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.973 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("openscad")]
2025-03-29T11:50:24.973 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("openscad")]
2025-03-29T11:50:24.973 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("openscad")]
2025-03-29T11:50:24.973 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.973 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("prisma")]
2025-03-29T11:50:24.973 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("prisma")]
2025-03-29T11:50:24.973 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("prisma")]
2025-03-29T11:50:24.973 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.973 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(4), exact=true) extracted before optimization: Seq[E("clojure"), E("clj"), E("edn"), E("boot")]
2025-03-29T11:50:24.973 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(4), exact=true) extracted after optimization: Seq[E("clojure"), E("clj"), E("edn"), E("boot")]
2025-03-29T11:50:24.973 regex_cursor::engines::meta::strategy [DEBUG] creating prefilter from 4 literals: [E("clojure"), E("clj"), E("edn"), E("boot")]
2025-03-29T11:50:24.973 regex_cursor::engines::meta::wrappers [DEBUG] PikeVM built
2025-03-29T11:50:24.973 regex_cursor::engines::meta::wrappers [DEBUG] fully compiled forward and reverse DFAs built, 6328 bytes
2025-03-29T11:50:24.973 regex_cursor::engines::meta::strategy [DEBUG] skipping lazy DFA because we have a full DFA
2025-03-29T11:50:24.973 regex_cursor::engines::meta::strategy [DEBUG] skipping reverse anchored optimization because the regex is not always anchored at the end
2025-03-29T11:50:24.973 regex_cursor::engines::meta::strategy [DEBUG] using core strategy
2025-03-29T11:50:24.973 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(3), exact=true) extracted before optimization: Seq[E("starlark"), E("bzl"), E("bazel")]
2025-03-29T11:50:24.973 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(3), exact=true) extracted after optimization: Seq[E("starlark"), E("bzl"), E("bazel")]
2025-03-29T11:50:24.973 regex_cursor::engines::meta::strategy [DEBUG] creating prefilter from 3 literals: [E("starlark"), E("bzl"), E("bazel")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::wrappers [DEBUG] PikeVM built
2025-03-29T11:50:24.974 regex_cursor::engines::meta::wrappers [DEBUG] fully compiled forward and reverse DFAs built, 3256 bytes
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] skipping lazy DFA because we have a full DFA
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] skipping reverse anchored optimization because the regex is not always anchored at the end
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] using core strategy
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("idr")]
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("idr")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("idr")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("fortran")]
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("fortran")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("fortran")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("ungrammar")]
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("ungrammar")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("ungrammar")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("dot")]
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("dot")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("dot")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("cue")]
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("cue")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("cue")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("slint")]
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("slint")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("slint")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("task")]
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("task")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("task")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("xit")]
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("xit")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("xit")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("esdl")]
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("esdl")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("esdl")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("pascal")]
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("pascal")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("pascal")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("sml")]
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("sml")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("sml")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("ada")]
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("ada")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("ada")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("astro")]
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("astro")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("astro")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("bass")]
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("bass")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("bass")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("d")]
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("d")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("d")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("kdl")]
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("kdl")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("kdl")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("xml")]
2025-03-29T11:50:24.974 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("xml")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("xml")]
2025-03-29T11:50:24.974 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("dtd")]
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("dtd")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("dtd")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("wit")]
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("wit")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("wit")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("env")]
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("env")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("env")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("ini")]
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("ini")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("ini")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("inko")]
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("inko")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("inko")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("mermaid")]
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("mermaid")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("mermaid")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("pony")]
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("pony")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("pony")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("dhall")]
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("dhall")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("dhall")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("sage")]
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("sage")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("sage")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("msbuild")]
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("msbuild")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("msbuild")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("pem")]
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("pem")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("pem")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("tal")]
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("tal")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("tal")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("yuck")]
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("yuck")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("yuck")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("prql")]
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("prql")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("prql")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted before optimization: Seq[E("nasm"), E("asm")]
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted after optimization: Seq[E("nasm"), E("asm")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 2 literals: [E("nasm"), E("asm")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("gas")]
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("gas")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("gas")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("capnp")]
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("capnp")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("capnp")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("smithy")]
2025-03-29T11:50:24.975 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("smithy")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("smithy")]
2025-03-29T11:50:24.975 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.976 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("vhdl")]
2025-03-29T11:50:24.976 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("vhdl")]
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("vhdl")]
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.976 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("rego")]
2025-03-29T11:50:24.976 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("rego")]
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("rego")]
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.976 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("nim")]
2025-03-29T11:50:24.976 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("nim")]
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("nim")]
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.976 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("hurl")]
2025-03-29T11:50:24.976 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("hurl")]
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("hurl")]
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.976 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted before optimization: Seq[E("cl"), E("opencl")]
2025-03-29T11:50:24.976 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted after optimization: Seq[E("cl"), E("opencl")]
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] creating prefilter from 2 literals: [E("cl"), E("opencl")]
2025-03-29T11:50:24.976 regex_cursor::engines::meta::wrappers [DEBUG] PikeVM built
2025-03-29T11:50:24.976 regex_cursor::engines::meta::wrappers [DEBUG] fully compiled forward and reverse DFAs built, 2052 bytes
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] skipping lazy DFA because we have a full DFA
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] skipping reverse anchored optimization because the regex is not always anchored at the end
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] using core strategy
2025-03-29T11:50:24.976 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("just")]
2025-03-29T11:50:24.976 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("just")]
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("just")]
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.976 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("gn")]
2025-03-29T11:50:24.976 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("gn")]
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("gn")]
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.976 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("blueprint")]
2025-03-29T11:50:24.976 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("blueprint")]
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("blueprint")]
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.976 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("forth")]
2025-03-29T11:50:24.976 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("forth")]
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("forth")]
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.976 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("fsharp")]
2025-03-29T11:50:24.976 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("fsharp")]
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("fsharp")]
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.976 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("t32")]
2025-03-29T11:50:24.976 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("t32")]
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("t32")]
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.976 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("webc")]
2025-03-29T11:50:24.976 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("webc")]
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("webc")]
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.976 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted before optimization: Seq[E("typst"), E("typ")]
2025-03-29T11:50:24.976 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted after optimization: Seq[E("typst"), E("typ")]
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] creating prefilter from 2 literals: [E("typst"), E("typ")]
2025-03-29T11:50:24.976 regex_cursor::engines::meta::wrappers [DEBUG] PikeVM built
2025-03-29T11:50:24.976 regex_cursor::engines::meta::wrappers [DEBUG] fully compiled forward and reverse DFAs built, 1604 bytes
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] skipping lazy DFA because we have a full DFA
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] skipping reverse anchored optimization because the regex is not always anchored at the end
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] using core strategy
2025-03-29T11:50:24.976 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("nunjucks")]
2025-03-29T11:50:24.976 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("nunjucks")]
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("nunjucks")]
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.976 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("jinja")]
2025-03-29T11:50:24.976 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("jinja")]
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("jinja")]
2025-03-29T11:50:24.976 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.977 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("jq")]
2025-03-29T11:50:24.977 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("jq")]
2025-03-29T11:50:24.977 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("jq")]
2025-03-29T11:50:24.977 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.977 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("wren")]
2025-03-29T11:50:24.977 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("wren")]
2025-03-29T11:50:24.977 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("wren")]
2025-03-29T11:50:24.977 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.977 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("unison")]
2025-03-29T11:50:24.977 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("unison")]
2025-03-29T11:50:24.977 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("unison")]
2025-03-29T11:50:24.977 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.977 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("agda")]
2025-03-29T11:50:24.977 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("agda")]
2025-03-29T11:50:24.977 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("agda")]
2025-03-29T11:50:24.977 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.977 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("dbml")]
2025-03-29T11:50:24.977 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("dbml")]
2025-03-29T11:50:24.977 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("dbml")]
2025-03-29T11:50:24.977 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.977 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("hoon")]
2025-03-29T11:50:24.977 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("hoon")]
2025-03-29T11:50:24.977 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("hoon")]
2025-03-29T11:50:24.977 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.977 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("koka")]
2025-03-29T11:50:24.977 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("koka")]
2025-03-29T11:50:24.977 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("koka")]
2025-03-29T11:50:24.977 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.977 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("tact")]
2025-03-29T11:50:24.977 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("tact")]
2025-03-29T11:50:24.977 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("tact")]
2025-03-29T11:50:24.977 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.977 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("pkl")]
2025-03-29T11:50:24.977 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("pkl")]
2025-03-29T11:50:24.977 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("pkl")]
2025-03-29T11:50:24.977 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.977 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("fidl")]
2025-03-29T11:50:24.977 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("fidl")]
2025-03-29T11:50:24.977 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("fidl")]
2025-03-29T11:50:24.977 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.977 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted before optimization: Seq[E("pwsh"), E("powershell")]
2025-03-29T11:50:24.977 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(2), exact=true) extracted after optimization: Seq[E("pwsh"), E("powershell")]
2025-03-29T11:50:24.977 regex_cursor::engines::meta::strategy [DEBUG] creating prefilter from 2 literals: [E("pwsh"), E("powershell")]
2025-03-29T11:50:24.977 regex_cursor::engines::meta::wrappers [DEBUG] PikeVM built
2025-03-29T11:50:24.977 regex_cursor::engines::meta::wrappers [DEBUG] fully compiled forward and reverse DFAs built, 3128 bytes
2025-03-29T11:50:24.977 regex_cursor::engines::meta::strategy [DEBUG] skipping lazy DFA because we have a full DFA
2025-03-29T11:50:24.977 regex_cursor::engines::meta::strategy [DEBUG] skipping reverse anchored optimization because the regex is not always anchored at the end
2025-03-29T11:50:24.977 regex_cursor::engines::meta::strategy [DEBUG] using core strategy
2025-03-29T11:50:24.977 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("ld")]
2025-03-29T11:50:24.977 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("ld")]
2025-03-29T11:50:24.977 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("ld")]
2025-03-29T11:50:24.977 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.977 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("tcl")]
2025-03-29T11:50:24.977 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("tcl")]
2025-03-29T11:50:24.977 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("tcl")]
2025-03-29T11:50:24.977 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.977 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("supercollider")]
2025-03-29T11:50:24.977 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("supercollider")]
2025-03-29T11:50:24.977 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("supercollider")]
2025-03-29T11:50:24.977 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.977 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("hbs")]
2025-03-29T11:50:24.977 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("hbs")]
2025-03-29T11:50:24.977 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("hbs")]
2025-03-29T11:50:24.977 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.977 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("ohm")]
2025-03-29T11:50:24.978 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("ohm")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("ohm")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.978 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("earthfile")]
2025-03-29T11:50:24.978 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("earthfile")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("earthfile")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.978 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("adl")]
2025-03-29T11:50:24.978 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("adl")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("adl")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.978 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("ldif")]
2025-03-29T11:50:24.978 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("ldif")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("ldif")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.978 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("move")]
2025-03-29T11:50:24.978 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("move")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("move")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.978 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("pest")]
2025-03-29T11:50:24.978 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("pest")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("pest")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.978 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("circom")]
2025-03-29T11:50:24.978 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("circom")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("circom")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.978 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("cylc")]
2025-03-29T11:50:24.978 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("cylc")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("cylc")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.978 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("spade")]
2025-03-29T11:50:24.978 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("spade")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("spade")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.978 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("koto")]
2025-03-29T11:50:24.978 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("koto")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("koto")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.978 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("gpr")]
2025-03-29T11:50:24.978 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("gpr")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("gpr")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.978 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("nginx")]
2025-03-29T11:50:24.978 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("nginx")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("nginx")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.978 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("codeql")]
2025-03-29T11:50:24.978 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("codeql")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("codeql")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.978 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("gren")]
2025-03-29T11:50:24.978 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("gren")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("gren")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.978 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("fga")]
2025-03-29T11:50:24.978 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("fga")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("fga")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.978 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("ink")]
2025-03-29T11:50:24.978 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("ink")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("ink")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.978 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted before optimization: Seq[E("tla")]
2025-03-29T11:50:24.978 regex_cursor::util::prefilter [DEBUG] prefixes (len=Some(1), exact=true) extracted after optimization: Seq[E("tla")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] trying to bypass regex engine by creating prefilter from 1 literals: [E("tla")]
2025-03-29T11:50:24.978 regex_cursor::engines::meta::strategy [DEBUG] found that the regex can be broken down to a literal search, avoiding the regex engine entirely
2025-03-29T11:50:24.979 globset [DEBUG] glob converted to regex: Glob { glob: "*/*SConstruct", re: "(?-u)^.*/.*SConstruct$", opts: GlobOptions { case_insensitive: false, literal_separator: false, backslash_escape: true, empty_alternates: false }, tokens: Tokens([ZeroOrMore, Literal('/'), ZeroOrMore, Literal('S'), Literal('C'), Literal('o'), Literal('n'), Literal('s'), Literal('t'), Literal('r'), Literal('u'), Literal('c'), Literal('t')]) }
2025-03-29T11:50:24.979 globset [DEBUG] glob converted to regex: Glob { glob: "*/*SConscript", re: "(?-u)^.*/.*SConscript$", opts: GlobOptions { case_insensitive: false, literal_separator: false, backslash_escape: true, empty_alternates: false }, tokens: Tokens([ZeroOrMore, Literal('/'), ZeroOrMore, Literal('S'), Literal('C'), Literal('o'), Literal('n'), Literal('s'), Literal('c'), Literal('r'), Literal('i'), Literal('p'), Literal('t')]) }
2025-03-29T11:50:24.979 globset [DEBUG] glob converted to regex: Glob { glob: "*/*sconstruct", re: "(?-u)^.*/.*sconstruct$", opts: GlobOptions { case_insensitive: false, literal_separator: false, backslash_escape: true, empty_alternates: false }, tokens: Tokens([ZeroOrMore, Literal('/'), ZeroOrMore, Literal('s'), Literal('c'), Literal('o'), Literal('n'), Literal('s'), Literal('t'), Literal('r'), Literal('u'), Literal('c'), Literal('t')]) }
2025-03-29T11:50:24.979 globset [DEBUG] glob converted to regex: Glob { glob: "*/Dockerfile.*", re: "(?-u)^.*/Dockerfile\\..*$", opts: GlobOptions { case_insensitive: false, literal_separator: false, backslash_escape: true, empty_alternates: false }, tokens: Tokens([ZeroOrMore, Literal('/'), Literal('D'), Literal('o'), Literal('c'), Literal('k'), Literal('e'), Literal('r'), Literal('f'), Literal('i'), Literal('l'), Literal('e'), Literal('.'), ZeroOrMore]) }
2025-03-29T11:50:24.979 globset [DEBUG] glob converted to regex: Glob { glob: "*/dockerfile.*", re: "(?-u)^.*/dockerfile\\..*$", opts: GlobOptions { case_insensitive: false, literal_separator: false, backslash_escape: true, empty_alternates: false }, tokens: Tokens([ZeroOrMore, Literal('/'), Literal('d'), Literal('o'), Literal('c'), Literal('k'), Literal('e'), Literal('r'), Literal('f'), Literal('i'), Literal('l'), Literal('e'), Literal('.'), ZeroOrMore]) }
2025-03-29T11:50:24.979 globset [DEBUG] glob converted to regex: Glob { glob: "*/Containerfile.*", re: "(?-u)^.*/Containerfile\\..*$", opts: GlobOptions { case_insensitive: false, literal_separator: false, backslash_escape: true, empty_alternates: false }, tokens: Tokens([ZeroOrMore, Literal('/'), Literal('C'), Literal('o'), Literal('n'), Literal('t'), Literal('a'), Literal('i'), Literal('n'), Literal('e'), Literal('r'), Literal('f'), Literal('i'), Literal('l'), Literal('e'), Literal('.'), ZeroOrMore]) }
2025-03-29T11:50:24.979 globset [DEBUG] glob converted to regex: Glob { glob: "*/containerfile.*", re: "(?-u)^.*/containerfile\\..*$", opts: GlobOptions { case_insensitive: false, literal_separator: false, backslash_escape: true, empty_alternates: false }, tokens: Tokens([ZeroOrMore, Literal('/'), Literal('c'), Literal('o'), Literal('n'), Literal('t'), Literal('a'), Literal('i'), Literal('n'), Literal('e'), Literal('r'), Literal('f'), Literal('i'), Literal('l'), Literal('e'), Literal('.'), ZeroOrMore]) }
2025-03-29T11:50:24.979 globset [DEBUG] glob converted to regex: Glob { glob: "*/.*ignore", re: "(?-u)^.*/\\..*ignore$", opts: GlobOptions { case_insensitive: false, literal_separator: false, backslash_escape: true, empty_alternates: false }, tokens: Tokens([ZeroOrMore, Literal('/'), Literal('.'), ZeroOrMore, Literal('i'), Literal('g'), Literal('n'), Literal('o'), Literal('r'), Literal('e')]) }
2025-03-29T11:50:24.979 globset [DEBUG] glob converted to regex: Glob { glob: "*/BUILD.*", re: "(?-u)^.*/BUILD\\..*$", opts: GlobOptions { case_insensitive: false, literal_separator: false, backslash_escape: true, empty_alternates: false }, tokens: Tokens([ZeroOrMore, Literal('/'), Literal('B'), Literal('U'), Literal('I'), Literal('L'), Literal('D'), Literal('.'), ZeroOrMore]) }
2025-03-29T11:50:24.979 globset [DEBUG] glob converted to regex: Glob { glob: "*/*.tm[Tt]heme", re: "(?-u)^.*/.*\\.tm[Tt]heme$", opts: GlobOptions { case_insensitive: false, literal_separator: false, backslash_escape: true, empty_alternates: false }, tokens: Tokens([ZeroOrMore, Literal('/'), ZeroOrMore, Literal('.'), Literal('t'), Literal('m'), Class { negated: false, ranges: [('T', 'T'), ('t', 't')] }, Literal('h'), Literal('e'), Literal('m'), Literal('e')]) }
2025-03-29T11:50:24.979 globset [DEBUG] glob converted to regex: Glob { glob: "*/.env.*", re: "(?-u)^.*/\\.env\\..*$", opts: GlobOptions { case_insensitive: false, literal_separator: false, backslash_escape: true, empty_alternates: false }, tokens: Tokens([ZeroOrMore, Literal('/'), Literal('.'), Literal('e'), Literal('n'), Literal('v'), Literal('.'), ZeroOrMore]) }
2025-03-29T11:50:24.979 globset [DEBUG] glob converted to regex: Glob { glob: "*/.envrc.*", re: "(?-u)^.*/\\.envrc\\..*$", opts: GlobOptions { case_insensitive: false, literal_separator: false, backslash_escape: true, empty_alternates: false }, tokens: Tokens([ZeroOrMore, Literal('/'), Literal('.'), Literal('e'), Literal('n'), Literal('v'), Literal('r'), Literal('c'), Literal('.'), ZeroOrMore]) }
2025-03-29T11:50:24.980 globset [DEBUG] glob converted to regex: Glob { glob: "*/conf/*/*.{inc,conf}", re: "(?-u)^.*/conf/.*/.*\\.(?:conf|inc)$", opts: GlobOptions { case_insensitive: false, literal_separator: false, backslash_escape: true, empty_alternates: false }, tokens: Tokens([ZeroOrMore, Literal('/'), Literal('c'), Literal('o'), Literal('n'), Literal('f'), Literal('/'), ZeroOrMore, Literal('/'), ZeroOrMore, Literal('.'), Alternates([Tokens([Literal('c'), Literal('o'), Literal('n'), Literal('f')]), Tokens([Literal('i'), Literal('n'), Literal('c')])])]) }
2025-03-29T11:50:24.980 globset [DEBUG] glob converted to regex: Glob { glob: "*/Jenkinsfile.*", re: "(?-u)^.*/Jenkinsfile\\..*$", opts: GlobOptions { case_insensitive: false, literal_separator: false, backslash_escape: true, empty_alternates: false }, tokens: Tokens([ZeroOrMore, Literal('/'), Literal('J'), Literal('e'), Literal('n'), Literal('k'), Literal('i'), Literal('n'), Literal('s'), Literal('f'), Literal('i'), Literal('l'), Literal('e'), Literal('.'), ZeroOrMore]) }
2025-03-29T11:50:24.980 globset [DEBUG] built glob set; 1 literals, 0 basenames, 0 extensions, 0 prefixes, 147 suffixes, 11 required extensions, 14 regexes
2025-03-29T11:50:24.985 helix_tui::backend::crossterm [DEBUG] Detected terminal features in 365.453µs. Enhanced keyboard support: true, Synchronized output support: true. Theme mode updates support: false
2025-03-29T11:50:24.988 helix_view::document [DEBUG] id 1 modified - last saved: 0, current: 0
2025-03-29T11:50:24.990 helix_view::document [DEBUG] id 1 modified - last saved: 0, current: 0
2025-03-29T11:50:24.991 helix_view::document [DEBUG] id 1 modified - last saved: 0, current: 0
2025-03-29T11:50:25.238 helix_term::application [DEBUG] received editor event: IdleTimer
2025-03-29T11:50:25.374 helix_term::application [DEBUG] received editor event: Redraw
2025-03-29T11:50:25.374 helix_view::document [DEBUG] id 1 modified - last saved: 0, current: 0
2025-03-29T11:50:25.991 helix_view::document [DEBUG] id 1 modified - last saved: 0, current: 0
2025-03-29T11:50:28.709 helix_view::document [DEBUG] id 1 modified - last saved: 0, current: 0
2025-03-29T11:50:29.456 helix_view::document [DEBUG] id 1 modified - last saved: 0, current: 0
2025-03-29T11:50:29.661 helix_term::commands::typed [DEBUG] quitting...
2025-03-29T11:50:29.661 helix_view::document [DEBUG] id 1 modified - last saved: 0, current: 0
2025-03-29T11:50:29.707 helix_term::application [DEBUG] received editor event: IdleTimer
2025-03-29T11:50:29.733 helix_term::commands::typed [DEBUG] quitting...
2025-03-29T11:50:29.733 helix_view::document [DEBUG] id 1 modified - last saved: 0, current: 0
2025-03-29T11:50:29.733 helix_term::job [DEBUG] waiting on jobs...
2025-03-29T11:50:29.733 helix_term::job [DEBUG] waiting on jobs...

@RoloEdits
Copy link
Contributor

RoloEdits commented Mar 29, 2025

It might be worth adding an override for some of these features if there is some platform/terminal issues. We do that for undercurl now I believe. Currently though the features are in TerminalFeatures which doesn't have access to any settings that might be in CrosstermBackend or Capabilities. (the actual check for this is done on CrosstermBackend so it can be done just fine with the config passed in and just adding a branch to check in the function)

[editor]
synchronized-output = true
# ...

@the-mikedavis
Copy link
Member Author

WezTerm doesn't yet support the theme extension: wezterm/wezterm#6454. The kitty keyboard protocol is supported but it has to be enabled in config: https://wezterm.org/config/lua/config/enable_kitty_keyboard.html

None of the features can be detected on Windows though since the escape sequence parsing is compiled out (#[cfg(unix)]). I'm not very familiar with the codepaths in crossterm for Windows but I think crossterm will need more work to be able to detect any of these features. It should work though to send the commands like synchronized output and kitty keyboard flags if we have a way to override detection with config.

@the-mikedavis
Copy link
Member Author

the-mikedavis commented Mar 29, 2025

There seems to be an issue with how Ghostty handles the request to figure out the current theme mode:

$ printf '\e[?996n\e[c'
[?62;22c[?997;2n

It's queueing the response for the query so it comes after any other requests. That makes it hard to query for - we'd have to set a timeout to detect terminals that don't support the feature and that would affect time-to-first-render. I'll open an issue with Ghostty.

Edit: looks like this was discussed recently: ghostty-org/ghostty#6738. I'll mark this as a draft until we can figure out how to handle this.

@the-mikedavis the-mikedavis marked this pull request as draft March 29, 2025 19:23
@RoloEdits
Copy link
Contributor

RoloEdits commented Mar 29, 2025

I think overrides definitely need to be added. I added it in my build branch (for the synchronized output) and it seems to work as expected.

I'm not very familiar with the codepaths in crossterm for Windows but I think crossterm will need more work to be able to detect any of these features.

I'll try to take a look at the fork you made and poke around. See if I can't get something together, at least for the features that helix uses.

I was thinking we could use the editor.terminal config option for a way to override based on known capabilities, but hard coding a bunch of terminals is probably not the way.

@RoloEdits
Copy link
Contributor

RoloEdits commented Mar 30, 2025

Something I came across for the kitty protocol is something I also came across for yazi which it handled in sxyazi/yazi#2474

helix will need to do something similar, otherwise if you enable the helix config, lets say a kitty-protocol = true or if wezterm is config.enable_kitty_keyboard = true then you can get

Error: Keyboard progressive enhancement not implemented for the legacy Windows API.

Also another issue (perhaps unrelated idk) is that when clicking on links in helix, say a url, scrolling changes to be (at least it seems) arrow inputs. So rather than scroll the page and have the cursor follow along, scrolling then becomes cursor actions (up and down).

@the-mikedavis
Copy link
Member Author

Error: Keyboard progressive enhancement not implemented for the legacy Windows API.

For this I believe we just need to tweak the impl of Command to say that the escape codes should be used on Windows as well. Yazi is working around the current Command for PushKeyboardEnhancementFlags impl to do that. (Synchronized output sequences do the same - ANSI codes are used on Windows.) helix-editor/crossterm@945b3c5

I wonder if we actually need to care about the winapi stuff anymore. As I understand it, cmd.exe got support for escape sequences in Windows 10 and I believe the Rust compiler hasn't supported anything older than Windows 10 since Feb 2024

@RoloEdits
Copy link
Contributor

RoloEdits commented Apr 1, 2025

So I patched with that change and with config.enable_kitty_keyboard = true and config.allow_win32_input_mode = false (and forcing the keyboard if statements to always true to see the effects).

It started without the error, but when I pressed : I could see ]58, which appears to be correct:
image
But it didn't get interpreted as : in helix.

Am I misunderstanding how this is supposed to work?

@the-mikedavis
Copy link
Member Author

I took a much longer look into this and the problem is that crossterm doesn't "speak VT" on Windows even though it is possible now with ConPTY. It handles key events from the Console API the old way: https://github.com/crossterm-rs/crossterm/blob/36d95b26a26e64b0f8c12edfe11f410a6d56a812/src/event/sys/windows/parse.rs#L204-L296. It also needs to enable VT inputs and attempt to handle key events as possible VT escape sequences like Termwiz does. But all VT parsing code is compiled only on Unix currently.

It's not an easy change to make in crossterm. It's also not easy to switch over to Termwiz sadly. I tried reviving @archseer's work in 7a51085 as the-mikedavis@0a515da but Termwiz has an API which is fairly different from crossterm. Both libraries also depend on the deprecated winapi crate rather than the official windows-sys bindings and neither provides an interface for querying for specific escapes. (Crossterm does actually but it's all private to the crate.)

Neither crate is quite what we want so I've got a new crate that only "speaks VT" in progress which merges the nicer parts of crossterm and Termwiz with a lower-level interface that should be flexible enough to do all of the manipulation and querying we want.

@the-mikedavis
Copy link
Member Author

I've got the new branch for that (☝️) up in #13307 so I will close in favor of that. That PR doesn't include the theme mode stuff (#13281) but I will add it in a follow-up PR. Enabling the theme mode updates is a matter of decset!(Theme) and querying can be done with Csi::Mode(csi::Mode::QueryTheme) and Csi::Mode(csi::Mode::ReportTheme(mode))

@the-mikedavis the-mikedavis deleted the helix-crossterm branch April 8, 2025 18:12
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
None yet
Projects
None yet
3 participants