Tinymist

https://myriad-dreamin.github.io/tinymist
Admin
Tinymist is an integrated language service for Typst, providing a CLI, language server (LSP), and...
Tokens:4,806,740
Snippets:35,235
Trust Score:8.3
Update:1 month ago
Show doc for...
Tokens:
Raw
### append usage example

Source: https://myriad-dreamin.github.io/tinymist/rs/tinymist_std/typst/foundations/struct.IndexMap.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Basic setup for the append method example.

```rust
use indexmap::IndexMap;
```

--------------------------------

### Product implementation example

Source: https://myriad-dreamin.github.io/tinymist/rs/typlite/type.Result.html?search=u32+-%3E+bool

This example demonstrates how to use the product method on a vector of strings, returning an Err if any string cannot be parsed.

```rust
let nums = vec!["5", "10", "1", "2"];
let total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();
assert_eq!(total, Ok(100));
let nums = vec!["5", "10", "one", "2"];
```

--------------------------------

### Using #example in docstring

Source: https://myriad-dreamin.github.io/tinymist/feature/docs.html

Shows how to use the `#example` function in a docstring to provide an associated example. The example content is passed as a string argument.

```typst
#example(`
$ sum f(x) = 10 $
`)
```

--------------------------------

### Start the language server with tinymist lsp

Source: https://myriad-dreamin.github.io/tinymist/feature/cli.html

Starts the language server. Running the CLI without arguments also starts the language server.

```bash
tinymist lsp
```

```bash
tinymist
```

--------------------------------

### Lazy::get example

Source: https://myriad-dreamin.github.io/tinymist/rs/typst_shim/utils/once_cell/sync/struct.Lazy.html?search=std%3A%3Avec

Shows how to get a reference to the result if initialized, returning `None` before initialization.

```rust
use once_cell::sync::Lazy;

let lazy = Lazy::new(|| 92);

assert_eq!(Lazy::get(&lazy), None);
assert_eq!(&*lazy, &92);
assert_eq!(Lazy::get(&lazy), Some(&92));
```

--------------------------------

### is_ok_and method examples

Source: https://myriad-dreamin.github.io/tinymist/rs/typlite/type.Result.html?search=

Examples of is_ok_and() with a predicate, including a case with as_ref().

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.is_ok_and(|x| x > 1), true);

let x: Result<u32, &str> = Ok(0);
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<u32, &str> = Err("hey");
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<String, &str> = Ok("ownership".to_string());
assert_eq!(x.as_ref().is_ok_and(|x| x.len() > 1), true);
println!("still alive {:?}", x);

```

--------------------------------

### partition_point examples

Source: https://myriad-dreamin.github.io/tinymist/rs/tinymist_vfs/struct.Bytes.html?search=

Examples for the `partition_point` method on slices. The first shows basic usage with a predicate, the second shows behavior when all elements match (including empty slices), and the third shows inserting into a sorted vector while maintaining order.

```rust
let v = [1, 2, 3, 3, 5, 6, 7];
let i = v.partition_point(|&x| x < 5);

assert_eq!(i, 4);
assert!(v[..i].iter().all(|&x| x < 5));
assert!(v[i..].iter().all(|&x| !(x < 5)));

```

```rust
let a = [2, 4, 8];
assert_eq!(a.partition_point(|x| x < &100), a.len());
let a: [i32; 0] = [];
assert_eq!(a.partition_point(|x| x < &100), 0);

```

```rust
let mut s = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
let num = 42;
let idx = s.partition_point(|&x| x <= num);
s.insert(idx, num);
assert_eq!(s, [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);

```

--------------------------------

### is_ok method examples

Source: https://myriad-dreamin.github.io/tinymist/rs/typlite/type.Result.html?search=

Examples of is_ok() returning a boolean.

```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_ok(), true);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_ok(), false);

```

--------------------------------

### flatten method examples

Source: https://myriad-dreamin.github.io/tinymist/rs/typlite/type.Result.html?search=

Examples of flatten() for Result<Result<T, E>, E> and its one-level nesting removal.

```rust
let x: Result<Result<&'static str, u32>, u32> = Ok(Ok("hello"));
assert_eq!(Ok("hello"), x.flatten());

let x: Result<Result<&'static str, u32>, u32> = Ok(Err(6));
assert_eq!(Err(6), x.flatten());

let x: Result<Result<&'static str, u32>, u32> = Err(6);
assert_eq!(Err(6), x.flatten());

```

```rust
let x: Result<Result<Result<&'static str, u32>, u32>, u32> = Ok(Ok(Ok("hello")));
assert_eq!(Ok(Ok("hello")), x.flatten());
assert_eq!(Ok("hello"), x.flatten().flatten());

```

--------------------------------

### ServerState start_preview method

Source: https://myriad-dreamin.github.io/tinymist/rs/src/tinymist/tool/preview.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Starts a preview instance by parsing CLI arguments with clap, prepending 'preview' to the argument list.

```rust
    /// Starts a preview instance.
    pub fn start_preview(
        &mut self,
        cli_args: Vec<String>,
        kind: PreviewKind,
    ) -> SchedulableResponse<StartPreviewResponse> {
        // clap parse
        let cli_args = ["preview"]
            .into_iter()
            .chain(cli_args.iter().map(|e| e.as_str()));
```

--------------------------------

### Initialize a static OnceCell with get_or_init

Source: https://myriad-dreamin.github.io/tinymist/rs/typst_shim/utils/once_cell/sync/struct.OnceCell.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows basic usage of `OnceCell::get_or_init` with a static cell and multiple threads. The example demonstrates that `get()` returns `None` before initialization and `Some` after, and that the initialized value is shared across threads.

```rust
use once_cell::sync::OnceCell;

static CELL: OnceCell<String> = OnceCell::new();
assert!(CELL.get().is_none());

std::thread::spawn(|| {
    let value: &String = CELL.get_or_init(|| {
        "Hello, World!".to_string()
    });
    assert_eq!(value, "Hello, World!");
}).join().unwrap();

let value: Option<&String> = CELL.get();
assert!(value.is_some());
assert_eq!(value.unwrap().as_str(), "Hello, World!");
```

--------------------------------

### iter_mut example

Source: https://myriad-dreamin.github.io/tinymist/rs/cmark_writer/error/type.WriteResult.html?search=std%3A%3Avec

Example for the iter_mut method, showing how to get a mutable iterator over the possibly contained value.

```rust
let mut x: Result<u32, &str> = Ok(7);
match x.iter_mut().next() {
    Some(v) => *v = 40,
    None => {}
}
assert_eq!(x, Ok(40));
```

--------------------------------

### start_preview method for ServerState

Source: https://myriad-dreamin.github.io/tinymist/rs/src/tinymist/tool/preview.rs.html

Starts a preview instance by parsing CLI arguments with clap, prepending the `preview` command. Returns a `SchedulableResponse<StartPreviewResponse>`.

```rust
    /// Starts a preview instance.
    pub fn start_preview(
        &mut self,
        cli_args: Vec<String>,
        kind: PreviewKind,
    ) -> SchedulableResponse<StartPreviewResponse> {
        // clap parse
        let cli_args = ["preview"]
            .into_iter()
```

--------------------------------

### Start a preview instance

Source: https://myriad-dreamin.github.io/tinymist/rs/src/tinymist/cmd.rs.html?search=

Handles the `do_start_preview` command, available only with the `preview` feature. It takes CLI arguments as a vector of strings and returns a `SchedulableResponse` with a `StartPreviewResponse`.

```rust
#[cfg(feature = "preview")]
pub fn do_start_preview(
    &mut self,
    mut args: Vec<JsonValue>,
) -> SchedulableResponse<crate::tool::preview::StartPreviewResponse> {
    let cli_args = get_arg_or_default!(args[0] as Vec<String>);
```

--------------------------------

### get example

Source: https://myriad-dreamin.github.io/tinymist/rs/tinymist/project/world/base/vfs/struct.Bytes.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how to use get with an index or range to safely access elements or subslices, returning None for out-of-bounds.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&40), v.get(1));
assert_eq!(Some(&[10, 40][..]), v.get(0..2));
assert_eq!(None, v.get(3));
assert_eq!(None, v.get(0..4));
```

--------------------------------

### Create a DashMap with a specified starting capacity

Source: https://myriad-dreamin.github.io/tinymist/rs/tinymist_std/adt/struct.CHashMap.html?search=std%3A%3Avec

Creates a new DashMap with a specified starting capacity. The example inserts two key-value pairs.

```rust
use dashmap::DashMap;

let mappings = DashMap::with_capacity(2);
mappings.insert(2, 4);
mappings.insert(8, 16);
```

--------------------------------

### ServerState::install_lsp: register preview and trace commands

Source: https://myriad-dreamin.github.io/tinymist/rs/src/tinymist/server.rs.html?search=

Installs LSP handlers by adding commands to the provider. With the 'preview' feature, it registers user commands (tinymist.startDefaultPreview, tinymist.scrollPreview) and internal commands (tinymist.doStartPreview, tinymist.doStartBrowsingPreview, tinymist.doKillPreview). With the 'trace' feature, it adds the tinymist.getDocumentTrace command.

```rust
/// Installs LSP handlers to the language server.
pub fn install_lsp<T: Initializer<S = Self> + AddCommands + 'static>(
    provider: LspBuilder<T>,
) -> LspBuilder<T> {
    type State = ServerState;
    use lsp_types::notification::*;
    use lsp_types::request::*;

    #[cfg(feature = "preview")]
    let provider = provider
        // User commands
        .with_command("tinymist.startDefaultPreview", State::default_preview)
        .with_command("tinymist.scrollPreview", State::scroll_preview)
        // Internal commands
        .with_command("tinymist.doStartPreview", State::do_start_preview)
        .with_command("tinymist.doStartBrowsingPreview", State::browse_preview)
        .with_command("tinymist.doKillPreview", State::kill_preview);

    #[cfg(feature = "trace")]
    let provider = provider
        .with_command("tinymist.getDocumentTrace", State::get_document_trace)
```

--------------------------------

### trim_start_matches examples

Source: https://myriad-dreamin.github.io/tinymist/rs/tinymist_std/typst/diag/struct.EcoString.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows trimming matching prefixes from the start of the string.

```rust
assert_eq!("11foo1bar11".trim_start_matches('1'), "foo1bar11");
assert_eq!("123foo1bar123".trim_start_matches(char::is_numeric), "foo1bar123");
```

--------------------------------

### Rust: ProjectOpts struct and start_project function

Source: https://myriad-dreamin.github.io/tinymist/rs/src/tinymist/tool/project.rs.html?search=u32+-%3E+bool

Defines `ProjectOpts` with optional tokio handle, analysis, config, and feature-gated preview/export fields, plus `start_project` which creates channels, optionally spawns a filesystem watcher, constructs a compiler with handler, and returns a `StartProjectResult` containing a `WatchService`. The preview feature gates the `preview` field, and the export/system features conditionally set up the tokio handle and file watching.

```rust
1//! Project management tools.
2
3use std::sync::Arc;
4
5use parking_lot::Mutex;
6use tinymist_query::analysis::Analysis;
7use tokio::sync::mpsc;
8
9use crate::project::*;
10use crate::{actor::editor::EditorRequest, Config};
11
12/// Options for starting a project.
13#[derive(Default)]
pub struct ProjectOpts {
    /// The tokio runtime handle.
    pub handle: Option<tokio::runtime::Handle>,
    /// The shared preview state.
    pub analysis: Arc<Analysis>,
    /// The shared config.
    pub config: Config,
    /// The shared preview state.
    #[cfg(feature = "preview")]
    pub preview: ProjectPreviewState,
    /// The export target.
    pub export_target: ExportTarget,
}

/// Result of starting a project.
pub struct StartProjectResult<F> {
    /// A future service that runs the project.
    pub service: WatchService<F>,
    /// The interrupt sender.
    pub intr_tx: mpsc::UnboundedSender<LspInterrupt>,
    /// The editor request receiver.
    pub editor_rx: mpsc::UnboundedReceiver<EditorRequest>,
}

// todo: This is only extracted from the `tinymist preview` command, and we need
// to abstract it in future.
/// Starts a project with the given universe.
pub fn start_project<F>(
    verse: LspUniverse,
    opts: Option<ProjectOpts>,
    intr_handler: F,
) -> StartProjectResult<F>
where
    F: FnMut(
        &mut LspProjectCompiler,
        Interrupt<LspCompilerFeat>,
        fn(&mut LspProjectCompiler, Interrupt<LspCompilerFeat>),
    ),
{
    let opts = opts.unwrap_or_default();
    #[cfg(any(feature = "export", feature = "system"))]
    let handle = opts.handle.unwrap_or_else(tokio::runtime::Handle::current);

    let _ = opts.config;

    // type EditorSender = mpsc::UnboundedSender<EditorRequest>;
    let (editor_tx, editor_rx) = mpsc::unbounded_channel();
    let (intr_tx, intr_rx) = tokio::sync::mpsc::unbounded_channel();

    // todo: unify filesystem watcher
    let (dep_tx, dep_rx) = mpsc::unbounded_channel();
    // todo: notify feature?
    #[cfg(feature = "system")]
    {
        let fs_intr_tx = intr_tx.clone();
        handle.spawn(watch_deps(dep_rx, move |event| {
            fs_intr_tx.interrupt(LspInterrupt::Fs(event));
        }));
    }
    #[cfg(not(feature = "system"))]
    {
        let _ = dep_rx;
        log::warn!("Project: system watcher is not enabled, file changes will not be watched");
    }

    // Create the actor
    let compile_handle = Arc::new(CompileHandlerImpl {
        #[cfg(feature = "preview")]
        preview: opts.preview,
        is_standalone: true,
        #[cfg(feature = "export")]
        export: crate::task::ExportTask::new(handle, Some(editor_tx.clone()), opts.config.export()),
        editor_tx,
        client: Arc::new(intr_tx.clone()),

        analysis: opts.analysis,
        status_revision: Mutex::default(),
        notified_revision: Mutex::default(),
    });

    let mut compiler = ProjectCompiler::new(
        verse,
        dep_tx,
        CompileServerOpts {
            handler: compile_handle,
            export_target: opts.export_target,
            syntax_only: opts.config.syntax_only,
            ignore_first_sync: true,
        },
    );

    compiler.primary.reason.by_entry_update = true;

    StartProjectResult {
        service: WatchService {
            compiler,
            intr_rx,
            intr_handler,
        },
        intr_tx,
        editor_rx,
    }
}
```

--------------------------------

### entry

Source: https://myriad-dreamin.github.io/tinymist/rs/typlite/struct.CompileOnceArgs.html?search=u32+-%3E+bool

Get the entry options from the arguments.

```APIDOC
## entry

### Description
Get the entry options from the arguments.

### Method
entry

### Parameters
None

### Returns
- **Result<EntryOpts, Error>** - The entry options or an error.

```

--------------------------------

### trim_start_matches example

Source: https://myriad-dreamin.github.io/tinymist/rs/tinymist_std/typst/diag/struct.EcoString.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates removing characters from the start of a string based on a pattern.

```rust
let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_start_matches(x), "foo1bar12");
```

--------------------------------

### iter_mut example

Source: https://myriad-dreamin.github.io/tinymist/rs/cmark_writer/error/type.WriteResult.html

Shows how to use Result::iter_mut to get a mutable iterator over the possibly contained value. The example demonstrates modifying the Ok value and handling Err.

```rust
let mut x: Result<u32, &str> = Ok(7);
match x.iter_mut().next() {
    Some(v) => *v = 40,
    None => {},
}
assert_eq!(x, Ok(40));

let mut x: Result<u32, &str> = Err("nothing!");
assert_eq!(x.iter_mut().next(), None);
```

--------------------------------

### Configuring Settings with bind

Source: https://myriad-dreamin.github.io/tinymist/rs/tinymist_tests/struct.Settings.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Example showing how to clone current settings, modify them, and apply them to a block of assertions using the bind method.

```rust
use insta;

let mut settings = insta::Settings::clone_current();
settings.set_sort_maps(true);
settings.bind(|| {
    // runs the assertion with the changed settings enabled
    insta::assert_snapshot!(...);
});
```

--------------------------------

### copied method example for Result<&mut T, E>

Source: https://myriad-dreamin.github.io/tinymist/rs/typlite/type.Result.html?search=

Example of copied() on a Result<&mut T, E>.

```rust
let mut val = 12;
let x: Result<&mut i32, i32> = Ok(&mut val);
assert_eq!(x, Ok(&mut 12));
let copied = x.copied();
assert_eq!(copied, Ok(12));

```

--------------------------------

### PreviewState::start

Source: https://myriad-dreamin.github.io/tinymist/rs/tinymist/tool/preview/struct.PreviewState.html?search=

Starts a preview on a given compiler with the provided arguments and builder.

```APIDOC
## PreviewState::start

### Description
Start a preview on a given compiler.

### Method
Method

### Signature
```rust
pub fn start(
    &self,
    args: PreviewCliArgs,
    previewer: PreviewBuilder,
    project_id: ProjectInsId,
    is_primary: bool,
    is_background: bool,
) -> SchedulableResponse<StartPreviewResponse>
```

### Parameters
- **args** (PreviewCliArgs) - Required - The CLI arguments for the preview.
- **previewer** (PreviewBuilder) - Required - The preview builder.
- **project_id** (ProjectInsId) - Required - The project instance ID.
- **is_primary** (bool) - Required - Whether this is the primary preview.
- **is_background** (bool) - Required - Whether this is a background preview.

### Returns
- **SchedulableResponse<StartPreviewResponse>** - The response from starting the preview.
```

--------------------------------

### iter example

Source: https://myriad-dreamin.github.io/tinymist/rs/cmark_writer/error/type.WriteResult.html

Shows how to use Result::iter to get an iterator over the possibly contained value. The example demonstrates that it yields one value for Ok and none for Err.

```rust
let x: Result<u32, &str> = Ok(7);
assert_eq!(x.iter().next(), Some(&7));

let x: Result<u32, &str> = Err("nothing!");
assert_eq!(x.iter().next(), None);
```

--------------------------------

### pub fn get_or_init(&self) -> Option<Font>

Source: https://myriad-dreamin.github.io/tinymist/rs/tinymist_world/font/struct.FontSlot.html?search=std%3A%3Avec

Gets or makes the font load result.

```APIDOC
## `pub fn get_or_init(&self) -> Option<Font>`

### Description
Gets or makes the font load result.

### Signature
`pub fn get_or_init(&self) -> Option<Font>`

### Parameters
- `&self` - The font slot.

### Returns
`Option<Font>` - The font load result, if available.
```

--------------------------------

### Setup workspace and build universe for package docs test

Source: https://myriad-dreamin.github.io/tinymist/rs/src/tinymist_query/docs/package.rs.html?search=std%3A%3Avec

Creates a workspace root, resolves a package, builds a universe with fonts, shadows fixture files, and returns the universe, entry path, and package info. Used as a helper for package documentation tests.

```rust
        workspace_root.as_path().into(),
        Some(VirtualPath::new("lib.typ").expect("valid fixture entrypoint")),
    );
    let registry = LspUniverseBuilder::resolve_package(
        None,
        Some(&CompilePackageArgs {
            package_path: Some(packages_root),
            package_cache_path: None,
        }),
    );
    let fonts = Arc::new(
        LspUniverseBuilder::resolve_fonts(CompileFontArgs {
            ignore_system_fonts: true,
            ..Default::default()
        })
        .expect("fixture font resolver must initialize"),
    );
    let mut verse = LspUniverseBuilder::build(
        entry,
        ExportTarget::Paged,
        Default::default(),
        Default::default(),
        registry,
        fonts,
        None,
        DynAccessModel(Arc::new(SystemAccessModel)),
    );
    for file in ["lib.typ", "a.typ", "b.typ"] {
        let path = workspace_root.join(file);
        let content = std::fs::read_to_string(package_root.join(file))
            .expect("fixture source must be readable");
        verse
            .map_shadow(&path, Bytes::from_string(content))
            .expect("fixture source must be shadowable");
    }
    let package = PackageInfo {
        path: package_root,
        namespace: "local".into(),
        name: "cyclic-docs".into(),
        version: "0.1.0".into(),
    };

    (verse, entry_path, package)
```

--------------------------------

### subslice_range example

Source: https://myriad-dreamin.github.io/tinymist/rs/tinymist_vfs/struct.Bytes.html?search=

Example for the nightly-only `subslice_range` method, showing how to get the range of indices that a subslice points to, useful for extending slice iterators like `slice::split`.

```rust
#![feature(substr_range)]

let nums = &[0, 5, 10, 0, 0, 5];

let mut iter = nums
    .split(|t| *t == 0)
    .map(|n| nums.subslice_range(n).unwrap());

assert_eq!(iter.next(), Some(0..0));
assert_eq!(iter.next(), Some(1..3));
assert_eq!(iter.next(), Some(4..4));
assert_eq!(iter.next(), Some(5..6));

```

--------------------------------

### expect example (panics)

Source: https://myriad-dreamin.github.io/tinymist/rs/cmark_writer/error/type.WriteResult.html

Shows how to use Result::expect to get the contained Ok value, panicking with the given message if Err. The example demonstrates the panic message format.

```rust
let x: Result<u32, &str> = Err("emergency failure");
x.expect("Testing expect"); // panics with `Testing expect: emergency failure`
```

--------------------------------

### Start a preview server with tinymist preview

Source: https://myriad-dreamin.github.io/tinymist/feature/cli.html

Starts a preview server for the given Typst file. See the Arguments section for more details.

```bash
tinymist preview path/to/main.typ
```

--------------------------------

### element_offset examples

Source: https://myriad-dreamin.github.io/tinymist/rs/tinymist_vfs/struct.Bytes.html?search=

Examples for the nightly-only `element_offset` method. The first shows basic usage returning the index of an element reference. The second shows returning `None` when the reference is not aligned to an element boundary.

```rust
#![feature(substr_range)]

let nums: &[u32] = &[1, 7, 1, 1];
let num = &nums[2];

assert_eq!(num, &1);
assert_eq!(nums.element_offset(num), Some(2));

```

```rust
#![feature(substr_range)]

let arr: &[[u32; 2]] = &[[0, 1], [2, 3]];
let flat_arr: &[u32] = arr.as_flattened();

let ok_elm: &[u32; 2] = flat_arr[0..2].try_into().unwrap();
let weird_elm: &[u32; 2] = flat_arr[1..3].try_into().unwrap();

assert_eq!(ok_elm, &[0, 1]);
assert_eq!(weird_elm, &[1, 2]);

assert_eq!(arr.element_offset(ok_elm), Some(0)); // Points to element 0
assert_eq!(arr.element_offset(weird_elm), None); // Points between element 0 and 1

```

--------------------------------

### captures_read_at example

Source: https://myriad-dreamin.github.io/tinymist/rs/tinymist_std/typst/foundations/struct.Regex.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how captures_read_at uses the start offset to consider surrounding context for look-around assertions. The example demonstrates that a match is found with captures_read on a slice but not with captures_read_at on the full haystack.

```rust
use regex::Regex;

let re = Regex::new(r"\bchew\b").unwrap();
let hay = "eschew";
let mut locs = re.capture_locations();
// We get a match here, but it's probably not intended.
assert!(re.captures_read(&mut locs, &hay[2..]).is_some());
// No match because the  assertions take the context into account.
assert!(re.captures_read_at(&mut locs, hay, 2).is_none());
```

--------------------------------

### SystemTime Examples

Source: https://myriad-dreamin.github.io/tinymist/rs/tinymist/project/world/base/vfs/struct.Time.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Code examples demonstrating the usage of SystemTime methods.

```rust
use std::time::SystemTime;

match SystemTime::now().duration_since(UNIX_EPOCH) {
    Ok(n) => println!("{} seconds since the Unix epoch.", n.as_secs()),
    Err(_) => panic!("SystemTime before UNIX_EPOCH!"),
}
```

```rust
use std::time::SystemTime;

let sys_time = SystemTime::now();
```

```rust
use std::time::SystemTime;

let sys_time = SystemTime::now();
let new_sys_time = SystemTime::now();
let difference = new_sys_time.duration_since(sys_time)
    .expect("Clock may have gone backwards");
println!("{difference:?}");
```

```rust
use std::thread::sleep;
use std::time::{Duration, SystemTime};

let sys_time = SystemTime::now();
let one_sec = Duration::from_secs(1);
sleep(one_sec);
assert!(sys_time.elapsed().unwrap() >= one_sec);
```

--------------------------------

### start (LspMessage)

Source: https://myriad-dreamin.github.io/tinymist/rs/sync_ls/struct.LsDriver.html

Starts the language server on the provided connection. If is_replay is true, the server waits for pending requests to finish before exiting.

```APIDOC
## pub fn start(&mut self, inbox: TConnectionRx<LspMessage>, is_replay: bool) -> Result<()>

### Description
Starts the language server on the given connection. If `is_replay` is true, the server will wait for all pending requests to finish before exiting. This is useful for testing the language server. See `transport::MirrorArgs` for information about the record-replay feature.

### Parameters
- **inbox** (TConnectionRx<LspMessage>) - Required - The connection to receive LSP messages from.
- **is_replay** (bool) - Required - Whether to enable record-replay mode.

### Returns
- **Result<()>** - Returns Ok on success, or an error if the operation fails.
```

--------------------------------

### Regex captures_at example

Source: https://myriad-dreamin.github.io/tinymist/rs/tinymist_std/typst/foundations/struct.Regex.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how captures_at accounts for surrounding context via the starting offset.

```rust
use regex::Regex;

let re = Regex::new(r"\bchew\b").unwrap();
let hay = "eschew";
// We get a match here, but it's probably not intended.
assert_eq!(&re.captures(&hay[2..]).unwrap()[0], "chew");
// No match because the  assertions take the context into account.
assert!(re.captures_at(hay, 2).is_none());
```

--------------------------------

### Regex is_match_at example

Source: https://myriad-dreamin.github.io/tinymist/rs/tinymist_std/typst/foundations/struct.Regex.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how is_match_at respects look-around assertions by considering the starting offset.

```rust
use regex::Regex;

let re = Regex::new(r"\bchew\b").unwrap();
let hay = "eschew";
// We get a match here, but it's probably not intended.
assert!(re.is_match(&hay[2..]));
// No match because the  assertions take the context into account.
assert!(!re.is_match_at(hay, 2));
```

--------------------------------

### Mock Workspace Setup Helpers

Source: https://myriad-dreamin.github.io/tinymist/rs/src/tinymist_project/compiler.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Functions to define default file structures and create file snapshots for testing.

```rust
    fn default_files() -> Vec<(&'static str, &'static str)> {
        vec![
            (MAIN, "#import \"dep.typ\": value\n#value"),
            (DEP, "#let value = [before]"),
            (UNRELATED, "#let note = [unchanged]"),
        ]
    }

    fn source_snapshot(source: &str) -> FileSnapshot {
        FileResult::Ok(Bytes::from_string(source.to_owned())).into()
    }

    fn read_error_snapshot(path: PathBuf) -> FileSnapshot {
        FileResult::Err(FileError::NotFound(path)).into()
    }
```

--------------------------------

### OnceBool::get_or_init

Source: https://myriad-dreamin.github.io/tinymist/rs/typst_shim/utils/once_cell/race/struct.OnceBool.html?search=u32+-%3E+bool

Gets the contents of the cell, initializing it with a closure if empty.

```APIDOC
## OnceBool::get_or_init

### Description
Gets the contents of the cell, initializing it with `f` if the cell was empty. If several threads concurrently run `get_or_init`, more than one `f` can be called. However, all threads will return the same value, produced by some `f`.

### Method
get_or_init

### Signature
```rust
pub fn get_or_init<F>(&self, f: F) -> bool
where
    F: FnOnce() -> bool,
```

### Parameters
- **f** (F) - Required - A closure that returns the value to initialize the cell with if empty.

### Returns
- **bool** - The current value of the cell.

```

--------------------------------

### Regex shortest_match_at example

Source: https://myriad-dreamin.github.io/tinymist/rs/tinymist_std/typst/foundations/struct.Regex.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how shortest_match_at uses the starting offset to respect look-around assertions.

```rust
use regex::Regex;

let re = Regex::new(r"\bchew\b").unwrap();
let hay = "eschew";
// We get a match here, but it's probably not intended.
assert_eq!(re.shortest_match(&hay[2..]), Some(4));
// No match because the  assertions take the context into account.
assert_eq!(re.shortest_match_at(hay, 2), None);
```

--------------------------------

### background_preview method for ServerState

Source: https://myriad-dreamin.github.io/tinymist/rs/src/tinymist/tool/preview.rs.html

Starts a background preview instance if enabled in config. Uses default CLI arguments `--data-plane-host=127.0.0.1:23635` and `--invert-colors=auto` when no custom args are provided. Logs errors if the preview fails to start.

```rust
impl ServerState {
    /// Starts a background preview instance.
    pub fn background_preview(&mut self) {
        if !self.config.preview.background.enabled {
            return;
        }

        let args = self.config.preview.background.args.clone();
        let args = args.unwrap_or_else(|| {
            vec![
                "--data-plane-host=127.0.0.1:23635".to_string(),
                "--invert-colors=auto".to_string(),
            ]
        });

        let res = self.start_preview(args, PreviewKind::Background);

        // todo: looks ugly
        self.client.handle.spawn(async move {
            let fut = match res {
                Ok(fut) => fut,
                Err(e) => {
                    log::error!("failed to start background preview: {e:?}");
                    return;
                }
            };
            tokio::pin!(fut);
            let () = fut.as_mut().await;

            if let Some(Err(e)) = fut.as_mut().take_output() {
                log::error!("failed to start background preview: {e:?}");
            }
        });
    }
}
```

--------------------------------

### OnceBool::get_or_try_init

Source: https://myriad-dreamin.github.io/tinymist/rs/typst_shim/utils/once_cell/race/struct.OnceBool.html?search=u32+-%3E+bool

Gets the contents of the cell, initializing it with a fallible closure if empty.

```APIDOC
## OnceBool::get_or_try_init

### Description
Gets the contents of the cell, initializing it with `f` if the cell was empty. If the cell was empty and `f` failed, an error is returned. If several threads concurrently run `get_or_init`, more than one `f` can be called. However, all threads will return the same value, produced by some `f`.

### Method
get_or_try_init

### Signature
```rust
pub fn get_or_try_init<F, E>(&self, f: F) -> Result<bool, E>
where
    F: FnOnce() -> Result<bool, E>,
```

### Parameters
- **f** (F) - Required - A closure that returns a `Result<bool, E>` to initialize the cell with if empty.

### Returns
- **Result<bool, E>** - The current value, or an error if initialization failed.

```

--------------------------------

### Example Entry File Content

Source: https://myriad-dreamin.github.io/tinymist/feature/testing.html

A sample Typst file demonstrating imports, test functions, and panic-on-panic test cases.

```typst
#import "example-hello-world.typ"

#let test-it() = {
  "test"
}

#let panic-on-panic() = {
  panic("this is a panic")
}
```

--------------------------------

### PreviewState::start

Source: https://myriad-dreamin.github.io/tinymist/rs/tinymist/tool/preview/struct.PreviewState.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Starts a preview on a given compiler with the specified arguments and options.

```APIDOC
## PreviewState::start

### Description
Starts a preview on a given compiler.

### Method
Method

### Signature
```rust
pub fn start(&self, args: PreviewCliArgs, previewer: PreviewBuilder, project_id: ProjectInsId, is_primary: bool, is_background: bool) -> SchedulableResponse<StartPreviewResponse>
```

### Parameters
- **args** (PreviewCliArgs) - Required - The CLI arguments for the preview.
- **previewer** (PreviewBuilder) - Required - The preview builder.
- **project_id** (ProjectInsId) - Required - The project instance ID.
- **is_primary** (bool) - Required - Whether this is the primary preview.
- **is_background** (bool) - Required - Whether this is a background preview.

### Returns
- **SchedulableResponse<StartPreviewResponse>** - The response from starting the preview.
```

--------------------------------

### slice::split_inclusive examples: middle match and leading match

Source: https://myriad-dreamin.github.io/tinymist/rs/tinymist/project/world/base/vfs/struct.Bytes.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Two examples for slice::split_inclusive: one with a match in the middle and one with a match at the start. The matched element is included as the terminator of the preceding subslice.

```rust
let slice = [10, 40, 33, 20];
let mut iter = slice.split_inclusive(|num| num % 3 == 0);

assert_eq!(iter.next().unwrap(), &[10, 40, 33]);
assert_eq!(iter.next().unwrap(), &[20]);
assert!(iter.next().is_none());

```

```rust
let slice = [3, 10, 40, 33];
let mut iter = slice.split_inclusive(|num| num % 3 == 0);

assert_eq!(iter.next().unwrap(), &[3]);
assert_eq!(iter.next().unwrap(), &[10, 40, 33]);
assert!(iter.next().is_none());

```

--------------------------------

### start_ (LspMessage)

Source: https://myriad-dreamin.github.io/tinymist/rs/sync_ls/struct.LsDriver.html

Starts the language server on the provided connection.

```APIDOC
## pub fn start_(&mut self, inbox: TConnectionRx<LspMessage>) -> Result<()>

### Description
Starts the language server on the given connection.

### Parameters
- **inbox** (TConnectionRx<LspMessage>) - Required - The connection to receive LSP messages from.

### Returns
- **Result<()>** - Returns Ok on success, or an error if the operation fails.
```

--------------------------------

### Regex find_at example

Source: https://myriad-dreamin.github.io/tinymist/rs/tinymist_std/typst/foundations/struct.Regex.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how find_at uses the starting offset to correctly handle look-around assertions.

```rust
use regex::Regex;

let re = Regex::new(r"\bchew\b").unwrap();
let hay = "eschew";
// We get a match here, but it's probably not intended.
assert_eq!(re.find(&hay[2..]).map(|m| m.range()), Some(0..4));
// No match because the  assertions take the context into account.
assert_eq!(re.find_at(hay, 2), None);
```

--------------------------------

### len() example

Source: https://myriad-dreamin.github.io/tinymist/rs/tinymist_std/typst/diag/struct.EcoString.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how to get the byte length of a string. Note that the length is in bytes, not characters or graphemes.

```rust
let len = "foo".len();
assert_eq!(3, len);

assert_eq!("ƒoo".len(), 4); // fancy f!
assert_eq!("ƒoo".chars().count(), 3);
```

--------------------------------

### HashSet with_hasher example

Source: https://myriad-dreamin.github.io/tinymist/rs/tinymist_std/hash/type.FxHashSet.html?search=

Example showing how to create a HashSet with a custom hasher.

```rust
use std::collections::HashSet;
use std::hash::RandomState;

let s = RandomState::new();
let mut set = HashSet::with_hasher(s);
set.insert(2);
```

--------------------------------

### ServerState background_preview method

Source: https://myriad-dreamin.github.io/tinymist/rs/src/tinymist/tool/preview.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Starts a background preview instance if enabled, using default args if none provided, and spawns a task to handle the result.

```rust
impl ServerState {
    /// Starts a background preview instance.
    pub fn background_preview(&mut self) {
        if !self.config.preview.background.enabled {
            return;
        }

        let args = self.config.preview.background.args.clone();
        let args = args.unwrap_or_else(|| {
            vec![
                "--data-plane-host=127.0.0.1:23635".to_string(),
                "--invert-colors=auto".to_string(),
            ]
        });

        let res = self.start_preview(args, PreviewKind::Background);

        // todo: looks ugly
        self.client.handle.spawn(async move {
            let fut = match res {
                Ok(fut) => fut,
                Err(e) => {
                    log::error!("failed to start background preview: {e:?}");
                    return;
                }
            };
            tokio::pin!(fut);
            let () = fut.as_mut().await;

            if let Some(Err(e)) = fut.as_mut().take_output() {
                log::error!("failed to start background preview: {e:?}");
            }
        });
    }
```

--------------------------------

### Lazy::get_mut example

Source: https://myriad-dreamin.github.io/tinymist/rs/typst_shim/utils/once_cell/sync/struct.Lazy.html?search=std%3A%3Avec

Shows how to get a mutable reference to the result if initialized, returning `None` before initialization.

```rust
use once_cell::sync::Lazy;

let mut lazy = Lazy::new(|| 92);

assert_eq!(Lazy::get_mut(&mut lazy), None);
assert_eq!(&*lazy, &92);
assert_eq!(Lazy::get_mut(&mut lazy), Some(&mut 92));
```
Tokens:
Raw