release: v0.0.62

.cargo/config.toml

@@ -1,2 +0,0 @@
-[build]
-rustflags = ["-C", "target-cpu=native"]

.gitignore

@@ -3,6 +3,7 @@
 
 # Builds
 target
+dist
 
 # Copies
 *\ copy*

Cargo.toml

@@ -4,7 +4,7 @@ members = ["crates/*"]
 package.description = "The Bitcoin Research Kit is a suite of tools designed to extract, compute and display data stored on a Bitcoin Core node"
 package.license = "MIT"
 package.edition = "2024"
-package.version = "0.0.44"
+package.version = "0.0.62"
 package.homepage = "https://bitcoinresearchkit.org"
 package.repository = "https://github.com/bitcoinresearchkit/brk"
 
@@ -22,26 +22,27 @@ axum = "0.8.4"
 bincode = { version = "2.0.1", features = ["serde"] }
 bitcoin = { version = "0.32.6", features = ["serde"] }
 bitcoincore-rpc = "0.19.0"
-brk_cli = { version = "0", path = "crates/brk_cli" }
-brk_computer = { version = "0", path = "crates/brk_computer" }
-brk_core = { version = "0", path = "crates/brk_core" }
-brk_exit = { version = "0", path = "crates/brk_exit" }
-brk_fetcher = { version = "0", path = "crates/brk_fetcher" }
-brk_indexer = { version = "0", path = "crates/brk_indexer" }
-brk_logger = { version = "0", path = "crates/brk_logger" }
-brk_parser = { version = "0", path = "crates/brk_parser" }
-brk_query = { version = "0", path = "crates/brk_query" }
-brk_server = { version = "0", path = "crates/brk_server" }
-brk_state = { version = "0", path = "crates/brk_state" }
-brk_store = { version = "0", path = "crates/brk_store" }
-brk_vec = { version = "0", path = "crates/brk_vec" }
+brk_bundler = { version = "0.0.62", path = "crates/brk_bundler" }
+brk_cli = { version = "0.0.62", path = "crates/brk_cli" }
+brk_computer = { version = "0.0.62", path = "crates/brk_computer" }
+brk_core = { version = "0.0.62", path = "crates/brk_core" }
+brk_exit = { version = "0.0.62", path = "crates/brk_exit" }
+brk_fetcher = { version = "0.0.62", path = "crates/brk_fetcher" }
+brk_indexer = { version = "0.0.62", path = "crates/brk_indexer" }
+brk_logger = { version = "0.0.62", path = "crates/brk_logger" }
+brk_parser = { version = "0.0.62", path = "crates/brk_parser" }
+brk_query = { version = "0.0.62", path = "crates/brk_query" }
+brk_server = { version = "0.0.62", path = "crates/brk_server" }
+brk_state = { version = "0.0.62", path = "crates/brk_state" }
+brk_store = { version = "0.0.62", path = "crates/brk_store" }
+brk_vec = { version = "0.0.62", path = "crates/brk_vec" }
 byteview = "=0.6.1"
-clap = { version = "4.5.39", features = ["string"] }
-clap_derive = "4.5.32"
+clap = { version = "4.5.40", features = ["string"] }
+clap_derive = "4.5.40"
 color-eyre = "0.6.5"
 derive_deref = "1.1.1"
 fjall = "2.11.0"
-jiff = "0.2.14"
+jiff = "0.2.15"
 log = { version = "0.4.27" }
 minreq = { version = "2.13.4", features = ["https", "serde_json"] }
 rayon = "1.10.0"

README.md

@@ -31,28 +31,22 @@
   </a>
 </p>
 
-> **WARNING**
->
-> This project is still a work in progress and while it's much better in many ways than its previous version ([kibo v0.5](https://github.com/kibo-money/kibo)), it doesn't yet include all of those datasets. If you're interested in having everything right now, please use the latter until feature parity is achieved.
->
-> The explorer part (mempool.space/electrs) is also not viable just yet.
->
-> Stay tuned and please be patient, it's a lot of work !
+The Bitcoin Research Kit is a high-performance toolchain designed to parse, index, compute, serve and visualize data from a Bitcoin node, enabling users to gain deeper insights into the Bitcoin network.
 
-The Bitcoin Research Kit is a high-performance toolchain designed to parse, index, compute, serve and visualize data from a Bitcoin Core node, enabling users to gain deeper insights into the Bitcoin network.
-
-In other words it's an alternative to [Glassnode](https://glassnode.com), [mempool.space](https://mempool.space/) and [electrs](https://github.com/romanz/electrs) all in one package with a particular focus on simplicity and the self-hosting experience.
+In other words it's an alternative to [Glassnode](https://glassnode.com), [mempool.space](https://mempool.space/) (soon) and [electrs](https://github.com/romanz/electrs) (soon) all in one package with a particular focus on simplicity and ease of use.
 
 The toolkit can be used in various ways to accommodate as many needs as possible:
 
-- **[Website](https://kibo.money)** \
-  Everyone is welcome to visit [kibo.money](https://kibo.money) which is the official showcase of the suite's capabilities and served by default when running BRK. \
-  Researchers and developers are free to use the API which endpoints documentation can be found [here](https://github.com/bitcoinresearchkit/brk/tree/main/crates/brk_server#endpoints). \
-  As a token of gratitude to the community and to stimulate curiosity, both the website and the API are entirely free, allowing anyone to use them.
+- **[Website](https://bitcoinresearchkit.org)** \
+  Everyone is welcome to visit the official instance and showcase of the suite's capabilities. \
+  It has a wide range of functionalities including charts, tables and simulations which you can visit for free and without the need for an account. \
+  Also available at: [kibo.money](https://kibo.money) // [satonomics.xyz](https://satonomics.xyz)
+- **[API](https://github.com/bitcoinresearchkit/brk/tree/main/crates/brk_server#endpoints)** \
+  Researchers and developers are free to use BRK's public API with ![Datasets variant count](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fbitcoinresearchkit.org%2Fapi%2Fvecs%2Fvariant-count&query=%24&style=flat&label=%20&color=white) dataset variants at your disposal. \
+  Just like the website, it's entirely free, with no authentication or rate-limiting.
 - **[CLI](https://crates.io/crates/brk_cli)** \
-  Node runners are strongly encouraged to try out and self-host their own instance. \
-  A lot of effort has gone into making this as easy as possible. \
-  For more information visit: [`brk_cli`](https://crates.io/crates/brk_cli)
+  Node runners are strongly encouraged to try out and self-host their own instance using BRK's command line interface. \
+  The CLI has multiple cogs available for users to tweak to adapt to all situations with even the possibility for web developers to create their own custom website which could later on be added as an alternative front-end.
 - **[Crates](https://crates.io/crates/brk)** \
   Rust developers have access to a wide range crates, each built upon one another with its own specific purpose, enabling independent use and offering great flexibility.
   PRs are welcome, especially if their goal is to introduce additional datasets.
@@ -77,22 +71,15 @@ In contrast, existing alternatives tend to be either [very costly](https://studi
 - [`brk_state`](https://crates.io/crates/brk_state): Various states used mainly by the computer
 - [`brk_store`](https://crates.io/crates/brk_store): A thin wrapper around [`fjall`](https://crates.io/crates/fjall)
 - [`brk_vec`](https://crates.io/crates/brk_vec): A push-only, truncable, compressable, saveable Vec
-
-## Acknowledgments
-
-Deepest gratitude to the [Open Sats](https://opensats.org/) public charity. Their grant — from December 2024 to the present — has been critical in sustaining this project.
-
-Heartfelt thanks go out to every donor on [Nostr](https://primal.net/p/npub1jagmm3x39lmwfnrtvxcs9ac7g300y3dusv9lgzhk2e4x5frpxlrqa73v44) and [Geyser.fund](https://geyser.fund/project/brk) whose support has ensured the availability of the [kibo.money](https://kibo.money) public instance.
+- [`brk_bundler`](https://crates.io/crates/brk_bundler): A thin wrapper around [`rolldown`](https://rolldown.rs/)
 
 ## Hosting as a service
 
-*Soon™*
-
 If you'd like to have your own instance hosted for you please contact [hosting@bitcoinresearchkit.org](mailto:hosting@bitcoinresearchkit.org).
 
 - 2 separate dedicated servers (1 GB/s each) with different ISPs and Cloudflare integration for enhanced performance and optimal availability
 - 99.99% SLA
-- Configurated for speed (`raw + eager`)
+- Configured for speed
 - Updates delivered at your convenience
 - Direct communication for feature requests and support
 - Bitcoin Core or Knots with desired version
@@ -101,6 +88,12 @@ If you'd like to have your own instance hosted for you please contact [hosting@b
 
 Pricing: `0.01 BTC / month` *or* `0.1 BTC / year`
 
+## Acknowledgments
+
+Deepest gratitude to the [Open Sats](https://opensats.org/) public charity. Their grant — from December 2024 to the present — has been critical in sustaining this project.
+
+Heartfelt thanks go out to every donor on [Nostr](https://primal.net/p/npub1jagmm3x39lmwfnrtvxcs9ac7g300y3dusv9lgzhk2e4x5frpxlrqa73v44) and [Geyser.fund](https://geyser.fund/project/brk) whose support has ensured the availability of the [kibo.money](https://kibo.money) public instance.
+
 ## Donate
 
 [`bc1q09 8zsm89 m7kgyz e338vf ejhpdt 92ua9p 3peuve`](bitcoin:bc1q098zsm89m7kgyze338vfejhpdt92ua9p3peuve)

crates/brk/Cargo.toml

@@ -10,6 +10,7 @@ version.workspace = true
 
 [features]
 full = [
+    "bundler",
     "core",
     "computer",
     "exit",
@@ -23,6 +24,7 @@ full = [
     "store",
     "vec",
 ]
+bundler = ["brk_bundler"]
 core = ["brk_core"]
 computer = ["brk_computer"]
 exit = ["brk_exit"]
@@ -37,6 +39,7 @@ store = ["brk_store"]
 vec = ["brk_vec"]
 
 [dependencies]
+brk_bundler = { workspace = true, optional = true }
 brk_cli = { workspace = true }
 brk_core = { workspace = true, optional = true }
 brk_computer = { workspace = true, optional = true }

crates/brk/examples/main.rs

@@ -0,0 +1 @@
+fn main() {}

crates/brk/src/lib.rs

@@ -1,5 +1,12 @@
 #![doc = include_str!(concat!("../", env!("CARGO_PKG_README")))]
 
+#[cfg(feature = "bundler")]
+#[doc(inline)]
+pub use brk_bundler as bundler;
+
+#[doc(inline)]
+pub use brk_cli as cli;
+
 #[cfg(feature = "core")]
 #[doc(inline)]
 pub use brk_core as core;

crates/brk_bundler/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "brk_bundler"
+description = "A thin wrapper around rolldown"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+homepage.workspace = true
+repository.workspace = true
+
+[dependencies]
+log = { workspace = true }
+notify = "8.0.0"
+brk_rolldown = "0.0.1"
+sugar_path = "1.2.0"
+tokio = { workspace = true }

crates/brk_bundler/src/lib.rs

@@ -0,0 +1,144 @@
+use std::{fs, io, path::Path, sync::Arc};
+
+use brk_rolldown::{Bundler, BundlerOptions, RawMinifyOptions, SourceMapType};
+use log::error;
+use notify::{EventKind, RecursiveMode, Watcher};
+use sugar_path::SugarPath;
+use tokio::sync::Mutex;
+
+const VERSION: &str = env!("CARGO_PKG_VERSION");
+
+pub async fn bundle(websites_path: &Path, source_folder: &str, watch: bool) -> io::Result<()> {
+    let source_path = websites_path.join(source_folder);
+    let dist_path = websites_path.join("dist");
+
+    let _ = fs::remove_dir_all(&dist_path);
+    copy_dir_all(&source_path, &dist_path)?;
+
+    let source_scripts = format!("./{source_folder}/scripts");
+    let source_entry = format!("{source_scripts}/entry.js");
+
+    let absolute_websites_path = websites_path.absolutize();
+
+    let mut bundler = Bundler::new(BundlerOptions {
+        input: Some(vec![source_entry.into()]),
+        dir: Some("./dist/scripts".to_string()),
+        cwd: Some(absolute_websites_path),
+        minify: Some(RawMinifyOptions::Bool(true)),
+        sourcemap: Some(SourceMapType::File),
+        ..Default::default()
+    });
+
+    bundler.write().await.unwrap();
+
+    let absolute_source_index_path = source_path.join("index.html").absolutize();
+    let absolute_source_index_path_clone = absolute_source_index_path.clone();
+    let absolute_source_path = source_path.absolutize();
+    let absolute_source_path_clone = absolute_source_path.clone();
+    let absolute_source_scripts_path = websites_path.join(source_scripts).absolutize();
+    let absolute_source_sw_path = source_path.join("service-worker.js").absolutize();
+    let absolute_source_sw_path_clone = absolute_source_sw_path.clone();
+
+    let absolute_dist_entry_path = dist_path.join("scripts/entry.js").absolutize();
+    let absolute_dist_index_path = dist_path.join("index.html").absolutize();
+    let absolute_dist_path = dist_path.absolutize();
+    let absolute_dist_path_clone = absolute_dist_path.clone();
+    let absolute_dist_sw_path = dist_path.join("service-worker.js").absolutize();
+
+    let write_index = move || {
+        let mut contents = fs::read_to_string(&absolute_source_index_path).unwrap();
+
+        if let Ok(entry) = fs::read_to_string(absolute_dist_path_clone.join("scripts/entry.js")) {
+            if let Some(start) = entry.find("main") {
+                if let Some(end) = entry.find(".js") {
+                    let main_hashed = &entry[start..end];
+                    contents = contents.replace("/scripts/main.js", &format!("/scripts/{main_hashed}.js"));
+                }
+            }
+        }
+
+        let _ = fs::write(&absolute_dist_index_path, contents);
+    };
+
+    let write_sw = move || {
+        let contents = fs::read_to_string(&absolute_source_sw_path)
+            .unwrap()
+            .replace("__VERSION__", &format!("v{VERSION}"));
+        let _ = fs::write(&absolute_dist_sw_path, contents);
+    };
+
+    write_index();
+    write_sw();
+
+    if !watch {
+        return Ok(());
+    }
+
+    tokio::spawn(async move {
+        let write_index_clone = write_index.clone();
+
+        let mut entry_watcher = notify::recommended_watcher(
+            move |res: Result<notify::Event, notify::Error>| match res {
+                Ok(_) => write_index_clone(),
+                Err(e) => error!("watch error: {:?}", e),
+            },
+        )
+        .unwrap();
+
+        entry_watcher
+            .watch(&absolute_dist_entry_path, RecursiveMode::Recursive)
+            .unwrap();
+
+        let mut source_watcher = notify::recommended_watcher(
+            move |res: Result<notify::Event, notify::Error>| match res {
+                Ok(event) => match event.kind {
+                    EventKind::Create(_) => event.paths,
+                    EventKind::Modify(_) => event.paths,
+                    _ => vec![],
+                }
+                .into_iter()
+                .filter(|path| path.starts_with(&absolute_source_path))
+                .filter(|path| !path.starts_with(&absolute_source_scripts_path))
+                .for_each(|source_path| {
+                    let suffix = source_path.strip_prefix(&absolute_source_path).unwrap();
+                    let dist_path = absolute_dist_path.join(suffix);
+
+                    if source_path == absolute_source_index_path_clone {
+                        write_index();
+                    } else if source_path == absolute_source_sw_path_clone {
+                        write_sw();
+                    } else {
+                        let _ = fs::copy(&source_path, &dist_path);
+                    }
+                }),
+                Err(e) => error!("watch error: {:?}", e),
+            },
+        )
+        .unwrap();
+
+        source_watcher
+            .watch(&absolute_source_path_clone, RecursiveMode::Recursive)
+            .unwrap();
+
+        let watcher =
+            brk_rolldown::Watcher::new(vec![Arc::new(Mutex::new(bundler))], None).unwrap();
+
+        watcher.start().await;
+    });
+
+    Ok(())
+}
+
+fn copy_dir_all(src: impl AsRef<Path>, dst: impl AsRef<Path>) -> io::Result<()> {
+    fs::create_dir_all(&dst)?;
+    for entry in fs::read_dir(src)? {
+        let entry = entry?;
+        let ty = entry.file_type()?;
+        if ty.is_dir() {
+            copy_dir_all(entry.path(), dst.as_ref().join(entry.file_name()))?;
+        } else {
+            fs::copy(entry.path(), dst.as_ref().join(entry.file_name()))?;
+        }
+    }
+    Ok(())
+}

crates/brk_cli/src/lib.rs

@@ -1,4 +1,4 @@
-use std::fs;
+use std::{fs, thread};
 
 use brk_core::{dot_brk_log_path, dot_brk_path};
 use brk_query::Params as QueryArgs;
@@ -20,9 +20,9 @@ struct Cli {
 
 #[derive(Subcommand, Debug)]
 enum Commands {
-    /// Run the indexer, computer and server
+    /// Run the indexer, computer and server, use `run -h` for more information
     Run(RunConfig),
-    /// Query generated datasets via the `run` command in a similar fashion as the server's API
+    /// Query generated datasets via the `run` command in a similar fashion as the server's API, use `query -h` for more information
     Query(QueryArgs),
 }
 
@@ -35,8 +35,12 @@ pub fn main() -> color_eyre::Result<()> {
 
     let cli = Cli::parse();
 
-    match cli.command {
-        Commands::Run(args) => run(args),
-        Commands::Query(args) => query(args),
-    }
+    thread::Builder::new()
+        .stack_size(128 * 1024 * 1024)
+        .spawn(|| match cli.command {
+            Commands::Run(args) => run(args),
+            Commands::Query(args) => query(args),
+        })?
+        .join()
+        .unwrap()
 }

crates/brk_cli/src/query.rs

@@ -10,7 +10,7 @@ pub fn query(params: QueryParams) -> color_eyre::Result<()> {
 
     let format = config.format();
 
-    let mut indexer = Indexer::new(&config.outputsdir(), format, config.check_collisions())?;
+    let mut indexer = Indexer::new(&config.outputsdir(), config.check_collisions())?;
     indexer.import_vecs()?;
 
     let mut computer = Computer::new(&config.outputsdir(), config.fetcher(), format);
@@ -19,12 +19,14 @@ pub fn query(params: QueryParams) -> color_eyre::Result<()> {
     let query = Query::build(&indexer, &computer);
 
     let index = Index::try_from(params.index.as_str())?;
-
     let ids = params.values.iter().map(|s| s.as_str()).collect::<Vec<_>>();
+    let from = params.from();
+    let to = params.to();
+    let format = params.format();
 
-    let res = query.search_and_format(index, &ids, params.from, params.to, params.format)?;
+    let res = query.search_and_format(index, &ids, from, to, format)?;
 
-    if params.format.is_some() {
+    if format.is_some() {
         println!("{}", res);
     } else {
         println!(

crates/brk_cli/src/run.rs

@@ -1,13 +1,13 @@
 use std::{
     fs,
     path::{Path, PathBuf},
-    thread::{self, sleep},
+    thread::sleep,
     time::Duration,
 };
 
 use bitcoincore_rpc::{self, Auth, Client, RpcApi};
 use brk_computer::Computer;
-use brk_core::{default_bitcoin_path, default_brk_path, dot_brk_path};
+use brk_core::{default_bitcoin_path, default_brk_path, default_on_error, dot_brk_path};
 use brk_exit::Exit;
 use brk_fetcher::Fetcher;
 use brk_indexer::Indexer;
@@ -29,7 +29,7 @@ pub fn run(config: RunConfig) -> color_eyre::Result<()> {
 
     let format = config.format();
 
-    let mut indexer = Indexer::new(&config.outputsdir(), format, config.check_collisions())?;
+    let mut indexer = Indexer::new(&config.outputsdir(), config.check_collisions())?;
     indexer.import_stores()?;
     indexer.import_vecs()?;
 
@@ -49,130 +49,143 @@ pub fn run(config: RunConfig) -> color_eyre::Result<()> {
         Ok(())
     };
 
-    let f = move || -> color_eyre::Result<()> {
-        let mut computer = Computer::new(&config.outputsdir(), config.fetcher(), format);
-        computer.import_stores(&indexer)?;
-        computer.import_vecs(&indexer, config.computation())?;
+    let mut computer = Computer::new(&config.outputsdir(), config.fetcher(), format);
+    computer.import_stores(&indexer)?;
+    computer.import_vecs(&indexer, config.computation())?;
 
-        tokio::runtime::Builder::new_multi_thread()
-            .enable_all()
-            .build()?
-            .block_on(async {
-                let server = if config.serve() {
-                    let served_indexer = indexer.clone();
-                    let served_computer = computer.clone();
+    tokio::runtime::Builder::new_multi_thread()
+        .enable_all()
+        .build()?
+        .block_on(async {
+            let server = if config.serve() {
+                let served_indexer = indexer.clone();
+                let served_computer = computer.clone();
 
-                    let server = Server::new(served_indexer, served_computer, config.website())?;
+                let server = Server::new(served_indexer, served_computer, config.website())?;
 
-                    let opt = Some(tokio::spawn(async move {
-                        server.serve().await.unwrap();
-                    }));
+                let watch = config.watch();
+                let opt = Some(tokio::spawn(async move {
+                    server.serve(watch).await.unwrap();
+                }));
 
-                    sleep(Duration::from_secs(1));
+                sleep(Duration::from_secs(1));
 
-                    opt
-                } else {
-                    None
-                };
+                opt
+            } else {
+                None
+            };
 
-                if config.process() {
-                    loop {
-                        wait_for_synced_node()?;
+            if config.process() {
+                loop {
+                    wait_for_synced_node()?;
 
-                        let block_count = rpc.get_block_count()?;
+                    let block_count = rpc.get_block_count()?;
 
-                        info!("{} blocks found.", block_count + 1);
+                    info!("{} blocks found.", block_count + 1);
 
-                        let starting_indexes = indexer.index(&parser, rpc, &exit)?;
+                    let starting_indexes = indexer.index(&parser, rpc, &exit)?;
 
-                        computer.compute(&mut indexer, starting_indexes, &exit)?;
+                    computer.compute(&mut indexer, starting_indexes, &exit)?;
 
-                        if let Some(delay) = config.delay() {
-                            sleep(Duration::from_secs(delay))
-                        }
+                    if let Some(delay) = config.delay() {
+                        sleep(Duration::from_secs(delay))
+                    }
 
-                        info!("Waiting for new blocks...");
+                    info!("Waiting for new blocks...");
 
-                        while block_count == rpc.get_block_count()? {
-                            sleep(Duration::from_secs(1))
-                        }
+                    while block_count == rpc.get_block_count()? {
+                        sleep(Duration::from_secs(1))
                     }
                 }
+            }
 
-                if let Some(handle) = server {
-                    handle.await.unwrap();
-                }
+            if let Some(handle) = server {
+                handle.await.unwrap();
+            }
 
-                Ok(())
-            })
-    };
-
-    thread::Builder::new()
-        .stack_size(128 * 1024 * 1024)
-        .spawn(f)?
-        .join()
-        .unwrap()
+            Ok(())
+        })
 }
 
 #[derive(Parser, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Deserialize, Serialize)]
 pub struct RunConfig {
     /// Bitcoin main directory path, defaults: ~/.bitcoin, ~/Library/Application\ Support/Bitcoin, saved
+    #[serde(default, deserialize_with = "default_on_error")]
     #[arg(long, value_name = "PATH")]
     bitcoindir: Option<String>,
 
     /// Bitcoin blocks directory path, default: --bitcoindir/blocks, saved
+    #[serde(default, deserialize_with = "default_on_error")]
     #[arg(long, value_name = "PATH")]
     blocksdir: Option<String>,
 
     /// Bitcoin Research Kit outputs directory path, default: ~/.brk, saved
+    #[serde(default, deserialize_with = "default_on_error")]
     #[arg(long, value_name = "PATH")]
     brkdir: Option<String>,
 
-    /// Executed by the runner, default: all, saved
+    /// Activated services, default: all, saved
+    #[serde(default, deserialize_with = "default_on_error")]
     #[arg(short, long)]
-    mode: Option<Mode>,
+    services: Option<Services>,
 
-    /// Computation mode for compatible datasets, `lazy` computes data whenever requested without saving it, `eager` computes the data once and saves it to disk, default: Lazy, saved
+    /// Computation of computed datasets, `lazy` computes data whenever requested without saving it, `eager` computes the data once and saves it to disk, default: `lazy`, saved
+    #[serde(default, deserialize_with = "default_on_error")]
     #[arg(short, long)]
     computation: Option<Computation>,
 
-    /// Activate compression of datasets, set to true to save disk space or false if prioritize speed, default: true, saved
-    #[arg(short, long, value_name = "FORMAT")]
+    /// Format of computed datasets, `compressed` to save disk space (experimental), `raw` to prioritize speed, default: `raw`, saved
+    #[serde(default, deserialize_with = "default_on_error")]
+    #[arg(short, long)]
     format: Option<Format>,
 
     /// Activate fetching prices from exchanges APIs and the computation of all related datasets, default: true, saved
+    #[serde(default, deserialize_with = "default_on_error")]
     #[arg(short = 'F', long, value_name = "BOOL")]
     fetch: Option<bool>,
 
     /// Website served by the server (if active), default: default, saved
+    #[serde(default, deserialize_with = "default_on_error")]
     #[arg(short, long)]
     website: Option<Website>,
 
     /// Bitcoin RPC ip, default: localhost, saved
+    #[serde(default, deserialize_with = "default_on_error")]
     #[arg(long, value_name = "IP")]
     rpcconnect: Option<String>,
 
     /// Bitcoin RPC port, default: 8332, saved
+    #[serde(default, deserialize_with = "default_on_error")]
     #[arg(long, value_name = "PORT")]
     rpcport: Option<u16>,
 
     /// Bitcoin RPC cookie file, default: --bitcoindir/.cookie, saved
+    #[serde(default, deserialize_with = "default_on_error")]
     #[arg(long, value_name = "PATH")]
     rpccookiefile: Option<String>,
 
     /// Bitcoin RPC username, saved
+    #[serde(default, deserialize_with = "default_on_error")]
     #[arg(long, value_name = "USERNAME")]
     rpcuser: Option<String>,
 
     /// Bitcoin RPC password, saved
+    #[serde(default, deserialize_with = "default_on_error")]
     #[arg(long, value_name = "PASSWORD")]
     rpcpassword: Option<String>,
 
     /// Delay between runs, default: 0, saved
+    #[serde(default, deserialize_with = "default_on_error")]
     #[arg(long, value_name = "SECONDS")]
     delay: Option<u64>,
 
+    /// DEV: Activate to watch the selected website's folder for changes, default: false, saved
+    #[serde(default, deserialize_with = "default_on_error")]
+    #[arg(long, value_name = "BOOL")]
+    watch: Option<bool>,
+
     /// DEV: Activate checking address hashes for collisions when indexing, default: false, saved
+    #[serde(default, deserialize_with = "default_on_error")]
     #[arg(long, value_name = "BOOL")]
     check_collisions: Option<bool>,
 }
@@ -200,8 +213,8 @@ impl RunConfig {
                 config_saved.brkdir = Some(brkdir);
             }
 
-            if let Some(mode) = config_args.mode.take() {
-                config_saved.mode = Some(mode);
+            if let Some(services) = config_args.services.take() {
+                config_saved.services = Some(services);
             }
 
             if let Some(computation) = config_args.computation.take() {
@@ -248,6 +261,10 @@ impl RunConfig {
                 config_saved.check_collisions = Some(check_collisions);
             }
 
+            if let Some(watch) = config_args.watch.take() {
+                config_saved.watch = Some(watch);
+            }
+
             if config_args != RunConfig::default() {
                 dbg!(config_args);
                 panic!("Didn't consume the full config")
@@ -260,19 +277,6 @@ impl RunConfig {
 
         config.write(&path)?;
 
-        // info!("Configuration {{");
-        // info!("  bitcoindir: {:?}", config.bitcoindir);
-        // info!("  brkdir: {:?}", config.brkdir);
-        // info!("  mode: {:?}", config.mode);
-        // info!("  website: {:?}", config.website);
-        // info!("  rpcconnect: {:?}", config.rpcconnect);
-        // info!("  rpcport: {:?}", config.rpcport);
-        // info!("  rpccookiefile: {:?}", config.rpccookiefile);
-        // info!("  rpcuser: {:?}", config.rpcuser);
-        // info!("  rpcpassword: {:?}", config.rpcpassword);
-        // info!("  delay: {:?}", config.delay);
-        // info!("}}");
-
         Ok(config)
     }
 
@@ -383,13 +387,13 @@ impl RunConfig {
     }
 
     pub fn process(&self) -> bool {
-        self.mode
-            .is_none_or(|m| m == Mode::All || m == Mode::Processor)
+        self.services
+            .is_none_or(|m| m == Services::All || m == Services::Processor)
     }
 
     pub fn serve(&self) -> bool {
-        self.mode
-            .is_none_or(|m| m == Mode::All || m == Mode::Server)
+        self.services
+            .is_none_or(|m| m == Services::All || m == Services::Server)
     }
 
     fn path_cookiefile(&self) -> PathBuf {
@@ -441,6 +445,10 @@ impl RunConfig {
     pub fn check_collisions(&self) -> bool {
         self.check_collisions.is_some_and(|b| b)
     }
+
+    pub fn watch(&self) -> bool {
+        self.watch.is_some_and(|b| b)
+    }
 }
 
 #[derive(
@@ -457,7 +465,7 @@ impl RunConfig {
     PartialOrd,
     Ord,
 )]
-pub enum Mode {
+pub enum Services {
     #[default]
     All,
     Processor,

crates/brk_computer/examples/main.rs

@@ -33,7 +33,7 @@ pub fn main() -> color_eyre::Result<()> {
 
             let format = Format::Raw;
 
-            let mut indexer = Indexer::new(outputs_dir, format, true)?;
+            let mut indexer = Indexer::new(outputs_dir, true)?;
             indexer.import_stores()?;
             indexer.import_vecs()?;
 

crates/brk_computer/src/vecs/fetched.rs

@@ -7,7 +7,7 @@ use brk_core::{
 use brk_exit::Exit;
 use brk_fetcher::Fetcher;
 use brk_indexer::Indexer;
-use brk_vec::{AnyCollectableVec, AnyIterableVec, Computation, EagerVec, Format};
+use brk_vec::{AnyCollectableVec, AnyIterableVec, Computation, EagerVec, Format, StoredIndex};
 
 use super::{
     Indexes,
@@ -429,8 +429,18 @@ impl Vecs {
         self.dateindex_to_ohlc_in_cents.compute_transform(
             starting_indexes.dateindex,
             &indexes.dateindex_to_date,
-            |(di, d, ..)| {
-                let ohlc = fetcher.get_date(d).unwrap();
+            |(di, d, this)| {
+                let mut ohlc = fetcher.get_date(d).unwrap();
+                if let Some(prev) = di.decremented() {
+                    let prev_open = *this
+                        .get_or_read(prev, &this.mmap().load())
+                        .unwrap()
+                        .unwrap()
+                        .close;
+                    *ohlc.open = prev_open;
+                    *ohlc.high = (*ohlc.high).max(prev_open);
+                    *ohlc.low = (*ohlc.low).min(prev_open);
+                }
                 (di, ohlc)
             },
             exit,

crates/brk_computer/src/vecs/grouped/value_from_txindex.rs

@@ -226,7 +226,11 @@ impl ComputedValueVecsFromTxindex {
     pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
         [
             self.sats.vecs(),
+            vec![&self.bitcoin_txindex as &dyn AnyCollectableVec],
             self.bitcoin.vecs(),
+            self.dollars_txindex
+                .as_ref()
+                .map_or(vec![], |v| vec![v as &dyn AnyCollectableVec]),
             self.dollars.as_ref().map_or(vec![], |v| v.vecs()),
         ]
         .into_iter()

crates/brk_computer/src/vecs/mod.rs

@@ -1,4 +1,4 @@
-use std::{fs, path::Path};
+use std::{fs, path::Path, thread};
 
 use brk_core::Version;
 use brk_exit::Exit;
@@ -44,22 +44,31 @@ impl Vecs {
     ) -> color_eyre::Result<Self> {
         fs::create_dir_all(path)?;
 
-        let indexes = indexes::Vecs::forced_import(
-            path,
-            version + VERSION + Version::ZERO,
-            indexer,
-            computation,
-            format,
-        )?;
+        let (indexes, fetched) = thread::scope(|s| {
+            let indexes_handle = s.spawn(|| {
+                indexes::Vecs::forced_import(
+                    path,
+                    version + VERSION + Version::ZERO,
+                    indexer,
+                    computation,
+                    format,
+                )
+                .unwrap()
+            });
 
-        let fetched = fetch.then(|| {
-            fetched::Vecs::forced_import(
-                path,
-                version + VERSION + Version::ZERO,
-                computation,
-                format,
-            )
-            .unwrap()
+            let fetch_handle = s.spawn(|| {
+                fetch.then(|| {
+                    fetched::Vecs::forced_import(
+                        path,
+                        version + VERSION + Version::ZERO,
+                        computation,
+                        format,
+                    )
+                    .unwrap()
+                })
+            });
+
+            (indexes_handle.join().unwrap(), fetch_handle.join().unwrap())
         });
 
         Ok(Self {
@@ -115,6 +124,7 @@ impl Vecs {
         fetcher: Option<&mut Fetcher>,
         exit: &Exit,
     ) -> color_eyre::Result<()> {
+        info!("Computing indexes...");
         let starting_indexes = self.indexes.compute(indexer, starting_indexes, exit)?;
 
         info!("Computing constants...");

crates/brk_computer/src/vecs/stateful/mod.rs

@@ -1289,7 +1289,7 @@ impl Vecs {
                 base_version + self.height_to_opreturn_supply.inner_version(),
             )?;
 
-        let mut chain_state: Vec<BlockState>;
+        let mut chain_state: Vec<BlockState> = vec![];
         let mut chain_state_starting_height = Height::from(self.chain_state.len());
 
         let stateful_starting_height = match separate_utxo_vecs
@@ -1322,25 +1322,27 @@ impl Vecs {
                     .collect::<Vec<_>>();
                 chain_state_starting_height
             }
-            Ordering::Less => {
-                // todo!("rollback instead");
-                chain_state = vec![];
-                chain_state_starting_height = Height::ZERO;
-                Height::ZERO
-            }
+            Ordering::Less => Height::ZERO,
         };
-        if stateful_starting_height.is_zero() {
-            info!("Starting processing utxos from the start");
-            separate_utxo_vecs
-                .par_iter_mut()
-                .try_for_each(|(_, v)| v.state.price_to_amount.reset())?;
-        }
+
         let starting_height = starting_indexes
             .height
             .min(stateful_starting_height)
             .min(Height::from(self.height_to_unspendable_supply.len()))
             .min(Height::from(self.height_to_opreturn_supply.len()));
 
+        if starting_height.is_zero() {
+            info!("Starting processing utxos from the start");
+
+            // todo!("rollback instead");
+            chain_state = vec![];
+            chain_state_starting_height = Height::ZERO;
+
+            separate_utxo_vecs
+                .par_iter_mut()
+                .try_for_each(|(_, v)| v.state.price_to_amount.reset())?;
+        }
+
         if starting_height == Height::from(height_to_date_fixed.len()) {
             return Ok(());
         }

crates/brk_core/src/structs/ohlc.rs

@@ -1,6 +1,6 @@
 use std::ops::{Add, Div};
 
-use derive_deref::Deref;
+use derive_deref::{Deref, DerefMut};
 use serde::{Serialize, Serializer, ser::SerializeTuple};
 use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
@@ -172,6 +172,7 @@ impl From<Close<Sats>> for OHLCSats {
     IntoBytes,
     KnownLayout,
     Deref,
+    DerefMut,
     Serialize,
 )]
 #[repr(C)]
@@ -259,6 +260,7 @@ where
     IntoBytes,
     KnownLayout,
     Deref,
+    DerefMut,
     Serialize,
 )]
 #[repr(C)]
@@ -346,6 +348,7 @@ where
     IntoBytes,
     KnownLayout,
     Deref,
+    DerefMut,
     Serialize,
 )]
 #[repr(C)]
@@ -433,6 +436,7 @@ where
     IntoBytes,
     KnownLayout,
     Deref,
+    DerefMut,
     Serialize,
 )]
 #[repr(C)]

crates/brk_core/src/structs/version.rs

@@ -33,7 +33,9 @@ impl Version {
         Self(self.0.swap_bytes())
     }
 
-    pub fn validate(&self, path: &Path) -> Result<()> {
+    /// Ok(true) if existed and is same
+    /// Ok(false) if didn't exist
+    pub fn validate(&self, path: &Path) -> Result<bool> {
         if let Ok(prev_version) = Version::try_from(path) {
             if prev_version != *self {
                 if prev_version.swap_bytes() == *self {
@@ -44,9 +46,11 @@ impl Version {
                     expected: *self,
                 });
             }
-        }
 
-        Ok(())
+            Ok(true)
+        } else {
+            Ok(false)
+        }
     }
 }
 

crates/brk_core/src/utils/mod.rs

@@ -3,9 +3,11 @@ mod checked_sub;
 mod paths;
 mod pause;
 mod rlimit;
+mod serde;
 
 pub use bytes::*;
 pub use checked_sub::*;
 pub use paths::*;
 pub use pause::*;
 pub use rlimit::*;
+pub use serde::*;

crates/brk_core/src/utils/serde.rs

@@ -0,0 +1,12 @@
+use serde::{Deserialize, Deserializer};
+
+pub fn default_on_error<'de, D, T>(deserializer: D) -> Result<T, D::Error>
+where
+    D: Deserializer<'de>,
+    T: Deserialize<'de> + Default,
+{
+    match T::deserialize(deserializer) {
+        Ok(v) => Ok(v),
+        Err(_) => Ok(T::default()),
+    }
+}

crates/brk_fetcher/examples/main.rs

@@ -1,5 +1,5 @@
 use brk_core::{Date, Height};
-use brk_fetcher::{BRK, Fetcher};
+use brk_fetcher::{BRK, Binance, Fetcher, Kraken};
 
 fn main() -> color_eyre::Result<()> {
     color_eyre::install()?;
@@ -12,6 +12,19 @@ fn main() -> color_eyre::Result<()> {
 
     let mut fetcher = Fetcher::import(None)?;
 
+    Binance::fetch_1d().map(|b| {
+        dbg!(b.last_key_value());
+    })?;
+    Kraken::fetch_1d().map(|b| {
+        dbg!(b.last_key_value());
+    })?;
+    Binance::fetch_1mn().map(|b| {
+        dbg!(b.last_key_value());
+    })?;
+    Kraken::fetch_1mn().map(|b| {
+        dbg!(b.last_key_value());
+    })?;
+
     dbg!(fetcher.get_date(Date::new(2025, 6, 5))?);
     dbg!(fetcher.get_height(
         899911_u32.into(),

crates/brk_fetcher/src/fetchers/kraken.rs

@@ -32,7 +32,7 @@ impl Kraken {
         )
     }
 
-    fn fetch_1mn() -> color_eyre::Result<BTreeMap<Timestamp, OHLCCents>> {
+    pub fn fetch_1mn() -> color_eyre::Result<BTreeMap<Timestamp, OHLCCents>> {
         info!("Fetching 1mn prices from Kraken...");
 
         retry(
@@ -54,7 +54,7 @@ impl Kraken {
             .ok_or(color_eyre::eyre::Error::msg("Couldn't find date"))
     }
 
-    fn fetch_1d() -> color_eyre::Result<BTreeMap<Date, OHLCCents>> {
+    pub fn fetch_1d() -> color_eyre::Result<BTreeMap<Date, OHLCCents>> {
         info!("Fetching daily prices from Kraken...");
 
         retry(

crates/brk_fetcher/src/lib.rs

@@ -40,11 +40,11 @@ impl Fetcher {
     }
 
     fn get_date_(&mut self, date: Date, tries: usize) -> color_eyre::Result<OHLCCents> {
-        self.binance
+        self.kraken
             .get_from_1d(&date)
             .or_else(|_| {
                 // eprintln!("{e}");
-                self.kraken.get_from_1d(&date)
+                self.binance.get_from_1d(&date)
             })
             .or_else(|_| {
                 // eprintln!("{e}");
@@ -90,11 +90,11 @@ impl Fetcher {
         let previous_timestamp = previous_timestamp.map(|t| t.floor_seconds());
 
         let ohlc = self
-            .binance
+            .kraken
             .get_from_1mn(timestamp, previous_timestamp)
             .unwrap_or_else(|_report| {
                 // eprintln!("{_report}");
-                self.kraken
+                self.binance
                     .get_from_1mn(timestamp, previous_timestamp)
                     .unwrap_or_else(|_report| {
                         //         // eprintln!("{_report}");
@@ -185,8 +185,8 @@ How to fix this:
     }
 
     pub fn clear(&mut self) {
+        self.kraken.clear();
         self.binance.clear();
         self.brk.clear();
-        self.kraken.clear();
     }
 }

crates/brk_indexer/examples/main.rs

@@ -4,7 +4,6 @@ use brk_core::default_bitcoin_path;
 use brk_exit::Exit;
 use brk_indexer::Indexer;
 use brk_parser::Parser;
-use brk_vec::Format;
 
 fn main() -> color_eyre::Result<()> {
     color_eyre::install()?;
@@ -25,7 +24,7 @@ fn main() -> color_eyre::Result<()> {
 
     let outputs = Path::new("../../_outputs");
 
-    let mut indexer = Indexer::new(outputs, Format::Raw, false)?;
+    let mut indexer = Indexer::new(outputs, false)?;
 
     indexer.import_stores()?;
     indexer.import_vecs()?;

crates/brk_indexer/src/indexes.rs

@@ -110,13 +110,7 @@ impl TryFrom<(&mut Vecs, &Stores, &Client)> for Indexes {
                 vecs.height_to_blockhash
                     .iter()
                     .get(*height)
-                    .is_none_or(|saved_blockhash| {
-                        let b = &rpc_blockhash != saved_blockhash.as_ref();
-                        if b {
-                            dbg!(rpc_blockhash, saved_blockhash.as_ref());
-                        }
-                        b
-                    })
+                    .is_none_or(|saved_blockhash| &rpc_blockhash != saved_blockhash.as_ref())
             })
             .unwrap_or(starting_height);
 

crates/brk_indexer/src/lib.rs

@@ -19,7 +19,7 @@ use brk_core::{
 use bitcoin::{Transaction, TxIn, TxOut};
 use brk_exit::Exit;
 use brk_parser::Parser;
-use brk_vec::{AnyVec, Format, VecIterator};
+use brk_vec::{AnyVec, VecIterator};
 use color_eyre::eyre::{ContextCompat, eyre};
 use fjall::TransactionalKeyspace;
 use log::{error, info};
@@ -42,21 +42,15 @@ pub struct Indexer {
     vecs: Option<Vecs>,
     stores: Option<Stores>,
     check_collisions: bool,
-    format: Format,
 }
 
 impl Indexer {
-    pub fn new(
-        outputs_dir: &Path,
-        format: Format,
-        check_collisions: bool,
-    ) -> color_eyre::Result<Self> {
+    pub fn new(outputs_dir: &Path, check_collisions: bool) -> color_eyre::Result<Self> {
         setrlimit()?;
         Ok(Self {
             path: outputs_dir.to_owned(),
             vecs: None,
             stores: None,
-            format,
             check_collisions,
         })
     }
@@ -65,7 +59,6 @@ impl Indexer {
         self.vecs = Some(Vecs::forced_import(
             &self.path.join("vecs/indexed"),
             VERSION + Version::ZERO,
-            self.format,
         )?);
         Ok(())
     }

crates/brk_indexer/src/vecs.rs

@@ -66,11 +66,7 @@ pub struct Vecs {
 }
 
 impl Vecs {
-    pub fn forced_import(
-        path: &Path,
-        version: Version,
-        format: Format,
-    ) -> color_eyre::Result<Self> {
+    pub fn forced_import(path: &Path, version: Version) -> color_eyre::Result<Self> {
         fs::create_dir_all(path)?;
 
         Ok(Self {
@@ -78,7 +74,7 @@ impl Vecs {
                 path,
                 "txindex",
                 version + VERSION + Version::ZERO,
-                format,
+                Format::Raw,
             )?,
             height_to_blockhash: IndexedVec::forced_import(
                 path,
@@ -90,145 +86,145 @@ impl Vecs {
                 path,
                 "difficulty",
                 version + VERSION + Version::ZERO,
-                format,
+                Format::Raw,
             )?,
             height_to_first_emptyoutputindex: IndexedVec::forced_import(
                 path,
                 "first_emptyoutputindex",
                 version + VERSION + Version::ZERO,
-                format,
+                Format::Raw,
             )?,
             height_to_first_inputindex: IndexedVec::forced_import(
                 path,
                 "first_inputindex",
                 version + VERSION + Version::ZERO,
-                format,
+                Format::Raw,
             )?,
             height_to_first_opreturnindex: IndexedVec::forced_import(
                 path,
                 "first_opreturnindex",
                 version + VERSION + Version::ZERO,
-                format,
+                Format::Raw,
             )?,
             height_to_first_outputindex: IndexedVec::forced_import(
                 path,
                 "first_outputindex",
                 version + VERSION + Version::ZERO,
-                format,
+                Format::Raw,
             )?,
             height_to_first_p2aindex: IndexedVec::forced_import(
                 path,
                 "first_p2aindex",
                 version + VERSION + Version::ZERO,
-                format,
+                Format::Raw,
             )?,
             height_to_first_p2msindex: IndexedVec::forced_import(
                 path,
                 "first_p2msindex",
                 version + VERSION + Version::ZERO,
-                format,
+                Format::Raw,
             )?,
             height_to_first_p2pk33index: IndexedVec::forced_import(
                 path,
                 "first_p2pk33index",
                 version + VERSION + Version::ZERO,
-                format,
+                Format::Raw,
             )?,
             height_to_first_p2pk65index: IndexedVec::forced_import(
                 path,
                 "first_p2pk65index",
                 version + VERSION + Version::ZERO,
-                format,
+                Format::Raw,
             )?,
             height_to_first_p2pkhindex: IndexedVec::forced_import(
                 path,
                 "first_p2pkhindex",
                 version + VERSION + Version::ZERO,
-                format,
+                Format::Raw,
             )?,
             height_to_first_p2shindex: IndexedVec::forced_import(
                 path,
                 "first_p2shindex",
                 version + VERSION + Version::ZERO,
-                format,
+                Format::Raw,
             )?,
             height_to_first_p2trindex: IndexedVec::forced_import(
                 path,
                 "first_p2trindex",
                 version + VERSION + Version::ZERO,
-                format,
+                Format::Raw,
             )?,
             height_to_first_p2wpkhindex: IndexedVec::forced_import(
                 path,
                 "first_p2wpkhindex",
                 version + VERSION + Version::ZERO,
-                format,
+                Format::Raw,
             )?,
             height_to_first_p2wshindex: IndexedVec::forced_import(
                 path,
                 "first_p2wshindex",
                 version + VERSION + Version::ZERO,
-                format,
+                Format::Raw,
             )?,
             height_to_first_txindex: IndexedVec::forced_import(
                 path,
                 "first_txindex",
                 version + VERSION + Version::ZERO,
-                format,
+                Format::Raw,
             )?,
             height_to_first_unknownoutputindex: IndexedVec::forced_import(
                 path,
                 "first_unknownoutputindex",
                 version + VERSION + Version::ZERO,
-                format,
+                Format::Raw,
             )?,
             height_to_timestamp: IndexedVec::forced_import(
                 path,
                 "timestamp",
                 version + VERSION + Version::ZERO,
-                format,
+                Format::Raw,
             )?,
             height_to_total_size: IndexedVec::forced_import(
                 path,
                 "total_size",
                 version + VERSION + Version::ZERO,
-                format,
+                Format::Raw,
             )?,
             height_to_weight: IndexedVec::forced_import(
                 path,
                 "weight",
                 version + VERSION + Version::ZERO,
-                format,
+                Format::Raw,
             )?,
             inputindex_to_outputindex: IndexedVec::forced_import(
                 path,
                 "outputindex",
                 version + VERSION + Version::ZERO,
-                format,
+                Format::Raw,
             )?,
             opreturnindex_to_txindex: IndexedVec::forced_import(
                 path,
                 "txindex",
                 version + VERSION + Version::ZERO,
-                format,
+                Format::Raw,
             )?,
             outputindex_to_outputtype: IndexedVec::forced_import(
                 path,
                 "outputtype",
                 version + VERSION + Version::ZERO,
-                format,
+                Format::Raw,
             )?,
             outputindex_to_outputtypeindex: IndexedVec::forced_import(
                 path,
                 "outputtypeindex",
                 version + VERSION + Version::ZERO,
-                format,
+                Format::Raw,
             )?,
             outputindex_to_value: IndexedVec::forced_import(
                 path,
                 "value",
                 version + VERSION + Version::ZERO,
-                format,
+                Format::Raw,
             )?,
             p2aindex_to_p2abytes: IndexedVec::forced_import(
                 path,
@@ -240,7 +236,7 @@ impl Vecs {
                 path,
                 "txindex",
                 version + VERSION + Version::ZERO,
-                format,
+                Format::Raw,
             )?,
             p2pk33index_to_p2pk33bytes: IndexedVec::forced_import(
                 path,
@@ -288,13 +284,13 @@ impl Vecs {
                 path,
                 "base_size",
                 version + VERSION + Version::ZERO,
-                format,
+                Format::Raw,
             )?,
             txindex_to_first_inputindex: IndexedVec::forced_import(
                 path,
                 "first_inputindex",
                 version + VERSION + Version::ZERO,
-                format,
+                Format::Raw,
             )?,
             txindex_to_first_outputindex: IndexedVec::forced_import(
                 path,
@@ -306,19 +302,19 @@ impl Vecs {
                 path,
                 "is_explicitly_rbf",
                 version + VERSION + Version::ZERO,
-                format,
+                Format::Raw,
             )?,
             txindex_to_rawlocktime: IndexedVec::forced_import(
                 path,
                 "rawlocktime",
                 version + VERSION + Version::ZERO,
-                format,
+                Format::Raw,
             )?,
             txindex_to_total_size: IndexedVec::forced_import(
                 path,
                 "total_size",
                 version + VERSION + Version::ZERO,
-                format,
+                Format::Raw,
             )?,
             txindex_to_txid: IndexedVec::forced_import(
                 path,
@@ -330,13 +326,13 @@ impl Vecs {
                 path,
                 "txversion",
                 version + VERSION + Version::ZERO,
-                format,
+                Format::Raw,
             )?,
             unknownoutputindex_to_txindex: IndexedVec::forced_import(
                 path,
                 "txindex",
                 version + VERSION + Version::ZERO,
-                format,
+                Format::Raw,
             )?,
         })
     }

crates/brk_logger/src/lib.rs

@@ -25,50 +25,53 @@ pub fn init(path: Option<&Path>) {
             .unwrap()
     });
 
-    Builder::from_env(Env::default().default_filter_or("info,fjall=off,lsm_tree=off"))
-        .format(move |buf, record| {
-            let date_time = Timestamp::now()
-                .to_zoned(tz::TimeZone::system())
-                .strftime("%Y-%m-%d %H:%M:%S")
-                .to_string();
-            let level = record.level().as_str().to_lowercase();
-            let level = format!("{:5}", level);
-            let target = record.target();
-            let dash = "-";
-            let args = record.args();
+    Builder::from_env(
+        Env::default()
+            .default_filter_or("info,fjall=off,lsm_tree=off,rolldown=off,brk_rolldown=off"),
+    )
+    .format(move |buf, record| {
+        let date_time = Timestamp::now()
+            .to_zoned(tz::TimeZone::system())
+            .strftime("%Y-%m-%d %H:%M:%S")
+            .to_string();
+        let level = record.level().as_str().to_lowercase();
+        let level = format!("{:5}", level);
+        let target = record.target();
+        let dash = "-";
+        let args = record.args();
 
-            if let Some(file) = file.as_ref() {
-                let _ = write(
-                    file.try_clone().unwrap(),
-                    &date_time,
-                    target,
-                    &level,
-                    dash,
-                    args,
-                );
-            }
-
-            let colored_date_time = date_time.bright_black();
-            let colored_level = match level.chars().next().unwrap() {
-                'e' => level.red().to_string(),
-                'w' => level.yellow().to_string(),
-                'i' => level.green().to_string(),
-                'd' => level.blue().to_string(),
-                't' => level.cyan().to_string(),
-                _ => panic!(),
-            };
-            let colored_dash = dash.bright_black();
-
-            write(
-                buf,
-                colored_date_time,
+        if let Some(file) = file.as_ref() {
+            let _ = write(
+                file.try_clone().unwrap(),
+                &date_time,
                 target,
-                colored_level,
-                colored_dash,
+                &level,
+                dash,
                 args,
-            )
-        })
-        .init();
+            );
+        }
+
+        let colored_date_time = date_time.bright_black();
+        let colored_level = match level.chars().next().unwrap() {
+            'e' => level.red().to_string(),
+            'w' => level.yellow().to_string(),
+            'i' => level.green().to_string(),
+            'd' => level.blue().to_string(),
+            't' => level.cyan().to_string(),
+            _ => panic!(),
+        };
+        let colored_dash = dash.bright_black();
+
+        write(
+            buf,
+            colored_date_time,
+            target,
+            colored_level,
+            colored_dash,
+            args,
+        )
+    })
+    .init();
 }
 
 fn write(
@@ -80,5 +83,9 @@ fn write(
     args: impl Display,
 ) -> Result<(), std::io::Error> {
     writeln!(buf, "{} {} {} {}", date_time, dash, level, args)
-    // writeln!(buf, "{} {} {} {}  {}", date_time, _target, level, dash, args)
+    // writeln!(
+    //     buf,
+    //     "{} {} {} {}  {}",
+    //     date_time, _target, level, dash, args
+    // )
 }

crates/brk_parser/src/blk_index_to_blk_recap.rs

@@ -96,9 +96,10 @@ impl BlkIndexToBlkRecap {
     }
 
     pub fn export(&self) {
-        let file = File::create(&self.path).unwrap_or_else(|_| {
+        let file = File::create(&self.path).unwrap_or_else(|e| {
+            dbg!(e);
             dbg!(&self.path);
-            panic!("No such file or directory")
+            panic!("Cannot write file");
         });
 
         serde_json::to_writer(&mut BufWriter::new(file), &self.tree).unwrap();

crates/brk_query/Cargo.toml

@@ -18,5 +18,5 @@ color-eyre = { workspace = true }
 derive_deref = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
-serde_with = "3.12.0"
+serde_with = "3.13.0"
 tabled = { workspace = true }

crates/brk_query/examples/main.rs

@@ -12,7 +12,7 @@ pub fn main() -> color_eyre::Result<()> {
 
     let format = Format::Compressed;
 
-    let mut indexer = Indexer::new(outputs_dir, format, true)?;
+    let mut indexer = Indexer::new(outputs_dir, true)?;
     indexer.import_vecs()?;
 
     let mut computer = Computer::new(outputs_dir, None, format);

crates/brk_query/src/lib.rs

@@ -19,7 +19,7 @@ mod vec_trees;
 pub use format::Format;
 pub use index::Index;
 pub use output::{Output, Value};
-pub use params::Params;
+pub use params::{Params, ParamsOpt};
 pub use table::Tabled;
 use vec_trees::VecTrees;
 

crates/brk_query/src/params.rs

@@ -1,6 +1,8 @@
+use std::{fmt::Display, ops::Deref, str::FromStr};
+
 use clap::builder::PossibleValuesParser;
 use clap_derive::Parser;
-use serde::Deserialize;
+use serde::{Deserialize, Deserializer};
 use serde_with::{OneOrMany, formats::PreferOne, serde_as};
 
 use crate::{Format, Index};
@@ -17,15 +19,111 @@ pub struct Params {
     #[serde_as(as = "OneOrMany<_, PreferOne>")]
     /// Names of the values requested
     pub values: Vec<String>,
+
+    #[clap(flatten)]
+    #[serde(flatten)]
+    pub rest: ParamsOpt,
+}
+
+// The macro creates custom deserialization code.
+// You need to specify a function name and the field name of the flattened field.
+serde_with::flattened_maybe!(deserialize_rest, "rest");
+
+impl Deref for Params {
+    type Target = ParamsOpt;
+    fn deref(&self) -> &Self::Target {
+        &self.rest
+    }
+}
+
+impl From<((String, String), ParamsOpt)> for Params {
+    fn from(((index, id), rest): ((String, String), ParamsOpt)) -> Self {
+        Self {
+            index,
+            values: vec![id],
+            rest,
+        }
+    }
+}
+
+#[serde_as]
+#[derive(Debug, Deserialize, Parser)]
+pub struct ParamsOpt {
     #[clap(short, long, allow_hyphen_values = true)]
-    #[serde(alias = "f")]
+    #[serde(default, alias = "f", deserialize_with = "de_unquote_i64")]
     /// Inclusive starting index, if negative will be from the end
-    pub from: Option<i64>,
+    from: Option<i64>,
     #[clap(short, long, allow_hyphen_values = true)]
-    #[serde(default, alias = "t")]
-    /// Inclusive ending index, if negative will be from the end
-    pub to: Option<i64>,
+    #[serde(default, alias = "t", deserialize_with = "de_unquote_i64")]
+    /// Exclusive ending index, if negative will be from the end, overrides 'count'
+    to: Option<i64>,
+    #[clap(short, long, allow_hyphen_values = true)]
+    #[serde(default, alias = "c", deserialize_with = "de_unquote_usize")]
+    /// Number of values
+    count: Option<usize>,
     #[clap(short = 'F', long)]
     /// Format of the output
-    pub format: Option<Format>,
+    format: Option<Format>,
+}
+
+impl ParamsOpt {
+    pub fn from(&self) -> Option<i64> {
+        self.from
+    }
+
+    pub fn to(&self) -> Option<i64> {
+        if self.to.is_none() {
+            if let Some(c) = self.count {
+                let c = c as i64;
+                if let Some(f) = self.from {
+                    if f.is_positive() || f.abs() > c {
+                        return Some(f + c);
+                    }
+                } else {
+                    return Some(c);
+                }
+            }
+        }
+        self.to
+    }
+
+    pub fn format(&self) -> Option<Format> {
+        self.format
+    }
+}
+
+fn de_unquote_i64<'de, D>(deserializer: D) -> Result<Option<i64>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    de_unquote(deserializer)
+}
+
+fn de_unquote_usize<'de, D>(deserializer: D) -> Result<Option<usize>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    de_unquote(deserializer)
+}
+
+fn de_unquote<'de, D, F>(deserializer: D) -> Result<Option<F>, D::Error>
+where
+    D: Deserializer<'de>,
+    F: FromStr + Display,
+    <F as std::str::FromStr>::Err: Display,
+{
+    let opt: Option<String> = Option::deserialize(deserializer)?;
+    let s = match opt {
+        None => return Ok(None),
+        Some(mut s) => {
+            // strip any leading/trailing quotes
+            if s.starts_with('"') && s.ends_with('"') && s.len() >= 2 {
+                s = s[1..s.len() - 1].to_string();
+            }
+            s
+        }
+    };
+    s.parse::<F>()
+        .map(Some)
+        .map_err(|e| serde::de::Error::custom(format!("cannot parse `{}` as type: {}", s, e)))
 }

crates/brk_server/Cargo.toml

@@ -10,6 +10,7 @@ repository.workspace = true
 [dependencies]
 axum = { workspace = true }
 bitcoincore-rpc = { workspace = true }
+brk_bundler = { workspace = true }
 brk_computer = { workspace = true }
 brk_exit = { workspace = true }
 brk_core = { workspace = true }
@@ -25,11 +26,11 @@ color-eyre = { workspace = true }
 jiff = { workspace = true }
 log = { workspace = true }
 minreq = { workspace = true }
-oxc = { version = "0.72.3", features = ["codegen", "minifier"] }
+oxc = { version = "0.73.0", features = ["codegen", "minifier"] }
 serde = { workspace = true }
 tokio = { workspace = true }
 tower-http = { version = "0.6.6", features = ["compression-full", "trace"] }
-zip = "4.0.0"
+zip = "4.1.0"
 tracing = "0.1.41"
 
 [package.metadata.cargo-machete]

crates/brk_server/README.md

@@ -41,22 +41,59 @@ The API uses `brk_query` and so inherites all of its features including formats.
 
 ### API
 
-#### `GET /api/vecs/indexes`
+#### [`GET /api/vecs/index-count`](https://bitcoinresearchkit.org/api/vecs/index-count)
+
+Count of all possible indexes
+
+#### [`GET /api/vecs/id-count`](https://bitcoinresearchkit.org/api/vecs/id-count)
+
+Count of all possible ids
+
+#### [`GET /api/vecs/variant-count`](https://bitcoinresearchkit.org/api/vecs/variant-count)
+
+Count of all possible variants
+
+#### [`GET /api/vecs/indexes`](https://bitcoinresearchkit.org/api/vecs/indexes)
 
 A list of all possible vec indexes and their accepted variants
 
-#### `GET /api/vecs/ids`
+#### [`GET /api/vecs/ids`](https://bitcoinresearchkit.org/api/vecs/ids)
 
 A list of all possible vec ids
 
-#### `GET /api/vecs/id-to-indexes`
+#### [`GET /api/vecs/variants`](https://bitcoinresearchkit.org/api/vecs/variants)
+
+A list of all possible variants
+
+#### [`GET /api/vecs/id-to-indexes`](https://bitcoinresearchkit.org/api/vecs/id-to-indexes)
 
 A list of all possible vec ids and their supported vec indexes
 
-#### `GET /api/vecs/index-to-ids`
+#### [`GET /api/vecs/index-to-ids`](https://bitcoinresearchkit.org/api/vecs/index-to-ids)
 
 A list of all possible vec indexes and their supported vec ids
 
+#### `GET /api/{INDEX}-to-{ID}`
+
+This endpoint retrieves data based on the specified vector index and id.
+
+**Parameters:**
+
+| Parameter | Type | Required | Description |
+| --- | --- | --- | --- |
+| `from` | `signed int` | No | Inclusive starting index for pagination (default is 0). |
+| `to` | `signed int` | No | Exclusive ending index for pagination (default is the total number of results). Overrides `count` |
+| `count` | `unsigned int` | No | The number of values requested |
+| `format` | `string` | No | The format of the response. Options include `json`, `csv`, `tsv`, or `md` (default is `json`). |
+
+**Examples:**
+
+```
+GET /api/date-to-close
+GET /date-to-close?from=-100
+GET /date-to-close?count=100&format=csv
+```
+
 #### `GET /api/query`
 
 This endpoint retrieves data based on the specified vector index and values.
@@ -67,8 +104,9 @@ This endpoint retrieves data based on the specified vector index and values.
 | --- | --- | --- | --- |
 | `index` | `VecIndex` | Yes | The vector index to query. |
 | `values` | `VecId[]` | Yes | A comma or space-separated list of vector IDs to retrieve. |
-| `from` | `unsigned int` | No | The starting index for pagination (default is 0). |
-| `to` | `unsigned int` | No | The ending index for pagination (default is the total number of results). |
+| `from` | `signed int` | No | Inclusive starting index for pagination (default is 0). |
+| `to` | `signed int` | No | Exclusive ending index for pagination (default is the total number of results). Overrides `count` |
+| `count` | `unsigned int` | No | The number of values requested |
 | `format` | `string` | No | The format of the response. Options include `json`, `csv`, `tsv`, or `md` (default is `json`). |
 
 **Examples:**
@@ -80,7 +118,7 @@ GET /api/query?index=week&values=ohlc,block-interval-average&from=0&to=20&format
 
 ### Meta
 
-#### `GET /version`
+#### [`GET /version`](https://bitcoinresearchkit.org/version)
 
 The version of the server and thus BRK.
 

crates/brk_server/examples/main.rs

@@ -31,7 +31,7 @@ pub fn main() -> color_eyre::Result<()> {
 
     let format = Format::Compressed;
 
-    let mut indexer = Indexer::new(outputs_dir, format, true)?;
+    let mut indexer = Indexer::new(outputs_dir, true)?;
     indexer.import_stores()?;
     indexer.import_vecs()?;
 
@@ -51,7 +51,7 @@ pub fn main() -> color_eyre::Result<()> {
             let server = Server::new(served_indexer, served_computer, Website::Default)?;
 
             let server = tokio::spawn(async move {
-                server.serve().await.unwrap();
+                server.serve(true).await.unwrap();
             });
 
             if process {

crates/brk_server/src/api/mod.rs

@@ -1,18 +1,20 @@
 use std::collections::BTreeMap;
 
 use axum::{
-    Router,
-    extract::State,
+    Json, Router,
+    extract::{Path, Query, State},
+    http::HeaderMap,
     response::{IntoResponse, Redirect, Response},
     routing::get,
 };
+use brk_query::{Params, ParamsOpt};
 
 use super::AppState;
 
 mod explorer;
 mod query;
 
-pub use query::DTS;
+pub use query::Bridge;
 
 pub trait ApiRoutes {
     fn add_api_routes(self) -> Self;
@@ -20,24 +22,29 @@ pub trait ApiRoutes {
 
 impl ApiRoutes for Router<AppState> {
     fn add_api_routes(self) -> Self {
-        self.route(
-            "/api",
-            get(|| async {
-                Redirect::permanent(
-                    "https://github.com/bitcoinresearchkit/brk/tree/main/crates/brk_server#api",
-                )
-            }),
-        )
-        .route("/api/query", get(query::handler))
-        .route("/api/vecs/ids", get(vecids_handler))
-        .route("/api/vecs/indexes", get(vecindexes_handler))
-        .route("/api/vecs/id-to-indexes", get(vecid_to_vecindexes_handler))
-        .route("/api/vecs/index-to-ids", get(vecindex_to_vecids_handler))
+        self.route("/api/query", get(query::handler))
+            .route("/api/vecs/id-count", get(id_count_handler))
+            .route("/api/vecs/index-count", get(index_count_handler))
+            .route("/api/vecs/variant-count", get(variant_count_handler))
+            .route("/api/vecs/ids", get(ids_handler))
+            .route("/api/vecs/indexes", get(indexes_handler))
+            .route("/api/vecs/variants", get(variants_handler))
+            .route("/api/vecs/id-to-indexes", get(id_to_indexes_handler))
+            .route("/api/vecs/index-to-ids", get(index_to_ids_handler))
+            .route("/api/{variant}", get(variant_handler))
+            .route(
+                "/api",
+                get(|| async {
+                    Redirect::temporary(
+                        "https://github.com/bitcoinresearchkit/brk/tree/main/crates/brk_server#api",
+                    )
+                }),
+            )
     }
 }
 
-pub async fn vecids_handler(State(app_state): State<AppState>) -> Response {
-    axum::Json(
+pub async fn ids_handler(State(app_state): State<AppState>) -> Response {
+    Json(
         app_state
             .query
             .vec_trees
@@ -48,8 +55,29 @@ pub async fn vecids_handler(State(app_state): State<AppState>) -> Response {
     .into_response()
 }
 
-pub async fn vecindexes_handler(State(app_state): State<AppState>) -> Response {
-    axum::Json(
+pub async fn variant_count_handler(State(app_state): State<AppState>) -> Response {
+    Json(
+        app_state
+            .query
+            .vec_trees
+            .index_to_id_to_vec
+            .values()
+            .map(|tree| tree.len())
+            .sum::<usize>(),
+    )
+    .into_response()
+}
+
+pub async fn id_count_handler(State(app_state): State<AppState>) -> Response {
+    Json(app_state.query.vec_trees.id_to_index_to_vec.keys().count()).into_response()
+}
+
+pub async fn index_count_handler(State(app_state): State<AppState>) -> Response {
+    Json(app_state.query.vec_trees.index_to_id_to_vec.keys().count()).into_response()
+}
+
+pub async fn indexes_handler(State(app_state): State<AppState>) -> Response {
+    Json(
         app_state
             .query
             .vec_trees
@@ -61,10 +89,49 @@ pub async fn vecindexes_handler(State(app_state): State<AppState>) -> Response {
     .into_response()
 }
 
-pub async fn vecid_to_vecindexes_handler(State(app_state): State<AppState>) -> Response {
-    axum::Json(app_state.query.vec_trees.serialize_id_to_index_to_vec()).into_response()
+pub async fn variants_handler(State(app_state): State<AppState>) -> Response {
+    Json(
+        app_state
+            .query
+            .vec_trees
+            .index_to_id_to_vec
+            .iter()
+            .flat_map(|(index, id_to_vec)| {
+                let index_ser = index.serialize_long();
+                id_to_vec
+                    .keys()
+                    .map(|id| format!("{}-to-{}", index_ser, id))
+                    .collect::<Vec<_>>()
+            })
+            .collect::<Vec<_>>(),
+    )
+    .into_response()
 }
 
-pub async fn vecindex_to_vecids_handler(State(app_state): State<AppState>) -> Response {
-    axum::Json(app_state.query.vec_trees.serialize_index_to_id_to_vec()).into_response()
+pub async fn id_to_indexes_handler(State(app_state): State<AppState>) -> Response {
+    Json(app_state.query.vec_trees.serialize_id_to_index_to_vec()).into_response()
+}
+
+pub async fn index_to_ids_handler(State(app_state): State<AppState>) -> Response {
+    Json(app_state.query.vec_trees.serialize_index_to_id_to_vec()).into_response()
+}
+
+const TO_SEPARATOR: &str = "-to-";
+
+pub async fn variant_handler(
+    headers: HeaderMap,
+    Path(variant): Path<String>,
+    Query(params_opt): Query<ParamsOpt>,
+    state: State<AppState>,
+) -> Response {
+    let variant = variant.replace("_", "-");
+    let mut split = variant.split(TO_SEPARATOR);
+    let params = Params::from((
+        (
+            split.next().unwrap().to_string(),
+            split.collect::<Vec<_>>().join(TO_SEPARATOR),
+        ),
+        params_opt,
+    ));
+    query::handler(headers, Query(params), state).await
 }

crates/brk_server/src/api/query/bridge.rs

@@ -2,17 +2,17 @@ use std::{fs, io, path::Path};
 
 use brk_query::{Index, Query};
 
-use crate::Website;
+use crate::{VERSION, Website};
 
 const SCRIPTS: &str = "scripts";
 
 #[allow(clippy::upper_case_acronyms)]
-pub trait DTS {
-    fn generate_dts_file(&self, website: Website, websites_path: &Path) -> io::Result<()>;
+pub trait Bridge {
+    fn generate_bridge_file(&self, website: Website, websites_path: &Path) -> io::Result<()>;
 }
 
-impl DTS for Query<'static> {
-    fn generate_dts_file(&self, website: Website, websites_path: &Path) -> io::Result<()> {
+impl Bridge for Query<'static> {
+    fn generate_bridge_file(&self, website: Website, websites_path: &Path) -> io::Result<()> {
         if website.is_none() {
             return Ok(());
         }
@@ -31,10 +31,16 @@ impl DTS for Query<'static> {
 
         let indexes = Index::all();
 
-        let mut contents = "//
+        let mut contents = format!(
+            "//
 // File auto-generated, any modifications will be overwritten
-//\n\n"
-            .to_string();
+//
+
+export const VERSION = \"v{}\";
+
+",
+            VERSION
+        );
 
         contents += &indexes
             .iter()
@@ -55,9 +61,12 @@ impl DTS for Query<'static> {
                 .join(" | ")
         );
 
-        contents += "\n\nexport function createVecIdToIndexes() {\n";
+        contents += "\n\n/** @typedef {ReturnType<typeof createVecIdToIndexes>} VecIdToIndexes */";
+        contents += "\n/** @typedef {keyof VecIdToIndexes} VecId */\n";
 
-        contents += "\n\n  return /** @type {const} */ ({\n";
+        contents += "\nexport function createVecIdToIndexes() {\n";
+
+        contents += "  return {\n";
 
         self.vec_trees
             .id_to_index_to_vec
@@ -73,11 +82,7 @@ impl DTS for Query<'static> {
                 contents += &format!("    \"{id}\": [{indexes}],\n");
             });
 
-        contents += "  });\n";
-        contents.push('}');
-
-        contents += "\n/** @typedef {ReturnType<typeof createVecIdToIndexes>} VecIdToIndexes */";
-        contents += "\n/** @typedef {keyof VecIdToIndexes} VecId */\n";
+        contents += "  };\n}\n";
 
         fs::write(path, contents)
     }

crates/brk_server/src/api/query/mod.rs

@@ -5,14 +5,18 @@ use axum::{
     response::{IntoResponse, Response},
 };
 use brk_query::{Format, Index, Output, Params};
+use brk_vec::{CollectableVec, StoredVec};
+use color_eyre::eyre::eyre;
 
 use crate::traits::{HeaderMapExtended, ModifiedState, ResponseExtended};
 
 use super::AppState;
 
-mod dts;
+mod bridge;
 
-pub use dts::*;
+pub use bridge::*;
+
+const MAX_WEIGHT: usize = 320_000;
 
 pub async fn handler(
     headers: HeaderMap,
@@ -33,11 +37,9 @@ pub async fn handler(
 fn req_to_response_res(
     headers: HeaderMap,
     AxumQuery(Params {
-        format,
-        from,
         index,
-        to,
         values,
+        rest,
     }): AxumQuery<Params>,
     AppState { query, .. }: AppState,
 ) -> color_eyre::Result<Response> {
@@ -48,6 +50,27 @@ fn req_to_response_res(
         &values.iter().map(|v| v.as_str()).collect::<Vec<_>>(),
     );
 
+    if vecs.is_empty() {
+        return Ok(Json(vec![] as Vec<usize>).into_response());
+    }
+
+    let from = rest.from();
+    let to = rest.to();
+    let format = rest.format();
+
+    let weight = vecs
+        .iter()
+        .map(|(_, v)| {
+            let len = v.len();
+            let count = StoredVec::<usize, usize>::range_count(from, to, len);
+            count * v.value_type_to_size_of()
+        })
+        .sum::<usize>();
+
+    if weight > MAX_WEIGHT {
+        return Err(eyre!("Request is too heavy, max weight is {MAX_WEIGHT}"));
+    }
+
     let mut date_modified_opt = None;
 
     if to.is_none() {
@@ -75,8 +98,8 @@ fn req_to_response_res(
         Output::TSV(s) => s.into_response(),
         Output::Json(v) => match v {
             brk_query::Value::Single(v) => Json(v).into_response(),
-            brk_query::Value::List(l) => Json(l).into_response(),
-            brk_query::Value::Matrix(m) => Json(m).into_response(),
+            brk_query::Value::List(v) => Json(v).into_response(),
+            brk_query::Value::Matrix(v) => Json(v).into_response(),
         },
         Output::MD(s) => s.into_response(),
     };

crates/brk_server/src/files/file.rs

@@ -13,8 +13,6 @@ use crate::{
     traits::{HeaderMapExtended, ModifiedState, ResponseExtended},
 };
 
-use super::minify::minify_js;
-
 pub async fn file_handler(
     headers: HeaderMap,
     State(app_state): State<AppState>,
@@ -32,18 +30,14 @@ fn any_handler(
     app_state: AppState,
     path: Option<extract::Path<String>>,
 ) -> Response {
-    let website_path = app_state
-        .websites_path
-        .as_ref()
-        .expect("Should never reach here is websites_path is None")
-        .join(app_state.website.to_folder_name());
+    let dist_path = app_state.dist_path();
 
     if let Some(path) = path.as_ref() {
         let path = path.0.replace("..", "").replace("\\", "");
 
-        let mut path = website_path.join(&path);
+        let mut path = dist_path.join(&path);
 
-        if !path.exists() {
+        if !path.exists() || path.is_dir() {
             if path.extension().is_some() {
                 let mut response: Response<Body> = (
                     StatusCode::INTERNAL_SERVER_ERROR,
@@ -55,13 +49,13 @@ fn any_handler(
 
                 return response;
             } else {
-                path = website_path.join("index.html");
+                path = dist_path.join("index.html");
             }
         }
 
         path_to_response(&headers, &path)
     } else {
-        path_to_response(&headers, &website_path.join("index.html"))
+        path_to_response(&headers, &dist_path.join("index.html"))
     }
 }
 
@@ -85,49 +79,35 @@ fn path_to_response_(headers: &HeaderMap, path: &Path) -> color_eyre::Result<Res
         return Ok(Response::new_not_modified());
     }
 
-    let mut response;
+    let content = fs::read(path).unwrap_or_else(|error| {
+        error!("{error}");
+        let path = path.to_str().unwrap();
+        info!("Can't read file {path}");
+        panic!("")
+    });
 
-    let is_localhost = headers.check_if_host_is_localhost();
-
-    if !is_localhost
-        && path.extension().unwrap_or_else(|| {
-            dbg!(path);
-            panic!();
-        }) == "js"
-    {
-        let content = minify_js(path);
-
-        response = Response::new(content.into());
-    } else {
-        let content = fs::read(path).unwrap_or_else(|error| {
-            error!("{error}");
-            let path = path.to_str().unwrap();
-            info!("Can't read file {path}");
-            panic!("")
-        });
-
-        response = Response::new(content.into());
-    }
+    let mut response = Response::new(content.into());
 
     let headers = response.headers_mut();
     headers.insert_cors();
     headers.insert_content_type(path);
 
-    if !is_localhost {
-        let serialized_path = path.to_str().unwrap();
+    let serialized_path = path.to_str().unwrap();
 
-        if serialized_path.contains("fonts/")
-            || serialized_path.contains("assets/")
-            || serialized_path.contains("packages/")
-            || path.extension().is_some_and(|extension| {
-                extension == "pdf"
-                    || extension == "jpg"
-                    || extension == "png"
-                    || extension == "woff2"
-            })
-        {
-            headers.insert_cache_control_immutable();
-        }
+    if serialized_path.ends_with(".html") || serialized_path.ends_with("service-worker.js") {
+        headers.insert_cache_control_must_revalidate();
+    } else if serialized_path.contains("fonts/")
+        || serialized_path.contains("assets/")
+        || serialized_path.contains("packages/")
+        || path.extension().is_some_and(|extension| {
+            extension == "pdf"
+                || extension == "jpg"
+                || extension == "png"
+                || extension == "woff2"
+                || extension == "js"
+        })
+    {
+        headers.insert_cache_control_immutable();
     }
 
     headers.insert_last_modified(date);

crates/brk_server/src/files/minify.rs

@@ -1,41 +0,0 @@
-// Source: https://github.com/oxc-project/oxc/blob/main/crates/oxc_minifier/examples/minifier.rs
-
-use std::{fs, path::Path};
-
-use oxc::{
-    allocator::Allocator,
-    codegen::{Codegen, CodegenOptions, LegalComment},
-    minifier::{CompressOptions, MangleOptions, Minifier, MinifierOptions},
-    parser::Parser,
-    span::SourceType,
-};
-
-pub fn minify_js(path: &Path) -> String {
-    let source_text = fs::read_to_string(path).unwrap();
-    let source_type = SourceType::from_path(path).unwrap();
-
-    let allocator = Allocator::default();
-
-    let parser_return = Parser::new(&allocator, &source_text, source_type).parse();
-
-    let mut program = parser_return.program;
-
-    let minifier_return = Minifier::new(MinifierOptions {
-        mangle: Some(MangleOptions::default()),
-        compress: Some(CompressOptions::default()),
-    })
-    .build(&allocator, &mut program);
-
-    Codegen::new()
-        .with_options(CodegenOptions {
-            minify: true,
-            single_quote: false,
-            comments: false,
-            annotation_comments: false,
-            source_map_path: None,
-            legal_comments: LegalComment::None,
-        })
-        .with_scoping(minifier_return.scoping)
-        .build(&program)
-        .code
-}

crates/brk_server/src/files/mod.rs

@@ -3,7 +3,6 @@ use axum::{Router, routing::get};
 use super::AppState;
 
 mod file;
-mod minify;
 mod website;
 
 use file::{file_handler, index_handler};

crates/brk_server/src/lib.rs

@@ -10,7 +10,7 @@ use std::{
     time::Duration,
 };
 
-use api::{ApiRoutes, DTS};
+use api::{ApiRoutes, Bridge};
 use axum::{
     Json, Router,
     body::Body,
@@ -19,6 +19,7 @@ use axum::{
     routing::get,
     serve,
 };
+use brk_bundler::bundle;
 use brk_computer::Computer;
 use brk_core::dot_brk_path;
 use brk_indexer::Indexer;
@@ -45,10 +46,20 @@ pub struct AppState {
     websites_path: Option<PathBuf>,
 }
 
+impl AppState {
+    pub fn dist_path(&self) -> PathBuf {
+        self.websites_path
+            .as_ref()
+            .expect("Should never reach here is websites_path is None")
+            .join("dist")
+    }
+}
+
+pub const VERSION: &str = env!("CARGO_PKG_VERSION");
+
 const DEV_PATH: &str = "../..";
 const DOWNLOADS: &str = "downloads";
 const WEBSITES: &str = "websites";
-const VERSION: &str = env!("CARGO_PKG_VERSION");
 
 pub struct Server(AppState);
 
@@ -88,7 +99,7 @@ impl Server {
                 downloaded_websites_path
             };
 
-            query.generate_dts_file(website, websites_path.as_path())?;
+            query.generate_bridge_file(website, websites_path.as_path())?;
 
             Some(websites_path)
         } else {
@@ -102,9 +113,13 @@ impl Server {
         }))
     }
 
-    pub async fn serve(self) -> color_eyre::Result<()> {
+    pub async fn serve(self, watch: bool) -> color_eyre::Result<()> {
         let state = self.0;
 
+        if let Some(websites_path) = state.websites_path.clone() {
+            bundle(&websites_path, state.website.to_folder_name(), watch).await?;
+        }
+
         let compression_layer = CompressionLayer::new()
             .br(true)
             .deflate(true)

crates/brk_server/src/traits/header_map.rs

@@ -5,12 +5,11 @@ use std::{
 
 use axum::http::{
     HeaderMap,
-    header::{self, HOST, IF_MODIFIED_SINCE},
+    header::{self, IF_MODIFIED_SINCE},
 };
 use jiff::{Timestamp, civil::DateTime, fmt::strtime, tz::TimeZone};
 use log::info;
 
-const STALE_IF_ERROR: u64 = 30_000_000; // 1 Year ish
 const MODIFIED_SINCE_FORMAT: &str = "%a, %d %b %Y %H:%M:%S GMT";
 
 #[derive(PartialEq, Eq)]
@@ -20,12 +19,6 @@ pub enum ModifiedState {
 }
 
 pub trait HeaderMapExtended {
-    fn _get_scheme(&self) -> &str;
-    fn get_host(&self) -> &str;
-    fn check_if_host_is_local(&self) -> bool;
-    fn check_if_host_is_0000(&self) -> bool;
-    fn check_if_host_is_localhost(&self) -> bool;
-
     fn insert_cors(&mut self);
 
     fn get_if_modified_since(&self) -> Option<DateTime>;
@@ -36,8 +29,8 @@ pub trait HeaderMapExtended {
         duration: Duration,
     ) -> color_eyre::Result<(ModifiedState, DateTime)>;
 
+    fn insert_cache_control_must_revalidate(&mut self);
     fn insert_cache_control_immutable(&mut self);
-    fn _insert_cache_control_revalidate(&mut self, max_age: u64, stale_while_revalidate: u64);
     fn insert_last_modified(&mut self, date: DateTime);
 
     fn insert_content_disposition_attachment(&mut self);
@@ -59,41 +52,22 @@ pub trait HeaderMapExtended {
 }
 
 impl HeaderMapExtended for HeaderMap {
-    fn _get_scheme(&self) -> &str {
-        if self.check_if_host_is_local() {
-            "http"
-        } else {
-            "https"
-        }
-    }
-
-    fn get_host(&self) -> &str {
-        self[HOST].to_str().unwrap()
-    }
-
-    fn check_if_host_is_local(&self) -> bool {
-        self.check_if_host_is_localhost() || self.check_if_host_is_0000()
-    }
-
-    fn check_if_host_is_0000(&self) -> bool {
-        self.get_host().contains("0.0.0.0")
-    }
-
-    fn check_if_host_is_localhost(&self) -> bool {
-        self.get_host().contains("localhost")
-    }
-
     fn insert_cors(&mut self) {
         self.insert(header::ACCESS_CONTROL_ALLOW_ORIGIN, "*".parse().unwrap());
         self.insert(header::ACCESS_CONTROL_ALLOW_HEADERS, "*".parse().unwrap());
     }
 
+    fn insert_cache_control_must_revalidate(&mut self) {
+        self.insert(
+            header::CACHE_CONTROL,
+            "public, max-age=0, must-revalidate".parse().unwrap(),
+        );
+    }
+
     fn insert_cache_control_immutable(&mut self) {
         self.insert(
             header::CACHE_CONTROL,
-            format!("public, max-age=604800, immutable, stale-if-error={STALE_IF_ERROR}")
-                .parse()
-                .unwrap(),
+            "public, max-age=31536000, immutable".parse().unwrap(),
         );
     }
 
@@ -101,16 +75,6 @@ impl HeaderMapExtended for HeaderMap {
         self.insert(header::CONTENT_DISPOSITION, "attachment".parse().unwrap());
     }
 
-    fn _insert_cache_control_revalidate(&mut self, max_age: u64, stale_while_revalidate: u64) {
-        self.insert(
-        header::CACHE_CONTROL,
-        format!(
-            "public, max-age={max_age}, stale-while-revalidate={stale_while_revalidate}, stale-if-error={STALE_IF_ERROR}")
-        .parse()
-        .unwrap(),
-    );
-    }
-
     fn insert_last_modified(&mut self, date: DateTime) {
         let formatted = date
             .to_zoned(TimeZone::system())
@@ -167,7 +131,7 @@ impl HeaderMapExtended for HeaderMap {
     fn insert_content_type(&mut self, path: &Path) {
         match path.extension().unwrap().to_str().unwrap() {
             "js" => self.insert_content_type_application_javascript(),
-            "json" => self.insert_content_type_application_json(),
+            "json" | "map" => self.insert_content_type_application_json(),
             "html" => self.insert_content_type_text_html(),
             "css" => self.insert_content_type_text_css(),
             "toml" | "txt" => self.insert_content_type_text_plain(),

crates/brk_vec/src/structs/format.rs

@@ -8,8 +8,8 @@ use serde::{Deserialize, Serialize};
     Default, Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, ValueEnum,
 )]
 pub enum Format {
-    #[default]
     Compressed,
+    #[default]
     Raw,
 }
 

crates/brk_vec/src/traits/any.rs

@@ -13,6 +13,7 @@ pub trait AnyVec: Send + Sync {
     }
     fn modified_time(&self) -> Result<Duration>;
     fn index_type_to_string(&self) -> String;
+    fn value_type_to_size_of(&self) -> usize;
 }
 
 pub trait AnyIterableVec<I, T>: AnyVec {

crates/brk_vec/src/traits/collectable.rs

@@ -27,13 +27,19 @@ where
     #[inline]
     fn i64_to_usize(i: i64, len: usize) -> usize {
         if i >= 0 {
-            i as usize
+            (i as usize).min(len)
         } else {
             let v = len as i64 + i;
             if v < 0 { 0 } else { v as usize }
         }
     }
 
+    fn range_count(from: Option<i64>, to: Option<i64>, len: usize) -> usize {
+        let from = from.map(|i| Self::i64_to_usize(i, len));
+        let to = to.map(|i| Self::i64_to_usize(i, len));
+        (from.unwrap_or_default()..to.unwrap_or(len)).count()
+    }
+
     #[doc(hidden)]
     fn collect_signed_range(&self, from: Option<i64>, to: Option<i64>) -> Result<Vec<T>> {
         let len = self.len();

crates/brk_vec/src/traits/generic.rs

@@ -31,7 +31,7 @@ where
     }
     #[inline]
     fn get_or_read_(&self, index: usize, mmap: &Mmap) -> Result<Option<Value<T>>> {
-        let stored_len = mmap.len() / Self::SIZE_OF_T;
+        let stored_len = self.stored_len_(mmap);
 
         if index >= stored_len {
             let pushed = self.pushed();
@@ -53,6 +53,7 @@ where
     fn mmap(&self) -> &ArcSwap<Mmap>;
 
     fn stored_len(&self) -> usize;
+    fn stored_len_(&self, mmap: &Mmap) -> usize;
 
     fn pushed(&self) -> &[T];
     #[inline]

crates/brk_vec/src/variants/compressed.rs

@@ -21,7 +21,9 @@ use crate::{
 const ONE_KIB: usize = 1024;
 const ONE_MIB: usize = ONE_KIB * ONE_KIB;
 pub const MAX_CACHE_SIZE: usize = 100 * ONE_MIB;
-pub const MAX_PAGE_SIZE: usize = 16 * ONE_KIB;
+pub const MAX_PAGE_SIZE: usize = 64 * ONE_KIB;
+
+const VERSION: Version = Version::ONE;
 
 #[derive(Debug)]
 pub struct CompressedVec<I, T> {
@@ -39,7 +41,9 @@ where
     pub const CACHE_LENGTH: usize = MAX_CACHE_SIZE / Self::PAGE_SIZE;
 
     /// Same as import but will reset the folder under certain errors, so be careful !
-    pub fn forced_import(path: &Path, version: Version) -> Result<Self> {
+    pub fn forced_import(path: &Path, mut version: Version) -> Result<Self> {
+        version = version + VERSION;
+
         let res = Self::import(path, version);
         match res {
             Err(Error::WrongEndian)
@@ -129,7 +133,7 @@ where
         page_index * Self::PER_PAGE
     }
 
-    fn stored_len_(pages_meta: &Guard<Arc<CompressedPagesMetadata>>) -> usize {
+    fn stored_len__(pages_meta: &Guard<Arc<CompressedPagesMetadata>>) -> usize {
         if let Some(last) = pages_meta.last() {
             (pages_meta.len() - 1) * Self::PER_PAGE + last.values_len as usize
         } else {
@@ -178,7 +182,11 @@ where
 
     #[inline]
     fn stored_len(&self) -> usize {
-        Self::stored_len_(&self.pages_meta.load())
+        Self::stored_len__(&self.pages_meta.load())
+    }
+    #[inline]
+    fn stored_len_(&self, _: &Mmap) -> usize {
+        self.stored_len()
     }
 
     #[inline]
@@ -361,6 +369,11 @@ where
     fn index_type_to_string(&self) -> String {
         I::to_string()
     }
+
+    #[inline]
+    fn value_type_to_size_of(&self) -> usize {
+        size_of::<T>()
+    }
 }
 
 impl<I, T> Clone for CompressedVec<I, T> {
@@ -472,7 +485,7 @@ where
 
     fn into_iter(self) -> Self::IntoIter {
         let pages_meta = self.pages_meta.load();
-        let stored_len = CompressedVec::<I, T>::stored_len_(&pages_meta);
+        let stored_len = CompressedVec::<I, T>::stored_len__(&pages_meta);
         CompressedVecIterator {
             vec: self,
             guard: self.mmap().load(),

crates/brk_vec/src/variants/computed.rs

@@ -255,6 +255,11 @@ where
             ComputedVec::LazyFrom3(v) => v.modified_time(),
         }
     }
+
+    #[inline]
+    fn value_type_to_size_of(&self) -> usize {
+        size_of::<T>()
+    }
 }
 
 pub enum ComputedVecIterator<'a, I, T, S1I, S1T, S2I, S2T, S3I, S3T> {

crates/brk_vec/src/variants/eager.rs

@@ -1116,12 +1116,12 @@ impl EagerVec<DateIndex, Dollars> {
         exit: &Exit,
     ) -> Result<()> {
         self.validate_computed_version_or_reset_file(
-            Version::ZERO + self.inner.version() + stacks.version(),
+            Version::ONE + self.inner.version() + stacks.version(),
         )?;
 
         let index = max_from.min(DateIndex::from(self.len()));
 
-        let first_price_date = DateIndex::try_from(Date::new(2010, 8, 16)).unwrap();
+        let first_price_date = DateIndex::try_from(Date::new(2010, 7, 12)).unwrap();
 
         stacks.iter_at(index).try_for_each(|(i, stack)| {
             let stack = stack.into_inner();
@@ -1298,6 +1298,11 @@ where
     fn index_type_to_string(&self) -> String {
         I::to_string()
     }
+
+    #[inline]
+    fn value_type_to_size_of(&self) -> usize {
+        size_of::<T>()
+    }
 }
 
 impl<I, T> AnyIterableVec<I, T> for EagerVec<I, T>

crates/brk_vec/src/variants/indexed.rs

@@ -127,6 +127,11 @@ where
     fn index_type_to_string(&self) -> String {
         I::to_string()
     }
+
+    #[inline]
+    fn value_type_to_size_of(&self) -> usize {
+        size_of::<T>()
+    }
 }
 
 pub trait AnyIndexedVec: AnyVec {

crates/brk_vec/src/variants/lazy1.rs

@@ -146,6 +146,11 @@ where
     fn modified_time(&self) -> Result<std::time::Duration> {
         self.source.modified_time()
     }
+
+    #[inline]
+    fn value_type_to_size_of(&self) -> usize {
+        size_of::<T>()
+    }
 }
 
 impl<I, T, S1I, S1T> AnyIterableVec<I, T> for LazyVecFrom1<I, T, S1I, S1T>

crates/brk_vec/src/variants/lazy2.rs

@@ -194,6 +194,11 @@ where
             .modified_time()?
             .min(self.source2.modified_time()?))
     }
+
+    #[inline]
+    fn value_type_to_size_of(&self) -> usize {
+        size_of::<T>()
+    }
 }
 
 impl<I, T, S1I, S1T, S2I, S2T> AnyIterableVec<I, T> for LazyVecFrom2<I, T, S1I, S1T, S2I, S2T>

crates/brk_vec/src/variants/lazy3.rs

@@ -229,6 +229,11 @@ where
             .min(self.source2.modified_time()?)
             .min(self.source3.modified_time()?))
     }
+
+    #[inline]
+    fn value_type_to_size_of(&self) -> usize {
+        size_of::<T>()
+    }
 }
 
 impl<I, T, S1I, S1T, S2I, S2T, S3I, S3T> AnyIterableVec<I, T>

crates/brk_vec/src/variants/raw.rs

@@ -48,8 +48,10 @@ where
         fs::create_dir_all(path)?;
 
         let version_path = Self::path_version_(path);
-        version.validate(version_path.as_ref())?;
-        version.write(version_path.as_ref())?;
+
+        if !version.validate(version_path.as_ref())? {
+            version.write(version_path.as_ref())?;
+        }
 
         let file = Self::open_file_(Self::path_vec_(path).as_path())?;
         let mmap = Arc::new(ArcSwap::new(Self::new_mmap(file)?));
@@ -102,7 +104,11 @@ where
 
     #[inline]
     fn stored_len(&self) -> usize {
-        self.mmap.load().len() / Self::SIZE_OF_T
+        self.stored_len_(&self.mmap.load())
+    }
+    #[inline]
+    fn stored_len_(&self, mmap: &Mmap) -> usize {
+        mmap.len() / Self::SIZE_OF_T
     }
 
     #[inline]
@@ -195,6 +201,11 @@ where
     fn index_type_to_string(&self) -> String {
         I::to_string()
     }
+
+    #[inline]
+    fn value_type_to_size_of(&self) -> usize {
+        size_of::<T>()
+    }
 }
 
 impl<I, T> Clone for RawVec<I, T> {

crates/brk_vec/src/variants/stored.rs

@@ -73,6 +73,13 @@ where
             StoredVec::Compressed(v) => v.stored_len(),
         }
     }
+    #[inline]
+    fn stored_len_(&self, mmap: &Mmap) -> usize {
+        match self {
+            StoredVec::Raw(v) => v.stored_len_(mmap),
+            StoredVec::Compressed(v) => v.stored_len_(mmap),
+        }
+    }
 
     #[inline]
     fn pushed(&self) -> &[T] {
@@ -149,6 +156,11 @@ where
             StoredVec::Compressed(v) => v.name(),
         }
     }
+
+    #[inline]
+    fn value_type_to_size_of(&self) -> usize {
+        size_of::<T>()
+    }
 }
 
 #[derive(Debug)]

websites/default/generate-icons.sh

@@ -1,33 +0,0 @@
-#!/usr/bin/env bash
-
-DATE=$(date -u '+%Y-%m-%d_%H-%M-%S')
-OUTPUT="/assets/pwa/${DATE}"
-
-mkdir ".${OUTPUT}"
-cp "./assets/pwa/index.html" ".${OUTPUT}/"
-
-pwa-asset-generator "../assets/dove-orange.svg" ".${OUTPUT}" \
-    --index ".${OUTPUT}/index.html" \
-    --manifest "./manifest.webmanifest" \
-    --favicon \
-    --padding "0%" \
-    --path-override "${OUTPUT}" \
-    --quality "100" \
-    --opaque "false"
-
-pwa-asset-generator "../assets/dove-white.svg" ".${OUTPUT}" \
-    --index ".${OUTPUT}/index.html" \
-    --manifest "./manifest.webmanifest" \
-    --icon-only \
-    --background "#f26610" \
-    --padding "10%" \
-    --path-override "${OUTPUT}" \
-    --quality "100"
-
-pwa-asset-generator "../assets/logo-stamp-orange.svg" ".${OUTPUT}" \
-    --index ".${OUTPUT}/index.html" \
-    --splash-only \
-    --background "#f26610" \
-    --padding "min(30vh, 30vw)" \
-    --path-override "${OUTPUT}" \
-    --quality "100"

websites/default/index.html

@@ -1,8 +1,7 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
   <head>
     <meta charset="utf-8" />
-    <!-- <title>kibo.money</title> -->
     <meta
       name="description"
       content="An open source Bitcoin Core data extractor and visualizer"
@@ -13,7 +12,7 @@
     />
     <link rel="manifest" href="/manifest.webmanifest" />
     <meta name="mobile-web-app-capable" content="yes" />
-    <script type="module" crossorigin src="/scripts/main.js"></script>
+    <script type="module" src="/scripts/main.js"></script>
 
     <!-- ------ -->
     <!-- Styles -->
@@ -282,7 +281,7 @@
 
       @font-face {
         font-family: "Geist mono";
-        src: url("./assets/fonts/geist_mono_var_1_4_01.woff2") format("woff2");
+        src: url("./assets/fonts/geist_mono_var_v1_5_0.woff2") format("woff2");
         font-weight: 100 900;
         font-display: block;
         font-style: normal;
@@ -649,17 +648,9 @@
         height: 100%;
         display: flex;
         flex-direction: column;
-        gap: 2rem;
         padding-bottom: var(--bottom-area);
       }
 
-      nav {
-        header {
-          display: flex;
-          justify-content: center;
-        }
-      }
-
       sup {
         opacity: 0.5;
         margin-left: 0.25rem;
@@ -728,6 +719,7 @@
        */
 
       .tree {
+        margin-top: -0.125rem;
         user-select: none;
         -webkit-user-select: none;
 
@@ -800,14 +792,6 @@
         }
       }
 
-      search {
-        ul {
-          display: flex;
-          flex-direction: column;
-          gap: 1rem;
-        }
-      }
-
       #share-div {
         font-size: var(--font-size-sm);
         line-height: var(--line-height-sm);
@@ -848,16 +832,12 @@
       }
 
       search {
-        > #search-no-input-text {
-          color: var(--off-color);
+        gap: 1rem;
 
-          &:has(+ ul li) {
-            display: none;
-          }
-
-          > button {
-            color: var(--color);
-          }
+        ul {
+          display: flex;
+          flex-direction: column;
+          gap: 0.5rem;
         }
       }
 
@@ -985,7 +965,7 @@
         display: flex;
         align-items: center;
         gap: 1.5rem;
-        margin: -0.75rem var(--negative-main-padding);
+        margin: -0.5rem var(--negative-main-padding);
         padding: 0.75rem var(--main-padding);
         overflow-x: auto;
         min-width: 0;
@@ -1123,6 +1103,268 @@
           }
         }
       }
+
+      #charts {
+        display: flex;
+        flex-direction: column;
+        height: 100%;
+        width: 100%;
+        min-height: 0;
+        padding: var(--main-padding);
+
+        header {
+          flex-shrink: 0;
+          display: flex;
+
+          white-space: nowrap;
+          overflow-x: auto;
+          padding-bottom: 1rem;
+          margin-bottom: -2rem;
+          padding-left: var(--main-padding);
+          margin-left: var(--negative-main-padding);
+          padding-right: var(--main-padding);
+          margin-right: var(--negative-main-padding);
+
+          & > * {
+            flex: 1;
+          }
+        }
+
+        .chart {
+          flex: 1;
+        }
+
+        > .chart > legend,
+        > fieldset {
+          z-index: 20;
+        }
+
+        .lightweight-chart {
+          z-index: 40;
+        }
+      }
+
+      #table {
+        width: 100%;
+        display: flex;
+        flex-direction: column;
+        gap: 2rem;
+        padding: var(--main-padding);
+
+        > div {
+          display: flex;
+          font-size: var(--font-size-xs);
+          line--line-height: var(--line-height-xs);
+          font-weight: 450;
+          margin-left: var(--negative-main-padding);
+          margin-right: var(--negative-main-padding);
+
+          table {
+            z-index: 10;
+            border-top-width: 1px;
+            border-style: dashed !important;
+            /* width: 100%; */
+            line-height: var(--line-height-sm);
+            text-transform: uppercase;
+            table-layout: auto;
+            border-collapse: separate;
+            border-spacing: 0;
+            /* border: 3px solid purple; */
+            /* min-height: 100%; */
+          }
+
+          th {
+            font-weight: 600;
+          }
+
+          th,
+          td {
+            /* border-top: 1px; */
+            border-right: 1px;
+            border-bottom: 1px;
+            border-color: var(--off-color);
+            border-style: dashed !important;
+            padding: 0.25rem 0.75rem;
+          }
+
+          td {
+            text-transform: lowercase;
+          }
+
+          a {
+            margin: -0.2rem 0;
+            font-size: 1.2rem;
+          }
+
+          th:first-child {
+            padding-left: var(--main-padding);
+          }
+
+          th[scope="col"] {
+            position: sticky;
+            top: 0;
+            background-color: var(--background-color);
+
+            > div {
+              display: flex;
+              flex-direction: column;
+              padding-top: 0.275rem;
+
+              > div {
+                display: flex;
+                gap: 0.25rem;
+                text-transform: lowercase;
+                color: var(--off-color);
+                text-align: left;
+
+                &:first-child {
+                  gap: 0.5rem;
+                }
+
+                &:last-child {
+                  gap: 1rem;
+                }
+
+                > span {
+                  width: 100%;
+                }
+
+                > button {
+                  padding: 0 0.25rem;
+                  margin: 0 -0.25rem;
+                  font-size: 0.75rem;
+                  line-height: 0;
+                }
+              }
+            }
+
+            &:first-child {
+              button {
+                display: none;
+              }
+            }
+
+            &:nth-child(2) {
+              button:nth-of-type(1) {
+                display: none;
+              }
+            }
+
+            &:last-child {
+              button:nth-of-type(2) {
+                display: none;
+              }
+            }
+          }
+
+          select {
+            margin-right: -4px;
+            /* width: 100%; */
+          }
+
+          tbody {
+            text-align: right;
+          }
+
+          > button {
+            padding: 1rem;
+            min-width: 10rem;
+            display: flex;
+            flex-direction: column;
+            flex: 1;
+            position: relative;
+            border-top-width: 1px;
+            width: 100%;
+            border-bottom-width: 1px;
+            border-style: dashed !important;
+
+            > span {
+              text-align: left;
+              position: sticky;
+              top: 2rem;
+              left: 0;
+              right: 0;
+            }
+          }
+        }
+      }
+
+      #simulation {
+        min-height: 0;
+        width: 100%;
+
+        > div {
+          display: flex;
+          flex-direction: column;
+          gap: 2rem;
+          padding: var(--main-padding);
+        }
+
+        @media (max-width: 767px) {
+          overflow-y: auto;
+
+          > div:first-child {
+            border-bottom: 1px;
+          }
+        }
+
+        @media (min-width: 768px) {
+          display: flex;
+          flex-direction: column;
+          height: 100%;
+          flex-direction: row;
+
+          > div {
+            flex: 1;
+            overflow-y: auto;
+            padding-bottom: var(--bottom-area);
+          }
+
+          > div:first-child {
+            max-width: var(--default-main-width);
+            border-right: 1px;
+          }
+        }
+
+        header {
+          margin-bottom: 0.5rem;
+        }
+
+        > div:last-child {
+          display: flex;
+          flex-direction: column;
+          gap: 1.5rem;
+          overflow-x: hidden;
+
+          p {
+            text-wrap: pretty;
+          }
+        }
+
+        label {
+          > span {
+            display: block;
+          }
+          small {
+            font-size: var(--font-size-sm);
+            line-height: var(--line-height-sm);
+            display: block;
+          }
+        }
+
+        .chart {
+          flex: none;
+          height: 400px;
+
+          .lightweight-chart {
+            margin-left: calc(var(--negative-main-padding) * 0.75);
+
+            fieldset {
+              margin-left: -0.5rem;
+            }
+          }
+        }
+      }
     </style>
 
     <!-- ------- -->
@@ -1133,7 +1375,7 @@
       // @ts-check
 
       const preferredColorSchemeMatchMedia = window.matchMedia(
-        "(prefers-color-scheme: dark)",
+        "(prefers-color-scheme: dark)"
       );
 
       const themeColor = window.document.createElement("meta");
@@ -1142,10 +1384,10 @@
 
       /** @param {boolean} dark */
       function updateThemeColor(dark) {
-        const backgroundColor = getComputedStyle(
-          window.document.documentElement,
+        const theme = getComputedStyle(
+          window.document.documentElement
         ).getPropertyValue(dark ? "--black" : "--white");
-        themeColor.content = backgroundColor;
+        themeColor.content = theme;
       }
 
       updateThemeColor(preferredColorSchemeMatchMedia.matches);
@@ -1153,7 +1395,7 @@
         "change",
         ({ matches }) => {
           updateThemeColor(matches);
-        },
+        }
       );
 
       if ("standalone" in window.navigator && !!window.navigator.standalone) {
@@ -1161,7 +1403,11 @@
       }
 
       if ("serviceWorker" in navigator) {
-        navigator.serviceWorker.register("/scripts/service-worker.js");
+        window.addEventListener("load", () => {
+          navigator.serviceWorker.register("/service-worker.js", {
+            scope: "/",
+          });
+        });
       }
     </script>
 
@@ -1608,13 +1854,15 @@
     </div>
 
     <script>
-      // Prevent width jumping
-      const savedWidth = localStorage.getItem("bar-width");
-      if (savedWidth) {
-        const main = window.document.getElementById("main");
-        if (!main) throw "Should exist";
-        main.style.width = `${savedWidth}px`;
-      }
+      try {
+        // Prevent width jumping
+        const savedWidth = localStorage.getItem("bar-width");
+        if (savedWidth) {
+          const main = window.document.getElementById("main");
+          if (!main) throw "Should exist";
+          main.style.width = `${savedWidth}px`;
+        }
+      } catch (_) {}
     </script>
   </body>
 </html>

websites/default/jsconfig.json

@@ -3,7 +3,8 @@
     "checkJs": true,
     "strict": true,
     "target": "ESNext",
-    "module": "ESNext"
+    "module": "ESNext",
+    "skipLibCheck": true
   },
   "exclude": ["assets", "packages", "ignore"]
 }

websites/default/manifest.webmanifest

@@ -1,6 +1,6 @@
 {
-  "name": "kibo.money",
-  "short_name": "kibo",
+  "name": "brk",
+  "short_name": "brk",
   "description": "A better, FOSS, Bitcoin-only, self-hostable Glassnode",
   "categories": [
     "bitcoin",

websites/default/misc/tailwindTo550.js

@@ -1,46 +0,0 @@
-(async () => {
-  const theme = await (
-    await fetch(
-      "https://github.com/tailwindlabs/tailwindcss/blob/main/packages/tailwindcss/theme.css",
-    )
-  ).text();
-
-  console.log(
-    [
-      "red",
-      "orange",
-      "amber",
-      "yellow",
-      "lime",
-      "green",
-      "emerald",
-      "teal",
-      "cyan",
-      "sky",
-      "blue",
-      "indigo",
-      "violet",
-      "purple",
-      "fuchsia",
-      "pink",
-      "rose",
-    ]
-      .map((color) => {
-        const [a, b] = [500, 600].map((shade) => {
-          const regExp = new RegExp(
-            `(?<=${`${color}-${shade}: oklch\(`})(.*?)(?=\\s*${`\);`})`,
-            "g",
-          );
-          let res = regExp.exec(theme)?.[2];
-          if (!res) throw "err";
-          res = res.replace("(", "");
-          res = res.replace(")", "");
-          // return res
-          return res.split(" ").map((s) => Number(s));
-        });
-        const mult = 10_000;
-        return `--${color}: oklch(${[0, 1, 2].map((i) => Math.round(((a[i] + b[i]) / 2) * mult) / mult).join(" ")})`;
-      })
-      .join(";\n"),
-  );
-})();

websites/default/packages/lean-qr/v2.3.4/types.d.ts

@@ -1,241 +0,0 @@
-declare module "lean-qr" {
-  interface ImageDataLike {
-    readonly data: Uint8ClampedArray;
-  }
-
-  interface Context2DLike<DataT extends ImageDataLike> {
-    createImageData(width: number, height: number): DataT;
-    putImageData(data: DataT, x: number, y: number): void;
-  }
-
-  interface CanvasLike<DataT extends ImageDataLike> {
-    width: number;
-    height: number;
-    getContext(type: "2d"): Context2DLike<DataT> | null;
-  }
-
-  export type RGBA = readonly [number, number, number, number?];
-
-  export interface Bitmap1D {
-    push(value: number, bits: number): void;
-  }
-
-  export interface StringOptions {
-    on?: string;
-    off?: string;
-    lf?: string;
-    padX?: number;
-    padY?: number;
-  }
-
-  export interface ImageDataOptions {
-    on?: RGBA;
-    off?: RGBA;
-    padX?: number;
-    padY?: number;
-  }
-
-  export interface Bitmap2D {
-    readonly size: number;
-
-    get(x: number, y: number): boolean;
-
-    toString(options?: Readonly<StringOptions>): string;
-
-    toImageData<DataT extends ImageDataLike>(
-      context: Context2DLike<DataT>,
-      options?: Readonly<ImageDataOptions>,
-    ): DataT;
-
-    toDataURL(
-      options?: Readonly<
-        ImageDataOptions & {
-          type?: `image/${string}`;
-          scale?: number;
-        }
-      >,
-    ): string;
-
-    toCanvas(
-      canvas: CanvasLike<ImageDataLike>,
-      options?: Readonly<ImageDataOptions>,
-    ): void;
-  }
-
-  export type Mask = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7;
-  export type Mode = (data: Bitmap1D, version: number) => void;
-  export interface ModeFactory {
-    (value: string): Mode;
-    test(string: string): boolean;
-    est(value: string, version: number): number;
-    eci?: number;
-  }
-
-  interface ModeAutoOptions {
-    modes?: ReadonlyArray<ModeFactory>;
-  }
-
-  export const mode: Readonly<{
-    auto(value: string, options?: Readonly<ModeAutoOptions>): Mode;
-    multi(...modes: ReadonlyArray<Mode>): Mode;
-    eci(id: number): Mode;
-    numeric: ModeFactory;
-    alphaNumeric: ModeFactory;
-    bytes(data: Uint8Array | ReadonlyArray<number>): Mode;
-    ascii: ModeFactory;
-    iso8859_1: ModeFactory;
-    shift_jis: ModeFactory;
-    utf8: ModeFactory;
-  }>;
-
-  type Correction = number & { readonly _: unique symbol };
-  export const correction: Readonly<{
-    min: Correction;
-    L: Correction;
-    M: Correction;
-    Q: Correction;
-    H: Correction;
-    max: Correction;
-  }>;
-
-  export interface GenerateOptions extends ModeAutoOptions {
-    minCorrectionLevel?: Correction;
-    maxCorrectionLevel?: Correction;
-    minVersion?: number;
-    maxVersion?: number;
-    mask?: null | Mask;
-    trailer?: number;
-  }
-
-  export type GenerateFn = (
-    data: Mode | string,
-    options?: Readonly<GenerateOptions>,
-  ) => Bitmap2D;
-  interface Generate extends GenerateFn {
-    with(...modes: ReadonlyArray<ModeFactory>): GenerateFn;
-  }
-  export const generate: Generate;
-}
-
-declare module "lean-qr/extras/svg" {
-  import type { Bitmap2D } from "lean-qr";
-
-  export interface SVGOptions {
-    on?: string;
-    off?: string;
-    padX?: number;
-    padY?: number;
-    width?: number | null;
-    height?: number | null;
-    scale?: number;
-  }
-
-  export const toSvgPath: (code: Bitmap2D) => string;
-
-  export const toSvg: (
-    code: Bitmap2D,
-    target: Document | SVGElement,
-    options?: Readonly<SVGOptions>,
-  ) => SVGElement;
-
-  export const toSvgSource: (
-    code: Bitmap2D,
-    options?: Readonly<SVGOptions & { xmlDeclaration?: boolean }>,
-  ) => string;
-
-  export type toSvgDataURLFn = (
-    code: Bitmap2D,
-    options?: Readonly<SVGOptions>,
-  ) => string;
-  export const toSvgDataURL: toSvgDataURLFn;
-}
-
-declare module "lean-qr/extras/node_export" {
-  import type { RGBA, Bitmap2D } from "lean-qr";
-
-  export interface PNGOptions {
-    on?: RGBA;
-    off?: RGBA;
-    padX?: number;
-    padY?: number;
-    scale?: number;
-  }
-
-  export const toPngBuffer: (
-    code: Bitmap2D,
-    options?: Readonly<PNGOptions>,
-  ) => Uint8Array;
-
-  export const toPngDataURL: (
-    code: Bitmap2D,
-    options?: Readonly<PNGOptions>,
-  ) => string;
-}
-
-declare module "lean-qr/extras/react" {
-  import type { ImageDataOptions, GenerateOptions, GenerateFn } from "lean-qr";
-  import type { SVGOptions, toSvgDataURLFn } from "lean-qr/extras/svg";
-
-  export interface AsyncFramework<T> {
-    createElement: (
-      type: "canvas",
-      props: {
-        ref: any;
-        style: { imageRendering: "pixelated" };
-        className: string;
-      },
-    ) => T;
-    useRef<T>(initialValue: T | null): { readonly current: T | null };
-    useEffect(fn: () => void | (() => void), deps: unknown[]): void;
-  }
-
-  interface QRComponentProps {
-    content: string;
-    className?: string;
-  }
-
-  export interface AsyncQRComponentProps
-    extends ImageDataOptions,
-      GenerateOptions,
-      QRComponentProps {}
-
-  export type AsyncQRComponent<T> = (
-    props: Readonly<AsyncQRComponentProps>,
-  ) => T;
-
-  export const makeAsyncComponent: <T>(
-    framework: Readonly<AsyncFramework<T>>,
-    generate: GenerateFn,
-    defaultProps?: Readonly<Partial<AsyncQRComponentProps>>,
-  ) => AsyncQRComponent<T>;
-
-  export interface SyncFramework<T> {
-    createElement: (
-      type: "img",
-      props: {
-        src: string;
-        style: { imageRendering: "pixelated" };
-        className: string;
-      },
-    ) => T;
-    useMemo<T>(fn: () => T, deps: unknown[]): T;
-  }
-
-  export interface SyncQRComponentProps
-    extends SVGOptions,
-      GenerateOptions,
-      QRComponentProps {}
-
-  export type SyncQRComponent<T> = (props: Readonly<SyncQRComponentProps>) => T;
-
-  export const makeSyncComponent: <T>(
-    framework: Readonly<SyncFramework<T>>,
-    generate: GenerateFn,
-    toSvgDataURL: toSvgDataURLFn,
-    defaultProps?: Readonly<Partial<SyncQRComponentProps>>,
-  ) => SyncQRComponent<T>;
-}
-
-declare module "lean-qr/extras/errors" {
-  export const readError: (error: unknown) => string;
-}

websites/default/packages/lean-qr/v2.5.0/types.d.ts

@@ -0,0 +1,491 @@
+declare module "lean-qr" {
+  interface ImageDataLike {
+    readonly data: Uint8ClampedArray;
+  }
+
+  interface Context2DLike<DataT extends ImageDataLike> {
+    createImageData(width: number, height: number): DataT;
+    putImageData(data: DataT, x: number, y: number): void;
+  }
+
+  interface CanvasLike<DataT extends ImageDataLike> {
+    width: number;
+    height: number;
+    getContext(type: "2d"): Context2DLike<DataT> | null;
+  }
+
+  /**
+   * A colour in `[red, green, blue, alpha]` format (all values from 0 to 255).
+   * If alpha is omitted, it is assumed to be 255 (opaque).
+   */
+  export type RGBA = readonly [number, number, number, number?];
+
+  export interface Bitmap1D {
+    /**
+     * Appends a sequence of bits.
+     *
+     * @param value an integer containing the bits to append (big endian).
+     * @param bits the number of bits to read from `value`. Must be between 1 and 24.
+     */
+    push(value: number, bits: number): void;
+  }
+
+  export interface StringOptions {
+    /** the text to use for modules which are 'on' (typically black) */
+    on?: string;
+
+    /** the text to use for modules which are 'off' (typically white) */
+    off?: string;
+
+    /** the text to use for linefeeds between rows */
+    lf?: string;
+
+    /** the padding to apply on the left and right of the output (populated with 'off' modules) */
+    padX?: number;
+
+    /** the padding to apply on the top and bottom of the output (populated with 'off' modules) */
+    padY?: number;
+  }
+
+  export interface ImageDataOptions {
+    /** the colour to use for modules which are 'on' (typically black) */
+    on?: RGBA;
+
+    /** the colour to use for modules which are 'off' (typically white) */
+    off?: RGBA;
+
+    /** the padding to apply on the left and right of the output (filled with 'off') */
+    padX?: number;
+
+    /** the padding to apply on the top and bottom of the output (filled with 'off') */
+    padY?: number;
+  }
+
+  export interface Bitmap2D {
+    /** the width / height of the QR code in modules (excluding any padding) */
+    readonly size: number;
+
+    /**
+     * Read the state of a module from the QR code.
+     *
+     * @param x the x coordinate to read. Can be negative / out of bounds.
+     * @param y the y coordinate to read. Can be negative / out of bounds.
+     * @returns true if the requested module is set (i.e. typically black)
+     */
+    get(x: number, y: number): boolean;
+
+    /**
+     * Generate a string containing the QR code, suitable for displaying in a
+     * terminal environment. Generally, you should customise on and off to use
+     * the ANSI escapes of your target terminal for better rendering.
+     *
+     * @param options optional configuration for the display.
+     */
+    toString(options?: Readonly<StringOptions>): string;
+
+    /**
+     * Generate image data containing the QR code, at a scale of 1 pixel per
+     * module. Use this if you need more control than toCanvas allows.
+     *
+     * @param context a context to use for creating the image data.
+     * @param options optional configuration for the display.
+     */
+    toImageData<DataT extends ImageDataLike>(
+      context: Context2DLike<DataT>,
+      options?: Readonly<ImageDataOptions>
+    ): DataT;
+
+    /**
+     * Generate a `data:image/*` URL for the QR code.
+     *
+     * @param options optional configuration for the output.
+     * @returns a string suitable for use as the `src` of an `img` tag.
+     */
+    toDataURL(
+      options?: Readonly<
+        ImageDataOptions & {
+          type?: `image/${string}`;
+          scale?: number;
+        }
+      >
+    ): string;
+
+    /**
+     * Populate a given canvas with the QR code, at a scale of 1 pixel per
+     * module. Set image-rendering: pixelated and scale the canvas using CSS
+     * for a large image. Automatically resizes the canvas to fit the QR code
+     * if necessary.
+     *
+     * @param canvas the canvas to populate.
+     * @param options optional configuration for the display.
+     */
+    toCanvas(
+      canvas: CanvasLike<ImageDataLike>,
+      options?: Readonly<ImageDataOptions>
+    ): void;
+  }
+
+  export type Mask = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7;
+  export type Mode = (data: Bitmap1D, version: number) => void;
+  export interface ModeFactory {
+    (value: string): Mode;
+    /** a function which returns true when given a character which the current mode can represent */
+    test(string: string): boolean;
+    /** a function which returns an estimate of the number of bits required to encode a given value */
+    est(value: string, version: number): number;
+    /** an optional ECI which must be active for this mode to be interpreted correctly by a reader */
+    eci?: number;
+  }
+
+  interface ModeAutoOptions {
+    /** a list of modes which can be considered when encoding a message */
+    modes?: ReadonlyArray<ModeFactory>;
+  }
+
+  export const mode: Readonly<{
+    /** automatically picks the most optimal combination of modes for the requested message */
+    auto(value: string, options?: Readonly<ModeAutoOptions>): Mode;
+    /** concatenates multiple modes together */
+    multi(...modes: ReadonlyArray<Mode>): Mode;
+    /** sets the Extended Channel Interpretation for the message from this point onwards */
+    eci(id: number): Mode;
+    /** supports `0-9` and stores 3 characters per 10 bits */
+    numeric: ModeFactory;
+    /** supports `0-9A-Z $%*+-./:` and stores 2 characters per 11 bits */
+    alphaNumeric: ModeFactory;
+    /** arbitrary byte data, typically combined with `eci` */
+    bytes(data: Uint8Array | ReadonlyArray<number>): Mode;
+    /** supports 7-bit ASCII and stores 1 character per 8 bits with no ECI */
+    ascii: ModeFactory;
+    /** supports 8-bit ISO-8859-1 and stores 1 character per 8 bits with ECI 3 */
+    iso8859_1: ModeFactory;
+    /** supports double-byte Shift-JIS characters stores 1 character per 13 bits */
+    shift_jis: ModeFactory;
+    /** supports variable length UTF-8 with ECI 26 */
+    utf8: ModeFactory;
+  }>;
+
+  export type Correction = number & { readonly _: unique symbol };
+  export const correction: Readonly<{
+    /** minimum possible correction level (same as L) */
+    min: Correction;
+    /** ~7.5% error tolerance, ~25% data overhead */
+    L: Correction;
+    /** ~15% error tolerance, ~60% data overhead */
+    M: Correction;
+    /** ~22.5% error tolerance, ~120% data overhead */
+    Q: Correction;
+    /** ~30% error tolerance, ~190% data overhead */
+    H: Correction;
+    /** maximum possible correction level (same as H) */
+    max: Correction;
+  }>;
+
+  export interface GenerateOptions extends ModeAutoOptions {
+    /** the minimum correction level to use (higher levels may still be used if the chosen version has space) */
+    minCorrectionLevel?: Correction;
+    /** the maximum correction level to use */
+    maxCorrectionLevel?: Correction;
+    /** the minimum version (size) of code to generate (must be between 1 and 40) */
+    minVersion?: number;
+    /** the maximum version (size) of code to generate (must be between 1 and 40) */
+    maxVersion?: number;
+    /** a mask to use on the QR code (should be left as `null` for ISO compliance but may be changed for artistic effect) */
+    mask?: null | Mask;
+    /** padding bits to use for extra space in the QR code (should be left as the default for ISO compliance but may be changed for artistic effect) */
+    trailer?: number;
+  }
+
+  /**
+   * Generate a QR code.
+   *
+   * @param data either a string, or a pre-encoded mode.
+   * @param options optional configuration for the QR code.
+   * @returns the requested QR code.
+   */
+  export type GenerateFn = (
+    data: Mode | string,
+    options?: Readonly<GenerateOptions>
+  ) => Bitmap2D;
+  interface Generate extends GenerateFn {
+    /**
+     * Creates a scoped `generate` function which considers additional modes
+     * when using auto encoding.
+     *
+     * @param modes the modes to add.
+     * @returns a `generate` function which will additionally consider the
+     * given modes when using auto encoding.
+     */
+    with(...modes: ReadonlyArray<ModeFactory>): GenerateFn;
+  }
+  export const generate: Generate;
+}
+
+declare module "lean-qr/nano" {
+  import type {
+    Correction,
+    Bitmap2D as FullBitmap2D,
+    GenerateOptions as FullGenerateOptions,
+  } from "lean-qr";
+  import { correction as fullCorrection } from "lean-qr";
+
+  export type { Correction };
+
+  export const correction: Pick<typeof fullCorrection, "L" | "M" | "Q" | "H">;
+
+  export type Bitmap2D = Pick<FullBitmap2D, "size" | "get" | "toCanvas">;
+
+  export type GenerateOptions = Pick<
+    FullGenerateOptions,
+    "minCorrectionLevel" | "minVersion"
+  >;
+
+  /**
+   * Generate a QR code.
+   *
+   * @param data either a string, or a pre-encoded mode.
+   * @param options optional configuration for the QR code.
+   * @returns the requested QR code.
+   */
+  export function generate(
+    data: string,
+    options?: Readonly<GenerateOptions>
+  ): Bitmap2D;
+}
+
+declare module "lean-qr/extras/svg" {
+  import type { Bitmap2D as FullBitmap2D } from "lean-qr";
+
+  type Bitmap2D = Pick<FullBitmap2D, "size" | "get">;
+
+  export interface SVGOptions {
+    /** the colour to use for modules which are 'on' (typically black) */
+    on?: string;
+    /** the colour to use for modules which are 'off' (typically white) */
+    off?: string;
+    /** the padding to apply on the left and right of the output (filled with 'off') */
+    padX?: number;
+    /** the padding to apply on the top and bottom of the output (filled with 'off') */
+    padY?: number;
+    /** a width to apply to the resulting image (overrides `scale`) */
+    width?: number | null;
+    /** a height to apply to the resulting image (overrides `scale`) */
+    height?: number | null;
+    /** a scale to apply to the resulting image (`scale` pixels = 1 module) */
+    scale?: number;
+  }
+
+  /**
+   * Generate the raw outline of the QR code for use in an existing SVG.
+   *
+   * @param code the QR code to convert.
+   * @returns a string suitable for passing to the `d` attribute of a `path`.
+   */
+  export function toSvgPath(code: Bitmap2D): string;
+
+  /**
+   * Generate an SVG element which can be added to the DOM.
+   *
+   * @param code the QR code to convert.
+   * @param options optional configuration for the display.
+   * @returns an SVG element.
+   */
+  export function toSvg(
+    code: Bitmap2D,
+    target: Document | SVGElement,
+    options?: Readonly<SVGOptions>
+  ): SVGElement;
+
+  /**
+   * Generate an SVG document which can be exported to a file or served from a
+   * web server.
+   *
+   * @param code the QR code to convert.
+   * @param options optional configuration for the display.
+   * @returns an SVG document.
+   */
+  export function toSvgSource(
+    code: Bitmap2D,
+    options?: Readonly<
+      SVGOptions & {
+        /** `true` to include an XML declaration at the start of the source (for standalone documents which will not be embedded inside another document) */
+        xmlDeclaration?: boolean;
+      }
+    >
+  ): string;
+
+  /**
+   * Generate a `data:image/svg+xml` URL.
+   *
+   * @param code the QR code to convert.
+   * @param options optional configuration for the display.
+   * @returns a string suitable for use as the `src` of an `img` tag.
+   */
+  export function toSvgDataURL(
+    code: Bitmap2D,
+    options?: Readonly<SVGOptions>
+  ): string;
+}
+
+declare module "lean-qr/extras/node_export" {
+  import type { RGBA, Bitmap2D as FullBitmap2D } from "lean-qr";
+
+  type Bitmap2D = Pick<FullBitmap2D, "size" | "get">;
+
+  export interface PNGOptions {
+    /** the colour to use for modules which are 'on' (typically black) */
+    on?: RGBA;
+    /** the colour to use for modules which are 'off' (typically white) */
+    off?: RGBA;
+    /** the padding to apply on the left and right of the output (filled with 'off') */
+    padX?: number;
+    /** the padding to apply on the top and bottom of the output (filled with 'off') */
+    padY?: number;
+    /** a scale to apply to the resulting image (`scale` pixels = 1 module) */
+    scale?: number;
+  }
+
+  /**
+   * Generate a PNG document which can be exported to a file or served from a
+   * web server.
+   *
+   * @param code the QR code to convert.
+   * @param options optional configuration for the display.
+   * @returns a PNG document.
+   */
+  export function toPngBuffer(
+    code: Bitmap2D,
+    options?: Readonly<PNGOptions>
+  ): Uint8Array;
+
+  /**
+   * Generate a `data:image/png` URL.
+   *
+   * @param code the QR code to convert.
+   * @param options optional configuration for the display.
+   * @returns a string suitable for use as the `src` of an `img` tag.
+   */
+  export function toPngDataURL(
+    code: Bitmap2D,
+    options?: Readonly<PNGOptions>
+  ): string;
+}
+
+declare module "lean-qr/extras/react" {
+  import type {
+    Bitmap2D as FullBitmap2D,
+    GenerateOptions,
+    ImageDataOptions,
+  } from "lean-qr";
+  import type {
+    SVGOptions,
+    toSvgDataURL as toSvgDataURLFn,
+  } from "lean-qr/extras/svg";
+
+  export interface AsyncFramework<T> {
+    createElement: (
+      type: "canvas",
+      props: {
+        ref: any;
+        style: { imageRendering: "pixelated" };
+        className: string;
+      }
+    ) => T;
+    useRef<T>(initialValue: T | null): { readonly current: T | null };
+    useEffect(fn: () => void | (() => void), deps: unknown[]): void;
+  }
+
+  interface QRComponentProps {
+    content: string;
+    className?: string;
+  }
+
+  export interface AsyncQRComponentProps
+    extends ImageDataOptions,
+      GenerateOptions,
+      QRComponentProps {}
+
+  export type AsyncQRComponent<T> = (
+    props: Readonly<AsyncQRComponentProps>
+  ) => T;
+
+  /**
+   * Generate an asynchronous QR component (rendering to a `canvas`).
+   * You should call this just once, in the global scope.
+   *
+   * This is not suitable for server-side rendering (use `makeSyncComponent`
+   * instead).
+   *
+   * @param framework the framework to use (e.g. `React`).
+   * @param generate the `generate` function to use
+   * (from `lean-qr` or `lean-qr/nano`).
+   * @param defaultProps optional default properties to apply when the
+   * component is used (overridden by properties set on use).
+   * @returns a component which can be rendered elsewhere.
+   */
+  export function makeAsyncComponent<T>(
+    framework: Readonly<AsyncFramework<T>>,
+    generate: (
+      data: string,
+      options?: Readonly<GenerateOptions>
+    ) => Pick<FullBitmap2D, "toCanvas">,
+    defaultProps?: Readonly<Partial<AsyncQRComponentProps>>
+  ): AsyncQRComponent<T>;
+
+  export interface SyncFramework<T> {
+    createElement: (
+      type: "img",
+      props: {
+        src: string;
+        style: { imageRendering: "pixelated" };
+        className: string;
+      }
+    ) => T;
+    useMemo<T>(fn: () => T, deps: unknown[]): T;
+  }
+
+  export interface SyncQRComponentProps
+    extends SVGOptions,
+      GenerateOptions,
+      QRComponentProps {}
+
+  export type SyncQRComponent<T> = (props: Readonly<SyncQRComponentProps>) => T;
+
+  /**
+   * Generate a synchronous QR component (rendering to an SVG).
+   * You should call this just once, in the global scope.
+   *
+   * This is best suited for server-side rendering (prefer
+   * `makeAsyncComponent` if you only need client-side rendering).
+   *
+   * @param framework the framework to use (e.g. `React`).
+   * @param generate the `generate` function to use
+   * (from `lean-qr` or `lean-qr/nano`).
+   * @param toSvgDataURL the `toSvgDataURL` function to use
+   * (from `lean-qr/extras/svg`).
+   * @param defaultProps optional default properties to apply when the
+   * component is used (overridden by properties set on use).
+   * @returns a component which can be rendered elsewhere.
+   */
+  export function makeSyncComponent<T>(
+    framework: Readonly<SyncFramework<T>>,
+    generate: (
+      data: string,
+      options?: Readonly<GenerateOptions>
+    ) => Pick<FullBitmap2D, "size" | "get">,
+    toSvgDataURL: typeof toSvgDataURLFn,
+    defaultProps?: Readonly<Partial<SyncQRComponentProps>>
+  ): SyncQRComponent<T>;
+}
+
+declare module "lean-qr/extras/errors" {
+  /**
+   * Convert an error into a human-readable message. This is intended for use
+   * with Lean QR errors, but will return somewhat meaningful messages for
+   * other errors too.
+   *
+   * @param error the error to convert.
+   * @returns a human-readable message explaining the error.
+   */
+  export function readError(error: unknown): string;
+}

websites/default/packages/solid-signals/README.md

@@ -0,0 +1 @@
+https://app.unpkg.com/@solidjs/signals@latest/files/dist/prod.js

websites/default/packages/solid-signals/types.d.ts

@@ -1,4 +0,0 @@
-import { Accessor, Setter } from "./v0.3.2-treeshaked/types/signals";
-
-export type Signal<T> = Accessor<T> & { set: Setter<T>; reset: VoidFunction };
-export type Signals = Awaited<typeof import("./wrapper.js").default>;

websites/default/packages/solid-signals/v0.3.0-treeshaked/script.js

@@ -1,686 +0,0 @@
-// @ts-nocheck
-// src/core/error.ts
-var NotReadyError = class extends Error {
-};
-var EffectError = class extends Error {
-  constructor(effect, cause) {
-    super("");
-    this.cause = cause;
-  }
-};
-
-// src/core/constants.ts
-var STATE_CLEAN = 0;
-var STATE_CHECK = 1;
-var STATE_DIRTY = 2;
-var STATE_DISPOSED = 3;
-var EFFECT_PURE = 0;
-var EFFECT_RENDER = 1;
-var EFFECT_USER = 2;
-
-// src/core/scheduler.ts
-var clock = 0;
-function getClock() {
-  return clock;
-}
-function incrementClock() {
-  clock++;
-}
-var scheduled = false;
-function schedule() {
-  if (scheduled)
-    return;
-  scheduled = true;
-  if (!globalQueue.y)
-    queueMicrotask(flushSync);
-}
-var Queue = class {
-  i = null;
-  y = false;
-  m = [[], [], []];
-  v = [];
-  created = clock;
-  enqueue(type, node) {
-    this.m[0].push(node);
-    if (type)
-      this.m[type].push(node);
-    schedule();
-  }
-  run(type) {
-    if (this.m[type].length) {
-      if (type === EFFECT_PURE) {
-        runPureQueue(this.m[type]);
-        this.m[type] = [];
-      } else {
-        const effects = this.m[type];
-        this.m[type] = [];
-        runEffectQueue(effects);
-      }
-    }
-    let rerun = false;
-    for (let i = 0; i < this.v.length; i++) {
-      rerun = this.v[i].run(type) || rerun;
-    }
-    if (type === EFFECT_PURE)
-      return rerun || !!this.m[type].length;
-  }
-  flush() {
-    if (this.y)
-      return;
-    this.y = true;
-    try {
-      while (this.run(EFFECT_PURE)) {
-      }
-      incrementClock();
-      scheduled = false;
-      this.run(EFFECT_RENDER);
-      this.run(EFFECT_USER);
-    } finally {
-      this.y = false;
-    }
-  }
-  addChild(child) {
-    this.v.push(child);
-    child.i = this;
-  }
-  removeChild(child) {
-    const index = this.v.indexOf(child);
-    if (index >= 0)
-      this.v.splice(index, 1);
-  }
-  notify(...args) {
-    if (this.i)
-      return this.i.notify(...args);
-    return false;
-  }
-};
-var globalQueue = new Queue();
-function flushSync() {
-  while (scheduled) {
-    globalQueue.flush();
-  }
-}
-function runTop(node) {
-  const ancestors = [];
-  for (let current = node; current !== null; current = current.i) {
-    if (current.a !== STATE_CLEAN) {
-      ancestors.push(current);
-    }
-  }
-  for (let i = ancestors.length - 1; i >= 0; i--) {
-    if (ancestors[i].a !== STATE_DISPOSED)
-      ancestors[i].p();
-  }
-}
-function runPureQueue(queue) {
-  for (let i = 0; i < queue.length; i++) {
-    if (queue[i].a !== STATE_CLEAN)
-      runTop(queue[i]);
-  }
-}
-function runEffectQueue(queue) {
-  for (let i = 0; i < queue.length; i++)
-    queue[i].L();
-}
-
-// src/core/owner.ts
-var currentOwner = null;
-var defaultContext = {};
-function getOwner() {
-  return currentOwner;
-}
-function setOwner(owner) {
-  const out = currentOwner;
-  currentOwner = owner;
-  return out;
-}
-function formatId(prefix, id) {
-  const num = id.toString(36), len = num.length - 1;
-  return prefix + (len ? String.fromCharCode(64 + len) : "") + num;
-}
-var Owner = class {
-  // We flatten the owner tree into a linked list so that we don't need a pointer to .firstChild
-  // However, the children are actually added in reverse creation order
-  // See comment at the top of the file for an example of the _nextSibling traversal
-  i = null;
-  g = null;
-  n = null;
-  a = STATE_CLEAN;
-  h = null;
-  j = defaultContext;
-  f = globalQueue;
-  G = null;
-  M = 0;
-  id = null;
-  constructor(id = null, skipAppend = false) {
-    this.id = id;
-    if (currentOwner && !skipAppend)
-      currentOwner.append(this);
-  }
-  append(child) {
-    child.i = this;
-    child.n = this;
-    if (this.id) {
-      child.G = this.g ? this.g.G + 1 : 0;
-      child.id = formatId(this.id, child.G);
-    }
-    if (this.g)
-      this.g.n = child;
-    child.g = this.g;
-    this.g = child;
-    if (child.j !== this.j) {
-      child.j = { ...this.j, ...child.j };
-    }
-    if (this.f)
-      child.f = this.f;
-  }
-  dispose(self = true) {
-    if (this.a === STATE_DISPOSED)
-      return;
-    let head = self ? this.n || this.i : this, current = this.g, next = null;
-    while (current && current.i === this) {
-      current.dispose(true);
-      current.q();
-      next = current.g;
-      current.g = null;
-      current = next;
-    }
-    this.M = 0;
-    if (self)
-      this.q();
-    if (current)
-      current.n = !self ? this : this.n;
-    if (head)
-      head.g = current;
-  }
-  q() {
-    if (this.n)
-      this.n.g = null;
-    this.i = null;
-    this.n = null;
-    this.j = defaultContext;
-    this.a = STATE_DISPOSED;
-    this.emptyDisposal();
-  }
-  emptyDisposal() {
-    if (!this.h)
-      return;
-    if (Array.isArray(this.h)) {
-      for (let i = 0; i < this.h.length; i++) {
-        const callable = this.h[i];
-        callable.call(callable);
-      }
-    } else {
-      this.h.call(this.h);
-    }
-    this.h = null;
-  }
-  getNextChildId() {
-    if (this.id)
-      return formatId(this.id + "-", this.M++);
-    throw new Error("Cannot get child id from owner without an id");
-  }
-};
-function onCleanup(fn) {
-  if (!currentOwner)
-    return fn;
-  const node = currentOwner;
-  if (!node.h) {
-    node.h = fn;
-  } else if (Array.isArray(node.h)) {
-    node.h.push(fn);
-  } else {
-    node.h = [node.h, fn];
-  }
-  return fn;
-}
-
-// src/core/flags.ts
-var ERROR_OFFSET = 0;
-var ERROR_BIT = 1 << ERROR_OFFSET;
-var LOADING_OFFSET = 1;
-var LOADING_BIT = 1 << LOADING_OFFSET;
-var UNINITIALIZED_OFFSET = 2;
-var UNINITIALIZED_BIT = 1 << UNINITIALIZED_OFFSET;
-var DEFAULT_FLAGS = ERROR_BIT;
-
-// src/core/core.ts
-var currentObserver = null;
-var currentMask = DEFAULT_FLAGS;
-var newSources = null;
-var newSourcesIndex = 0;
-var newFlags = 0;
-var notStale = false;
-var UNCHANGED = Symbol(0);
-var Computation = class extends Owner {
-  b = null;
-  c = null;
-  e;
-  w;
-  r;
-  // Used in __DEV__ mode, hopefully removed in production
-  Q;
-  // Using false is an optimization as an alternative to _equals: () => false
-  // which could enable more efficient DIRTY notification
-  H = isEqual;
-  N;
-  /** Whether the computation is an error or has ancestors that are unresolved */
-  d = 0;
-  /** Which flags raised by sources are handled, vs. being passed through. */
-  I = DEFAULT_FLAGS;
-  s = -1;
-  z = false;
-  constructor(initialValue, compute2, options) {
-    super(null, compute2 === null);
-    this.r = compute2;
-    this.a = compute2 ? STATE_DIRTY : STATE_CLEAN;
-    this.d = compute2 && initialValue === void 0 ? UNINITIALIZED_BIT : 0;
-    this.e = initialValue;
-    if (options?.equals !== void 0)
-      this.H = options.equals;
-    if (options?.unobserved)
-      this.N = options?.unobserved;
-  }
-  O() {
-    if (this.r) {
-      if (this.d & ERROR_BIT && this.s <= getClock())
-        update(this);
-      else
-        this.p();
-    }
-    track(this);
-    newFlags |= this.d & ~currentMask;
-    if (this.d & ERROR_BIT) {
-      throw this.w;
-    } else {
-      return this.e;
-    }
-  }
-  /**
-   * Return the current value of this computation
-   * Automatically re-executes the surrounding computation when the value changes
-   */
-  read() {
-    return this.O();
-  }
-  /**
-   * Return the current value of this computation
-   * Automatically re-executes the surrounding computation when the value changes
-   *
-   * If the computation has any unresolved ancestors, this function waits for the value to resolve
-   * before continuing
-   */
-  wait() {
-    if (this.r && this.d & ERROR_BIT && this.s <= getClock()) {
-      update(this);
-    } else {
-      this.p();
-    }
-    track(this);
-    if ((notStale || this.d & UNINITIALIZED_BIT) && this.d & LOADING_BIT) {
-      throw new NotReadyError();
-    }
-    return this.O();
-  }
-  /** Update the computation with a new value. */
-  write(value, flags = 0, raw = false) {
-    const newValue = !raw && typeof value === "function" ? value(this.e) : value;
-    const valueChanged = newValue !== UNCHANGED && (!!(this.d & UNINITIALIZED_BIT) || this.d & LOADING_BIT & ~flags || this.H === false || !this.H(this.e, newValue));
-    if (valueChanged) {
-      this.e = newValue;
-      this.w = void 0;
-    }
-    const changedFlagsMask = this.d ^ flags, changedFlags = changedFlagsMask & flags;
-    this.d = flags;
-    this.s = getClock() + 1;
-    if (this.c) {
-      for (let i = 0; i < this.c.length; i++) {
-        if (valueChanged) {
-          this.c[i].l(STATE_DIRTY);
-        } else if (changedFlagsMask) {
-          this.c[i].P(changedFlagsMask, changedFlags);
-        }
-      }
-    }
-    return this.e;
-  }
-  /**
-   * Set the current node's state, and recursively mark all of this node's observers as STATE_CHECK
-   */
-  l(state, skipQueue) {
-    if (this.a >= state && !this.z)
-      return;
-    this.z = !!skipQueue;
-    this.a = state;
-    if (this.c) {
-      for (let i = 0; i < this.c.length; i++) {
-        this.c[i].l(STATE_CHECK, skipQueue);
-      }
-    }
-  }
-  /**
-   * Notify the computation that one of its sources has changed flags.
-   *
-   * @param mask A bitmask for which flag(s) were changed.
-   * @param newFlags The source's new flags, masked to just the changed ones.
-   */
-  P(mask, newFlags2) {
-    if (this.a >= STATE_DIRTY)
-      return;
-    if (mask & this.I) {
-      this.l(STATE_DIRTY);
-      return;
-    }
-    if (this.a >= STATE_CHECK)
-      return;
-    const prevFlags = this.d & mask;
-    const deltaFlags = prevFlags ^ newFlags2;
-    if (newFlags2 === prevFlags) ; else if (deltaFlags & prevFlags & mask) {
-      this.l(STATE_CHECK);
-    } else {
-      this.d ^= deltaFlags;
-      if (this.c) {
-        for (let i = 0; i < this.c.length; i++) {
-          this.c[i].P(mask, newFlags2);
-        }
-      }
-    }
-  }
-  J(error) {
-    this.w = error;
-    this.write(UNCHANGED, this.d & ~LOADING_BIT | ERROR_BIT | UNINITIALIZED_BIT);
-  }
-  /**
-   * This is the core part of the reactivity system, which makes sure that the values are updated
-   * before they are read. We've also adapted it to return the loading state of the computation,
-   * so that we can propagate that to the computation's observers.
-   *
-   * This function will ensure that the value and states we read from the computation are up to date
-   */
-  p() {
-    if (!this.r) {
-      return;
-    }
-    if (this.a === STATE_DISPOSED) {
-      return;
-    }
-    if (this.a === STATE_CLEAN) {
-      return;
-    }
-    let observerFlags = 0;
-    if (this.a === STATE_CHECK) {
-      for (let i = 0; i < this.b.length; i++) {
-        this.b[i].p();
-        observerFlags |= this.b[i].d;
-        if (this.a === STATE_DIRTY) {
-          break;
-        }
-      }
-    }
-    if (this.a === STATE_DIRTY) {
-      update(this);
-    } else {
-      this.write(UNCHANGED, observerFlags);
-      this.a = STATE_CLEAN;
-    }
-  }
-  /**
-   * Remove ourselves from the owner graph and the computation graph
-   */
-  q() {
-    if (this.a === STATE_DISPOSED)
-      return;
-    if (this.b)
-      removeSourceObservers(this, 0);
-    super.q();
-  }
-};
-function track(computation) {
-  if (currentObserver) {
-    if (!newSources && currentObserver.b && currentObserver.b[newSourcesIndex] === computation) {
-      newSourcesIndex++;
-    } else if (!newSources)
-      newSources = [computation];
-    else if (computation !== newSources[newSources.length - 1]) {
-      newSources.push(computation);
-    }
-  }
-}
-function update(node) {
-  const prevSources = newSources, prevSourcesIndex = newSourcesIndex, prevFlags = newFlags;
-  newSources = null;
-  newSourcesIndex = 0;
-  newFlags = 0;
-  try {
-    node.dispose(false);
-    node.emptyDisposal();
-    const result = compute(node, node.r, node);
-    node.write(result, newFlags, true);
-  } catch (error) {
-    if (error instanceof NotReadyError) {
-      node.write(UNCHANGED, newFlags | LOADING_BIT | node.d & UNINITIALIZED_BIT);
-    } else {
-      node.J(error);
-    }
-  } finally {
-    if (newSources) {
-      if (node.b)
-        removeSourceObservers(node, newSourcesIndex);
-      if (node.b && newSourcesIndex > 0) {
-        node.b.length = newSourcesIndex + newSources.length;
-        for (let i = 0; i < newSources.length; i++) {
-          node.b[newSourcesIndex + i] = newSources[i];
-        }
-      } else {
-        node.b = newSources;
-      }
-      let source;
-      for (let i = newSourcesIndex; i < node.b.length; i++) {
-        source = node.b[i];
-        if (!source.c)
-          source.c = [node];
-        else
-          source.c.push(node);
-      }
-    } else if (node.b && newSourcesIndex < node.b.length) {
-      removeSourceObservers(node, newSourcesIndex);
-      node.b.length = newSourcesIndex;
-    }
-    newSources = prevSources;
-    newSourcesIndex = prevSourcesIndex;
-    newFlags = prevFlags;
-    node.s = getClock() + 1;
-    node.a = STATE_CLEAN;
-  }
-}
-function removeSourceObservers(node, index) {
-  let source;
-  let swap;
-  for (let i = index; i < node.b.length; i++) {
-    source = node.b[i];
-    if (source.c) {
-      swap = source.c.indexOf(node);
-      source.c[swap] = source.c[source.c.length - 1];
-      source.c.pop();
-      if (!source.c.length)
-        source.N?.();
-    }
-  }
-}
-function isEqual(a, b) {
-  return a === b;
-}
-function untrack(fn) {
-  if (currentObserver === null)
-    return fn();
-  return compute(getOwner(), fn, null);
-}
-function latest(fn, fallback) {
-  const argLength = arguments.length;
-  const prevFlags = newFlags;
-  const prevNotStale = notStale;
-  notStale = false;
-  try {
-    return fn();
-  } catch (err) {
-    if (argLength > 1 && err instanceof NotReadyError)
-      return fallback;
-    throw err;
-  } finally {
-    newFlags = prevFlags;
-    notStale = prevNotStale;
-  }
-}
-function compute(owner, fn, observer) {
-  const prevOwner = setOwner(owner), prevObserver = currentObserver, prevMask = currentMask, prevNotStale = notStale;
-  currentObserver = observer;
-  currentMask = observer?.I ?? DEFAULT_FLAGS;
-  notStale = true;
-  try {
-    return fn(observer ? observer.e : void 0);
-  } finally {
-    setOwner(prevOwner);
-    currentObserver = prevObserver;
-    currentMask = prevMask;
-    notStale = prevNotStale;
-  }
-}
-
-// src/core/effect.ts
-var Effect = class extends Computation {
-  A;
-  B;
-  t;
-  K = false;
-  C;
-  o;
-  constructor(initialValue, compute2, effect, error, options) {
-    super(initialValue, compute2, options);
-    this.A = effect;
-    this.B = error;
-    this.C = initialValue;
-    this.o = options?.render ? EFFECT_RENDER : EFFECT_USER;
-    if (this.o === EFFECT_RENDER) {
-      this.r = (p) => getClock() > this.f.created && !(this.d & ERROR_BIT) ? latest(() => compute2(p)) : compute2(p);
-    }
-    this.p();
-    !options?.defer && (this.o === EFFECT_USER ? this.f.enqueue(this.o, this) : this.L());
-  }
-  write(value, flags = 0) {
-    if (this.a == STATE_DIRTY) {
-      this.d;
-      this.d = flags;
-      if (this.o === EFFECT_RENDER) {
-        this.f.notify(this, LOADING_BIT | ERROR_BIT, flags);
-      }
-    }
-    if (value === UNCHANGED)
-      return this.e;
-    this.e = value;
-    this.K = true;
-    return value;
-  }
-  l(state, skipQueue) {
-    if (this.a >= state || skipQueue)
-      return;
-    if (this.a === STATE_CLEAN)
-      this.f.enqueue(this.o, this);
-    this.a = state;
-  }
-  J(error) {
-    this.w = error;
-    this.t?.();
-    this.f.notify(this, LOADING_BIT, 0);
-    this.d = ERROR_BIT;
-    if (this.o === EFFECT_USER) {
-      try {
-        return this.B ? this.t = this.B(error) : console.error(new EffectError(this.A, error));
-      } catch (e) {
-        error = e;
-      }
-    }
-    if (!this.f.notify(this, ERROR_BIT, ERROR_BIT))
-      throw error;
-  }
-  q() {
-    if (this.a === STATE_DISPOSED)
-      return;
-    this.A = void 0;
-    this.C = void 0;
-    this.B = void 0;
-    this.t?.();
-    this.t = void 0;
-    super.q();
-  }
-  L() {
-    if (this.K && this.a !== STATE_DISPOSED) {
-      this.t?.();
-      try {
-        this.t = this.A(this.e, this.C);
-      } catch (e) {
-        if (!this.f.notify(this, ERROR_BIT, ERROR_BIT))
-          throw e;
-      } finally {
-        this.C = this.e;
-        this.K = false;
-      }
-    }
-  }
-};
-
-// src/signals.ts
-function createSignal(first, second, third) {
-  if (typeof first === "function") {
-    const memo = createMemo((p) => {
-      const node2 = new Computation(
-        first(p ? untrack(p[0]) : second),
-        null,
-        third
-      );
-      return [node2.read.bind(node2), node2.write.bind(node2)];
-    });
-    return [() => memo()[0](), (value) => memo()[1](value)];
-  }
-  const node = new Computation(first, null, second);
-  return [node.read.bind(node), node.write.bind(node)];
-}
-function createMemo(compute2, value, options) {
-  let node = new Computation(
-    value,
-    compute2,
-    options
-  );
-  let resolvedValue;
-  return () => {
-    if (node) {
-      if (node.a === STATE_DISPOSED) {
-        node = void 0;
-        return resolvedValue;
-      }
-      resolvedValue = node.wait();
-      if (!node.b?.length && node.g?.i !== node) {
-        node.dispose();
-        node = void 0;
-      }
-    }
-    return resolvedValue;
-  };
-}
-function createEffect(compute2, effect, error, value, options) {
-  void new Effect(
-    value,
-    compute2,
-    effect,
-    error,
-    options
-  );
-}
-function createRoot(init, options) {
-  const owner = new Owner(options?.id);
-  return compute(owner, !init.length ? init : () => init(() => owner.dispose()), null);
-}
-function runWithOwner(owner, run) {
-  return compute(owner, run, null);
-}
-
-export { Owner, createEffect, createMemo, createRoot, createSignal, getOwner, onCleanup, runWithOwner, untrack };

websites/default/packages/solid-signals/v0.3.0-treeshaked/types/core/boundaries.d.ts

@@ -1,17 +0,0 @@
-import { Computation } from "./core.js";
-import { type Effect } from "./effect.js";
-import { Queue } from "./scheduler.js";
-export declare class CollectionQueue extends Queue {
-    _collectionType: number;
-    _nodes: Set<Effect>;
-    _disabled: Computation<boolean>;
-    constructor(type: number);
-    notify(node: Effect, type: number, flags: number): boolean;
-}
-export declare enum BoundaryMode {
-    VISIBLE = "visible",
-    HIDDEN = "hidden"
-}
-export declare function createBoundary<T>(fn: () => T, condition: () => BoundaryMode): () => T | undefined;
-export declare function createSuspense(fn: () => any, fallback: () => any): () => any;
-export declare function createErrorBoundary<U>(fn: () => any, fallback: (error: unknown, reset: () => void) => U): () => any;

websites/default/packages/solid-signals/v0.3.0-treeshaked/types/core/core.d.ts

@@ -1,158 +0,0 @@
-/**
- * Nodes for constructing a graph of reactive values and reactive computations.
- *
- * - The graph is acyclic.
- * - The user inputs new values into the graph by calling .write() on one more computation nodes.
- * - The user retrieves computed results from the graph by calling .read() on one or more computation nodes.
- * - The library is responsible for running any necessary computations so that .read() is up to date
- *   with all prior .write() calls anywhere in the graph.
- * - We call the input nodes 'roots' and the output nodes 'leaves' of the graph here.
- * - Changes flow from roots to leaves. It would be effective but inefficient to immediately
- *   propagate all changes from a root through the graph to descendant leaves. Instead, we defer
- *   change most change propagation computation until a leaf is accessed. This allows us to
- *   coalesce computations and skip altogether recalculating unused sections of the graph.
- * - Each computation node tracks its sources and its observers (observers are other
- *   elements that have this node as a source). Source and observer links are updated automatically
- *   as observer computations re-evaluate and call get() on their sources.
- * - Each node stores a cache state (clean/check/dirty) to support the change propagation algorithm:
- *
- * In general, execution proceeds in three passes:
- *
- *  1. write() propagates changes down the graph to the leaves
- *     direct children are marked as dirty and their deeper descendants marked as check
- *     (no computations are evaluated)
- *  2. read() requests that parent nodes updateIfNecessary(), which proceeds recursively up the tree
- *     to decide whether the node is clean (parents unchanged) or dirty (parents changed)
- *  3. updateIfNecessary() evaluates the computation if the node is dirty (the computations are
- *     executed in root to leaf order)
- */
-import { type Flags } from "./flags.js";
-import { Owner } from "./owner.js";
-export interface SignalOptions<T> {
-    name?: string;
-    equals?: ((prev: T, next: T) => boolean) | false;
-    unobserved?: () => void;
-}
-interface SourceType {
-    _observers: ObserverType[] | null;
-    _unobserved?: () => void;
-    _updateIfNecessary: () => void;
-    _stateFlags: Flags;
-    _time: number;
-}
-interface ObserverType {
-    _sources: SourceType[] | null;
-    _notify: (state: number, skipQueue?: boolean) => void;
-    _handlerMask: Flags;
-    _notifyFlags: (mask: Flags, newFlags: Flags) => void;
-    _time: number;
-}
-/**
- * Returns the current observer.
- */
-export declare function getObserver(): Computation | null;
-export declare const UNCHANGED: unique symbol;
-export type UNCHANGED = typeof UNCHANGED;
-export declare class Computation<T = any> extends Owner implements SourceType, ObserverType {
-    _sources: SourceType[] | null;
-    _observers: ObserverType[] | null;
-    _value: T | undefined;
-    _error: unknown;
-    _compute: null | ((p?: T) => T);
-    _name: string | undefined;
-    _equals: false | ((a: T, b: T) => boolean);
-    _unobserved: (() => void) | undefined;
-    /** Whether the computation is an error or has ancestors that are unresolved */
-    _stateFlags: number;
-    /** Which flags raised by sources are handled, vs. being passed through. */
-    _handlerMask: number;
-    _time: number;
-    _forceNotify: boolean;
-    constructor(initialValue: T | undefined, compute: null | ((p?: T) => T), options?: SignalOptions<T>);
-    _read(): T;
-    /**
-     * Return the current value of this computation
-     * Automatically re-executes the surrounding computation when the value changes
-     */
-    read(): T;
-    /**
-     * Return the current value of this computation
-     * Automatically re-executes the surrounding computation when the value changes
-     *
-     * If the computation has any unresolved ancestors, this function waits for the value to resolve
-     * before continuing
-     */
-    wait(): T;
-    /** Update the computation with a new value. */
-    write(value: T | ((currentValue: T) => T) | UNCHANGED, flags?: number, raw?: boolean): T;
-    /**
-     * Set the current node's state, and recursively mark all of this node's observers as STATE_CHECK
-     */
-    _notify(state: number, skipQueue?: boolean): void;
-    /**
-     * Notify the computation that one of its sources has changed flags.
-     *
-     * @param mask A bitmask for which flag(s) were changed.
-     * @param newFlags The source's new flags, masked to just the changed ones.
-     */
-    _notifyFlags(mask: Flags, newFlags: Flags): void;
-    _setError(error: unknown): void;
-    /**
-     * This is the core part of the reactivity system, which makes sure that the values are updated
-     * before they are read. We've also adapted it to return the loading state of the computation,
-     * so that we can propagate that to the computation's observers.
-     *
-     * This function will ensure that the value and states we read from the computation are up to date
-     */
-    _updateIfNecessary(): void;
-    /**
-     * Remove ourselves from the owner graph and the computation graph
-     */
-    _disposeNode(): void;
-}
-/**
- * Reruns a computation's _compute function, producing a new value and keeping track of dependencies.
- *
- * It handles the updating of sources and observers, disposal of previous executions,
- * and error handling if the _compute function throws. It also sets the node as loading
- * if it reads any parents that are currently loading.
- */
-export declare function update<T>(node: Computation<T>): void;
-export declare function isEqual<T>(a: T, b: T): boolean;
-/**
- * Returns the current value stored inside the given compute function without triggering any
- * dependencies. Use `untrack` if you want to also disable owner tracking.
- */
-export declare function untrack<T>(fn: () => T): T;
-/**
- * Returns true if the given functinon contains signals that have been updated since the last time
- * the parent computation was run.
- */
-export declare function hasUpdated(fn: () => any): boolean;
-/**
- * Returns an accessor that is true if the given function contains async signals are out of date.
- */
-export declare function isPending(fn: () => any): boolean;
-export declare function isPending(fn: () => any, loadingValue: boolean): boolean;
-/**
- * Attempts to resolve value of expression synchronously returning the last resolved value for any async computation.
- */
-export declare function latest<T>(fn: () => T): T;
-export declare function latest<T, U>(fn: () => T, fallback: U): T | U;
-/**
- * Runs the given function in the given observer.
- *
- * Warning: Usually there are simpler ways of modeling a problem that avoid using this function
- */
-export declare function runWithObserver<T>(observer: Computation, run: () => T): T | undefined;
-/**
- * A convenient wrapper that calls `compute` with the `owner` and `observer` and is guaranteed
- * to reset the global context after the computation is finished even if an error is thrown.
- */
-export declare function compute<T>(owner: Owner | null, fn: (val: T) => T, observer: Computation<T>): T;
-export declare function compute<T>(owner: Owner | null, fn: (val: undefined) => T, observer: null): T;
-export declare function flatten(children: any, options?: {
-    skipNonRendered?: boolean;
-    doNotUnwrap?: boolean;
-}): any;
-export {};

websites/default/packages/solid-signals/v0.3.0-treeshaked/types/core/effect.d.ts

@@ -1,34 +0,0 @@
-import { EFFECT_RENDER, EFFECT_USER } from "./constants.js";
-import { Computation, type SignalOptions } from "./core.js";
-/**
- * Effects are the leaf nodes of our reactive graph. When their sources change, they are
- * automatically added to the queue of effects to re-execute, which will cause them to fetch their
- * sources and recompute
- */
-export declare class Effect<T = any> extends Computation<T> {
-    _effect: (val: T, prev: T | undefined) => void | (() => void);
-    _onerror: ((err: unknown) => void | (() => void)) | undefined;
-    _cleanup: (() => void) | undefined;
-    _modified: boolean;
-    _prevValue: T | undefined;
-    _type: typeof EFFECT_RENDER | typeof EFFECT_USER;
-    constructor(initialValue: T, compute: (val?: T) => T, effect: (val: T, prev: T | undefined) => void | (() => void), error?: (err: unknown) => void | (() => void), options?: SignalOptions<T> & {
-        render?: boolean;
-        defer?: boolean;
-    });
-    write(value: T, flags?: number): T;
-    _notify(state: number, skipQueue?: boolean): void;
-    _setError(error: unknown): void;
-    _disposeNode(): void;
-    _runEffect(): void;
-}
-export declare class EagerComputation<T = any> extends Computation<T> {
-    constructor(initialValue: T, compute: () => T, options?: SignalOptions<T> & {
-        defer?: boolean;
-    });
-    _notify(state: number, skipQueue?: boolean): void;
-}
-export declare class ProjectionComputation extends Computation {
-    constructor(compute: () => void);
-    _notify(state: number, skipQueue?: boolean): void;
-}

websites/default/packages/solid-signals/v0.3.0-treeshaked/types/core/error.d.ts

@@ -1,15 +0,0 @@
-import type { Owner } from "./owner.js";
-export declare class NotReadyError extends Error {
-}
-export declare class NoOwnerError extends Error {
-    constructor();
-}
-export declare class ContextNotFoundError extends Error {
-    constructor();
-}
-export declare class EffectError extends Error {
-    constructor(effect: Function, cause: unknown);
-}
-export interface ErrorHandler {
-    (error: unknown, node: Owner): void;
-}

websites/default/packages/solid-signals/v0.3.0-treeshaked/types/core/index.d.ts

@@ -1,9 +0,0 @@
-export { ContextNotFoundError, NoOwnerError, NotReadyError, type ErrorHandler } from "./error.js";
-export { Owner, createContext, getContext, setContext, hasContext, getOwner, onCleanup, type Context, type ContextRecord, type Disposable } from "./owner.js";
-export { Computation, getObserver, isEqual, untrack, hasUpdated, isPending, latest, flatten, UNCHANGED, compute, runWithObserver, type SignalOptions } from "./core.js";
-export { Effect, EagerComputation } from "./effect.js";
-export { flushSync, type IQueue, Queue } from "./scheduler.js";
-export { createSuspense, createErrorBoundary, createBoundary } from "./boundaries.js";
-export { SUPPORTS_PROXY } from "./constants.js";
-export { tryCatch, type TryCatchResult } from "./utils.js";
-export * from "./flags.js";

websites/default/packages/solid-signals/v0.3.0-treeshaked/types/core/owner.d.ts

@@ -1,96 +0,0 @@
-/**
- * Owner tracking is used to enable nested tracking scopes with automatic cleanup.
- * We also use owners to also keep track of which error handling context we are in.
- *
- * If you write the following
- *
- *   const a = createOwner(() => {
- *     const b = createOwner(() => {});
- *
- *     const c = createOwner(() => {
- *       const d = createOwner(() => {});
- *     });
- *
- *     const e = createOwner(() => {});
- *   });
- *
- * The owner tree will look like this:
- *
- *    a
- *   /|\
- *  b-c-e
- *    |
- *    d
- *
- * Following the _nextSibling pointers of each owner will first give you its children, and then its siblings (in reverse).
- * a -> e -> c -> d -> b
- *
- * Note that the owner tree is largely orthogonal to the reactivity tree, and is much closer to the component tree.
- */
-import { type IQueue } from "./scheduler.js";
-export type ContextRecord = Record<string | symbol, unknown>;
-export interface Disposable {
-    (): void;
-}
-/**
- * Returns the currently executing parent owner.
- */
-export declare function getOwner(): Owner | null;
-export declare function setOwner(owner: Owner | null): Owner | null;
-export declare class Owner {
-    _parent: Owner | null;
-    _nextSibling: Owner | null;
-    _prevSibling: Owner | null;
-    _state: number;
-    _disposal: Disposable | Disposable[] | null;
-    _context: ContextRecord;
-    _queue: IQueue;
-    _siblingCount: number | null;
-    _childCount: number;
-    id: string | null;
-    constructor(id?: string | null, skipAppend?: boolean);
-    append(child: Owner): void;
-    dispose(this: Owner, self?: boolean): void;
-    _disposeNode(): void;
-    emptyDisposal(): void;
-    getNextChildId(): string;
-}
-export interface Context<T> {
-    readonly id: symbol;
-    readonly defaultValue: T | undefined;
-}
-/**
- * Context provides a form of dependency injection. It is used to save from needing to pass
- * data as props through intermediate components. This function creates a new context object
- * that can be used with `getContext` and `setContext`.
- *
- * A default value can be provided here which will be used when a specific value is not provided
- * via a `setContext` call.
- */
-export declare function createContext<T>(defaultValue?: T, description?: string): Context<T>;
-/**
- * Attempts to get a context value for the given key.
- *
- * @throws `NoOwnerError` if there's no owner at the time of call.
- * @throws `ContextNotFoundError` if a context value has not been set yet.
- */
-export declare function getContext<T>(context: Context<T>, owner?: Owner | null): T;
-/**
- * Attempts to set a context value on the parent scope with the given key.
- *
- * @throws `NoOwnerError` if there's no owner at the time of call.
- */
-export declare function setContext<T>(context: Context<T>, value?: T, owner?: Owner | null): void;
-/**
- * Whether the given context is currently defined.
- */
-export declare function hasContext(context: Context<any>, owner?: Owner | null): boolean;
-/**
- * Runs an effect once before the reactive scope is disposed
- * @param fn an effect that should run only once on cleanup
- *
- * @returns the same {@link fn} function that was passed in
- *
- * @description https://docs.solidjs.com/reference/lifecycle/on-cleanup
- */
-export declare function onCleanup(fn: Disposable): Disposable;

websites/default/packages/solid-signals/v0.3.0-treeshaked/types/core/scheduler.d.ts

@@ -1,33 +0,0 @@
-import type { Computation } from "./core.js";
-import type { Effect } from "./effect.js";
-export declare function getClock(): number;
-export declare function incrementClock(): void;
-export interface IQueue {
-    enqueue<T extends Computation | Effect>(type: number, node: T): void;
-    run(type: number): boolean | void;
-    flush(): void;
-    addChild(child: IQueue): void;
-    removeChild(child: IQueue): void;
-    created: number;
-    notify(...args: any[]): boolean;
-    _parent: IQueue | null;
-}
-export declare class Queue implements IQueue {
-    _parent: IQueue | null;
-    _running: boolean;
-    _queues: [Computation[], Effect[], Effect[]];
-    _children: IQueue[];
-    created: number;
-    enqueue<T extends Computation | Effect>(type: number, node: T): void;
-    run(type: number): boolean | undefined;
-    flush(): void;
-    addChild(child: IQueue): void;
-    removeChild(child: IQueue): void;
-    notify(...args: any[]): boolean;
-}
-export declare const globalQueue: Queue;
-/**
- * By default, changes are batched on the microtask queue which is an async process. You can flush
- * the queue synchronously to get the latest updates by calling `flushSync()`.
- */
-export declare function flushSync(): void;

websites/default/packages/solid-signals/v0.3.0-treeshaked/types/core/utils.d.ts

@@ -1,4 +0,0 @@
-export declare function isUndefined(value: any): value is undefined;
-export type TryCatchResult<T, E> = [undefined, T] | [E];
-export declare function tryCatch<T, E = Error>(fn: () => Promise<T>): Promise<TryCatchResult<T, E>>;
-export declare function tryCatch<T, E = Error>(fn: () => T): TryCatchResult<T, E>;

websites/default/packages/solid-signals/v0.3.0-treeshaked/types/index.d.ts

@@ -1,3 +0,0 @@
-export { Owner, getOwner, onCleanup, untrack } from "./core/index.js";
-export type { ErrorHandler, SignalOptions, Context, ContextRecord, Disposable, IQueue } from "./core/index.js";
-export * from "./signals.js";

websites/default/packages/solid-signals/v0.3.0-treeshaked/types/signals.d.ts

@@ -1,102 +0,0 @@
-import type { SignalOptions } from "./core/index.js";
-import { Owner } from "./core/index.js";
-export type Accessor<T> = () => T;
-export type Setter<in out T> = {
-    <U extends T>(...args: undefined extends T ? [] : [value: Exclude<U, Function> | ((prev: T) => U)]): undefined extends T ? undefined : U;
-    <U extends T>(value: (prev: T) => U): U;
-    <U extends T>(value: Exclude<U, Function>): U;
-    <U extends T>(value: Exclude<U, Function> | ((prev: T) => U)): U;
-};
-export type Signal<T> = [get: Accessor<T>, set: Setter<T>];
-export type ComputeFunction<Prev, Next extends Prev = Prev> = (v: Prev) => Next;
-export type EffectFunction<Prev, Next extends Prev = Prev> = (v: Next, p?: Prev) => (() => void) | void;
-export interface EffectOptions {
-    name?: string;
-    defer?: boolean;
-}
-export interface MemoOptions<T> {
-    name?: string;
-    equals?: false | ((prev: T, next: T) => boolean);
-}
-export type NoInfer<T extends any> = [T][T extends any ? 0 : never];
-/**
- * Creates a simple reactive state with a getter and setter
- * ```typescript
- * const [state: Accessor<T>, setState: Setter<T>] = createSignal<T>(
- *  value: T,
- *  options?: { name?: string, equals?: false | ((prev: T, next: T) => boolean) }
- * )
- * ```
- * @param value initial value of the state; if empty, the state's type will automatically extended with undefined; otherwise you need to extend the type manually if you want setting to undefined not be an error
- * @param options optional object with a name for debugging purposes and equals, a comparator function for the previous and next value to allow fine-grained control over the reactivity
- *
- * @returns ```typescript
- * [state: Accessor<T>, setState: Setter<T>]
- * ```
- * * the Accessor is a function that returns the current value and registers each call to the reactive root
- * * the Setter is a function that allows directly setting or mutating the value:
- * ```typescript
- * const [count, setCount] = createSignal(0);
- * setCount(count => count + 1);
- * ```
- *
- * @description https://docs.solidjs.com/reference/basic-reactivity/create-signal
- */
-export declare function createSignal<T>(): Signal<T | undefined>;
-export declare function createSignal<T>(value: Exclude<T, Function>, options?: SignalOptions<T>): Signal<T>;
-export declare function createSignal<T>(fn: ComputeFunction<T>, initialValue?: T, options?: SignalOptions<T>): Signal<T>;
-/**
- * Creates a readonly derived reactive memoized signal
- * ```typescript
- * export function createMemo<T>(
- *   compute: (v: T) => T,
- *   value?: T,
- *   options?: { name?: string, equals?: false | ((prev: T, next: T) => boolean) }
- * ): () => T;
- * ```
- * @param compute a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
- * @param value an optional initial value for the computation; if set, fn will never receive undefined as first argument
- * @param options allows to set a name in dev mode for debugging purposes and use a custom comparison function in equals
- *
- * @description https://docs.solidjs.com/reference/basic-reactivity/create-memo
- */
-export declare function createMemo<Next extends Prev, Prev = Next>(compute: ComputeFunction<undefined | NoInfer<Prev>, Next>): Accessor<Next>;
-export declare function createMemo<Next extends Prev, Init = Next, Prev = Next>(compute: ComputeFunction<Init | Prev, Next>, value: Init, options?: MemoOptions<Next>): Accessor<Next>;
-/**
- * Creates a reactive effect that runs after the render phase
- * ```typescript
- * export function createEffect<T>(
- *   compute: (prev: T) => T,
- *   effect: (v: T, prev: T) => (() => void) | void,
- *   value?: T,
- *   options?: { name?: string }
- * ): void;
- * ```
- * @param compute a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
- * @param effect a function that receives the new value and is used to perform side effects, return a cleanup function to run on disposal
- * @param error an optional function that receives an error if thrown during the computation
- * @param value an optional initial value for the computation; if set, fn will never receive undefined as first argument
- * @param options allows to set a name in dev mode for debugging purposes
- *
- * @description https://docs.solidjs.com/reference/basic-reactivity/create-effect
- */
-export declare function createEffect<Next>(compute: ComputeFunction<undefined | NoInfer<Next>, Next>, effect: EffectFunction<NoInfer<Next>, Next>, error?: (err: unknown) => void): void;
-export declare function createEffect<Next, Init = Next>(compute: ComputeFunction<Init | Next, Next>, effect: EffectFunction<Next, Next>, error: ((err: unknown) => void) | undefined, value: Init, options?: EffectOptions): void;
-/**
- * Creates a new non-tracked reactive context with manual disposal
- *
- * @param fn a function in which the reactive state is scoped
- * @returns the output of `fn`.
- *
- * @description https://docs.solidjs.com/reference/reactive-utilities/create-root
- */
-export declare function createRoot<T>(init: ((dispose: () => void) => T) | (() => T), options?: {
-    id: string;
-}): T;
-/**
- * Runs the given function in the given owner to move ownership of nested primitives and cleanups.
- * This method untracks the current scope.
- *
- * Warning: Usually there are simpler ways of modeling a problem that avoid using this function
- */
-export declare function runWithOwner<T>(owner: Owner | null, run: () => T): T;

websites/default/packages/solid-signals/v0.3.2-treeshaked/script.js

@@ -1,678 +0,0 @@
-// @ts-nocheck
-// src/core/error.ts
-var NotReadyError = class extends Error {};
-var EffectError = class extends Error {
-  constructor(effect, cause) {
-    super("");
-    this.cause = cause;
-  }
-};
-
-// src/core/constants.ts
-var STATE_CLEAN = 0;
-var STATE_CHECK = 1;
-var STATE_DIRTY = 2;
-var STATE_DISPOSED = 3;
-var EFFECT_PURE = 0;
-var EFFECT_RENDER = 1;
-var EFFECT_USER = 2;
-
-// src/core/scheduler.ts
-var clock = 0;
-function getClock() {
-  return clock;
-}
-function incrementClock() {
-  clock++;
-}
-var scheduled = false;
-function schedule() {
-  if (scheduled) return;
-  scheduled = true;
-  if (!globalQueue.u) queueMicrotask(flushSync);
-}
-var pureQueue = [];
-var Queue = class {
-  i = null;
-  u = false;
-  v = [[], []];
-  t = [];
-  created = clock;
-  enqueue(type, fn) {
-    pureQueue.push(fn);
-    if (type) this.v[type - 1].push(fn);
-    schedule();
-  }
-  run(type) {
-    if (type === EFFECT_PURE) {
-      pureQueue.length && runQueue(pureQueue, type);
-      pureQueue = [];
-      return;
-    } else if (this.v[type - 1].length) {
-      const effects = this.v[type - 1];
-      this.v[type - 1] = [];
-      runQueue(effects, type);
-    }
-    for (let i = 0; i < this.t.length; i++) {
-      this.t[i].run(type);
-    }
-  }
-  flush() {
-    if (this.u) return;
-    this.u = true;
-    try {
-      this.run(EFFECT_PURE);
-      incrementClock();
-      scheduled = false;
-      this.run(EFFECT_RENDER);
-      this.run(EFFECT_USER);
-    } finally {
-      this.u = false;
-    }
-  }
-  addChild(child) {
-    this.t.push(child);
-    child.i = this;
-  }
-  removeChild(child) {
-    const index = this.t.indexOf(child);
-    if (index >= 0) this.t.splice(index, 1);
-  }
-  notify(...args) {
-    if (this.i) return this.i.notify(...args);
-    return false;
-  }
-};
-var globalQueue = new Queue();
-function flushSync() {
-  while (scheduled) {
-    globalQueue.flush();
-  }
-}
-function runQueue(queue, type) {
-  for (let i = 0; i < queue.length; i++) queue[i](type);
-}
-
-// src/core/owner.ts
-var currentOwner = null;
-var defaultContext = {};
-function getOwner() {
-  return currentOwner;
-}
-function setOwner(owner) {
-  const out = currentOwner;
-  currentOwner = owner;
-  return out;
-}
-var Owner = class {
-  // We flatten the owner tree into a linked list so that we don't need a pointer to .firstChild
-  // However, the children are actually added in reverse creation order
-  // See comment at the top of the file for an example of the _nextSibling traversal
-  i = null;
-  h = null;
-  l = null;
-  a = STATE_CLEAN;
-  f = null;
-  j = defaultContext;
-  g = globalQueue;
-  F = 0;
-  id = null;
-  constructor(id = null, skipAppend = false) {
-    this.id = id;
-    if (currentOwner) {
-      !skipAppend && currentOwner.append(this);
-    }
-  }
-  append(child) {
-    child.i = this;
-    child.l = this;
-    if (this.h) this.h.l = child;
-    child.h = this.h;
-    this.h = child;
-    if (this.id != null && child.id == null) child.id = this.getNextChildId();
-    if (child.j !== this.j) {
-      child.j = { ...this.j, ...child.j };
-    }
-    if (this.g) child.g = this.g;
-  }
-  dispose(self = true) {
-    if (this.a === STATE_DISPOSED) return;
-    let head = self ? this.l || this.i : this,
-      current = this.h,
-      next = null;
-    while (current && current.i === this) {
-      current.dispose(true);
-      current.o();
-      next = current.h;
-      current.h = null;
-      current = next;
-    }
-    this.F = 0;
-    if (self) this.o();
-    if (current) current.l = !self ? this : this.l;
-    if (head) head.h = current;
-  }
-  o() {
-    if (this.l) this.l.h = null;
-    this.i = null;
-    this.l = null;
-    this.j = defaultContext;
-    this.a = STATE_DISPOSED;
-    this.emptyDisposal();
-  }
-  emptyDisposal() {
-    if (!this.f) return;
-    if (Array.isArray(this.f)) {
-      for (let i = 0; i < this.f.length; i++) {
-        const callable = this.f[i];
-        callable.call(callable);
-      }
-    } else {
-      this.f.call(this.f);
-    }
-    this.f = null;
-  }
-  getNextChildId() {
-    if (this.id != null) return formatId(this.id, this.F++);
-    throw new Error("Cannot get child id from owner without an id");
-  }
-};
-function onCleanup(fn) {
-  if (!currentOwner) return fn;
-  const node = currentOwner;
-  if (!node.f) {
-    node.f = fn;
-  } else if (Array.isArray(node.f)) {
-    node.f.push(fn);
-  } else {
-    node.f = [node.f, fn];
-  }
-  return fn;
-}
-function formatId(prefix, id) {
-  const num = id.toString(36),
-    len = num.length - 1;
-  return prefix + (len ? String.fromCharCode(64 + len) : "") + num;
-}
-
-// src/core/flags.ts
-var ERROR_OFFSET = 0;
-var ERROR_BIT = 1 << ERROR_OFFSET;
-var LOADING_OFFSET = 1;
-var LOADING_BIT = 1 << LOADING_OFFSET;
-var UNINITIALIZED_OFFSET = 2;
-var UNINITIALIZED_BIT = 1 << UNINITIALIZED_OFFSET;
-var DEFAULT_FLAGS = ERROR_BIT;
-
-// src/core/core.ts
-var currentObserver = null;
-var currentMask = DEFAULT_FLAGS;
-var newSources = null;
-var newSourcesIndex = 0;
-var newFlags = 0;
-var notStale = false;
-var UNCHANGED = Symbol(0);
-var Computation = class extends Owner {
-  b = null;
-  c = null;
-  e;
-  w;
-  p;
-  // Used in __DEV__ mode, hopefully removed in production
-  J;
-  // Using false is an optimization as an alternative to _equals: () => false
-  // which could enable more efficient DIRTY notification
-  A = isEqual;
-  G;
-  /** Whether the computation is an error or has ancestors that are unresolved */
-  d = 0;
-  /** Which flags raised by sources are handled, vs. being passed through. */
-  B = DEFAULT_FLAGS;
-  q = -1;
-  n = false;
-  constructor(initialValue, compute2, options) {
-    super(options?.id, compute2 === null);
-    this.p = compute2;
-    this.a = compute2 ? STATE_DIRTY : STATE_CLEAN;
-    this.d = compute2 && initialValue === void 0 ? UNINITIALIZED_BIT : 0;
-    this.e = initialValue;
-    if (options?.equals !== void 0) this.A = options.equals;
-    if (options?.unobserved) this.G = options?.unobserved;
-  }
-  H() {
-    if (this.p) {
-      if (this.d & ERROR_BIT && this.q <= getClock()) update(this);
-      else this.r();
-    }
-    track(this);
-    newFlags |= this.d & ~currentMask;
-    if (this.d & ERROR_BIT) {
-      throw this.w;
-    } else {
-      return this.e;
-    }
-  }
-  /**
-   * Return the current value of this computation
-   * Automatically re-executes the surrounding computation when the value changes
-   */
-  read() {
-    return this.H();
-  }
-  /**
-   * Return the current value of this computation
-   * Automatically re-executes the surrounding computation when the value changes
-   *
-   * If the computation has any unresolved ancestors, this function waits for the value to resolve
-   * before continuing
-   */
-  wait() {
-    if (this.p && this.d & ERROR_BIT && this.q <= getClock()) {
-      update(this);
-    } else {
-      this.r();
-    }
-    track(this);
-    if ((notStale || this.d & UNINITIALIZED_BIT) && this.d & LOADING_BIT) {
-      throw new NotReadyError();
-    }
-    return this.H();
-  }
-  /** Update the computation with a new value. */
-  write(value, flags = 0, raw = false) {
-    const newValue =
-      !raw && typeof value === "function" ? value(this.e) : value;
-    const valueChanged =
-      newValue !== UNCHANGED &&
-      (!!(this.d & UNINITIALIZED_BIT) ||
-        this.d & LOADING_BIT & ~flags ||
-        this.A === false ||
-        !this.A(this.e, newValue));
-    if (valueChanged) {
-      this.e = newValue;
-      this.w = void 0;
-    }
-    const changedFlagsMask = this.d ^ flags,
-      changedFlags = changedFlagsMask & flags;
-    this.d = flags;
-    this.q = getClock() + 1;
-    if (this.c) {
-      for (let i = 0; i < this.c.length; i++) {
-        if (valueChanged) {
-          this.c[i].k(STATE_DIRTY);
-        } else if (changedFlagsMask) {
-          this.c[i].I(changedFlagsMask, changedFlags);
-        }
-      }
-    }
-    return this.e;
-  }
-  /**
-   * Set the current node's state, and recursively mark all of this node's observers as STATE_CHECK
-   */
-  k(state, skipQueue) {
-    if (this.a >= state && !this.n) return;
-    this.n = !!skipQueue;
-    this.a = state;
-    if (this.c) {
-      for (let i = 0; i < this.c.length; i++) {
-        this.c[i].k(STATE_CHECK, skipQueue);
-      }
-    }
-  }
-  /**
-   * Notify the computation that one of its sources has changed flags.
-   *
-   * @param mask A bitmask for which flag(s) were changed.
-   * @param newFlags The source's new flags, masked to just the changed ones.
-   */
-  I(mask, newFlags2) {
-    if (this.a >= STATE_DIRTY) return;
-    if (mask & this.B) {
-      this.k(STATE_DIRTY);
-      return;
-    }
-    if (this.a >= STATE_CHECK) return;
-    const prevFlags = this.d & mask;
-    const deltaFlags = prevFlags ^ newFlags2;
-    if (newFlags2 === prevFlags);
-    else if (deltaFlags & prevFlags & mask) {
-      this.k(STATE_CHECK);
-    } else {
-      this.d ^= deltaFlags;
-      if (this.c) {
-        for (let i = 0; i < this.c.length; i++) {
-          this.c[i].I(mask, newFlags2);
-        }
-      }
-    }
-  }
-  C(error) {
-    this.w = error;
-    this.write(
-      UNCHANGED,
-      (this.d & ~LOADING_BIT) | ERROR_BIT | UNINITIALIZED_BIT,
-    );
-  }
-  /**
-   * This is the core part of the reactivity system, which makes sure that the values are updated
-   * before they are read. We've also adapted it to return the loading state of the computation,
-   * so that we can propagate that to the computation's observers.
-   *
-   * This function will ensure that the value and states we read from the computation are up to date
-   */
-  r() {
-    if (!this.p) {
-      return;
-    }
-    if (this.a === STATE_DISPOSED) {
-      return;
-    }
-    if (this.a === STATE_CLEAN) {
-      return;
-    }
-    let observerFlags = 0;
-    if (this.a === STATE_CHECK) {
-      for (let i = 0; i < this.b.length; i++) {
-        this.b[i].r();
-        observerFlags |= this.b[i].d;
-        if (this.a === STATE_DIRTY) {
-          break;
-        }
-      }
-    }
-    if (this.a === STATE_DIRTY) {
-      update(this);
-    } else {
-      this.write(UNCHANGED, observerFlags);
-      this.a = STATE_CLEAN;
-    }
-  }
-  /**
-   * Remove ourselves from the owner graph and the computation graph
-   */
-  o() {
-    if (this.a === STATE_DISPOSED) return;
-    if (this.b) removeSourceObservers(this, 0);
-    super.o();
-  }
-};
-function track(computation) {
-  if (currentObserver) {
-    if (
-      !newSources &&
-      currentObserver.b &&
-      currentObserver.b[newSourcesIndex] === computation
-    ) {
-      newSourcesIndex++;
-    } else if (!newSources) newSources = [computation];
-    else if (computation !== newSources[newSources.length - 1]) {
-      newSources.push(computation);
-    }
-  }
-}
-function update(node) {
-  const prevSources = newSources,
-    prevSourcesIndex = newSourcesIndex,
-    prevFlags = newFlags;
-  newSources = null;
-  newSourcesIndex = 0;
-  newFlags = 0;
-  try {
-    node.dispose(false);
-    node.emptyDisposal();
-    const result = compute(node, node.p, node);
-    node.write(result, newFlags, true);
-  } catch (error) {
-    if (error instanceof NotReadyError) {
-      node.write(
-        UNCHANGED,
-        newFlags | LOADING_BIT | (node.d & UNINITIALIZED_BIT),
-      );
-    } else {
-      node.C(error);
-    }
-  } finally {
-    if (newSources) {
-      if (node.b) removeSourceObservers(node, newSourcesIndex);
-      if (node.b && newSourcesIndex > 0) {
-        node.b.length = newSourcesIndex + newSources.length;
-        for (let i = 0; i < newSources.length; i++) {
-          node.b[newSourcesIndex + i] = newSources[i];
-        }
-      } else {
-        node.b = newSources;
-      }
-      let source;
-      for (let i = newSourcesIndex; i < node.b.length; i++) {
-        source = node.b[i];
-        if (!source.c) source.c = [node];
-        else source.c.push(node);
-      }
-    } else if (node.b && newSourcesIndex < node.b.length) {
-      removeSourceObservers(node, newSourcesIndex);
-      node.b.length = newSourcesIndex;
-    }
-    newSources = prevSources;
-    newSourcesIndex = prevSourcesIndex;
-    newFlags = prevFlags;
-    node.q = getClock() + 1;
-    node.a = STATE_CLEAN;
-  }
-}
-function removeSourceObservers(node, index) {
-  let source;
-  let swap;
-  for (let i = index; i < node.b.length; i++) {
-    source = node.b[i];
-    if (source.c) {
-      swap = source.c.indexOf(node);
-      source.c[swap] = source.c[source.c.length - 1];
-      source.c.pop();
-      if (!source.c.length) source.G?.();
-    }
-  }
-}
-function isEqual(a, b) {
-  return a === b;
-}
-function untrack(fn) {
-  if (currentObserver === null) return fn();
-  return compute(getOwner(), fn, null);
-}
-function latest(fn, fallback) {
-  const argLength = arguments.length;
-  const prevFlags = newFlags;
-  const prevNotStale = notStale;
-  notStale = false;
-  try {
-    return fn();
-  } catch (err) {
-    if (argLength > 1 && err instanceof NotReadyError) return fallback;
-    throw err;
-  } finally {
-    newFlags = prevFlags;
-    notStale = prevNotStale;
-  }
-}
-function compute(owner, fn, observer) {
-  const prevOwner = setOwner(owner),
-    prevObserver = currentObserver,
-    prevMask = currentMask,
-    prevNotStale = notStale;
-  currentObserver = observer;
-  currentMask = observer?.B ?? DEFAULT_FLAGS;
-  notStale = true;
-  try {
-    return fn(observer ? observer.e : void 0);
-  } finally {
-    setOwner(prevOwner);
-    currentObserver = prevObserver;
-    currentMask = prevMask;
-    notStale = prevNotStale;
-  }
-}
-
-// src/core/effect.ts
-var Effect = class extends Computation {
-  x;
-  y;
-  s;
-  D = false;
-  z;
-  m;
-  constructor(initialValue, compute2, effect, error, options) {
-    super(initialValue, compute2, options);
-    this.x = effect;
-    this.y = error;
-    this.z = initialValue;
-    this.m = options?.render ? EFFECT_RENDER : EFFECT_USER;
-    if (this.m === EFFECT_RENDER) {
-      this.p = (p) =>
-        getClock() > this.g.created && !(this.d & ERROR_BIT)
-          ? latest(() => compute2(p))
-          : compute2(p);
-    }
-    this.r();
-    !options?.defer &&
-      (this.m === EFFECT_USER
-        ? this.g.enqueue(this.m, this.E.bind(this))
-        : this.E(this.m));
-  }
-  write(value, flags = 0) {
-    if (this.a == STATE_DIRTY) {
-      this.d;
-      this.d = flags;
-      if (this.m === EFFECT_RENDER) {
-        this.g.notify(this, LOADING_BIT | ERROR_BIT, flags);
-      }
-    }
-    if (value === UNCHANGED) return this.e;
-    this.e = value;
-    this.D = true;
-    return value;
-  }
-  k(state, skipQueue) {
-    if (this.a >= state || skipQueue) return;
-    if (this.a === STATE_CLEAN) this.g.enqueue(this.m, this.E.bind(this));
-    this.a = state;
-  }
-  C(error) {
-    this.w = error;
-    this.s?.();
-    this.g.notify(this, LOADING_BIT, 0);
-    this.d = ERROR_BIT;
-    if (this.m === EFFECT_USER) {
-      try {
-        return this.y
-          ? (this.s = this.y(error))
-          : console.error(new EffectError(this.x, error));
-      } catch (e) {
-        error = e;
-      }
-    }
-    if (!this.g.notify(this, ERROR_BIT, ERROR_BIT)) throw error;
-  }
-  o() {
-    if (this.a === STATE_DISPOSED) return;
-    this.x = void 0;
-    this.z = void 0;
-    this.y = void 0;
-    this.s?.();
-    this.s = void 0;
-    super.o();
-  }
-  E(type) {
-    if (type) {
-      if (this.D && this.a !== STATE_DISPOSED) {
-        this.s?.();
-        try {
-          this.s = this.x(this.e, this.z);
-        } catch (e) {
-          if (!this.g.notify(this, ERROR_BIT, ERROR_BIT)) throw e;
-        } finally {
-          this.z = this.e;
-          this.D = false;
-        }
-      }
-    } else this.a !== STATE_CLEAN && runTop(this);
-  }
-};
-function runTop(node) {
-  const ancestors = [];
-  for (let current = node; current !== null; current = current.i) {
-    if (current.a !== STATE_CLEAN) {
-      ancestors.push(current);
-    }
-  }
-  for (let i = ancestors.length - 1; i >= 0; i--) {
-    if (ancestors[i].a !== STATE_DISPOSED) ancestors[i].r();
-  }
-}
-
-// src/signals.ts
-function createSignal(first, second, third) {
-  if (typeof first === "function") {
-    const memo = createMemo((p) => {
-      const node2 = new Computation(
-        first(p ? untrack(p[0]) : second),
-        null,
-        third,
-      );
-      return [node2.read.bind(node2), node2.write.bind(node2)];
-    });
-    return [() => memo()[0](), (value) => memo()[1](value)];
-  }
-  const o = getOwner();
-  const needsId = o?.id != null;
-  const node = new Computation(
-    first,
-    null,
-    needsId ? { id: o.getNextChildId(), ...second } : second,
-  );
-  return [node.read.bind(node), node.write.bind(node)];
-}
-function createMemo(compute2, value, options) {
-  let node = new Computation(value, compute2, options);
-  let resolvedValue;
-  return () => {
-    if (node) {
-      if (node.a === STATE_DISPOSED) {
-        node = void 0;
-        return resolvedValue;
-      }
-      resolvedValue = node.wait();
-      if (!node.b?.length && node.h?.i !== node) {
-        node.dispose();
-        node = void 0;
-      }
-    }
-    return resolvedValue;
-  };
-}
-function createEffect(compute2, effect, error, value, options) {
-  void new Effect(value, compute2, effect, error, options);
-}
-function createRoot(init, options) {
-  const owner = new Owner(options?.id);
-  return compute(
-    owner,
-    !init.length ? init : () => init(() => owner.dispose()),
-    null,
-  );
-}
-function runWithOwner(owner, run) {
-  return compute(owner, run, null);
-}
-
-export {
-  Owner,
-  createEffect,
-  createMemo,
-  createRoot,
-  createSignal,
-  getOwner,
-  onCleanup,
-  runWithOwner,
-  untrack,
-};

websites/default/packages/solid-signals/v0.3.2-treeshaked/types/core/constants.d.ts

@@ -1,14 +0,0 @@
-/**
- * See https://dev.to/modderme123/super-charging-fine-grained-reactive-performance-47ph
- * State clean corresponds to a node where all the sources are fully up to date
- * State check corresponds to a node where some sources (including grandparents) may have changed
- * State dirty corresponds to a node where the direct parents of a node has changed
- */
-export declare const STATE_CLEAN = 0;
-export declare const STATE_CHECK = 1;
-export declare const STATE_DIRTY = 2;
-export declare const STATE_DISPOSED = 3;
-export declare const EFFECT_PURE = 0;
-export declare const EFFECT_RENDER = 1;
-export declare const EFFECT_USER = 2;
-export declare const SUPPORTS_PROXY: boolean;

websites/default/packages/solid-signals/v0.3.2-treeshaked/types/core/flags.d.ts

@@ -1,11 +0,0 @@
-export type Flags = number;
-export declare const ERROR_OFFSET = 0;
-export declare const ERROR_BIT: number;
-export declare const ERROR: unique symbol;
-export declare const LOADING_OFFSET = 1;
-export declare const LOADING_BIT: number;
-export declare const LOADING: unique symbol;
-export declare const UNINITIALIZED_OFFSET = 2;
-export declare const UNINITIALIZED_BIT: number;
-export declare const UNINITIALIZED: unique symbol;
-export declare const DEFAULT_FLAGS: number;

websites/default/packages/solid-signals/v0.3.2-treeshaked/types/map.d.ts

@@ -1,22 +0,0 @@
-import type { Accessor } from "./signals.js";
-export type Maybe<T> = T | void | null | undefined | false;
-/**
- * Reactively transforms an array with a callback function - underlying helper for the `<For>` control flow
- *
- * similar to `Array.prototype.map`, but gets the value and index as accessors, transforms only values that changed and returns an accessor and reactively tracks changes to the list.
- *
- * @description https://docs.solidjs.com/reference/reactive-utilities/map-array
- */
-export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly Item[]>>, map: (value: Accessor<Item>, index: Accessor<number>) => MappedItem, options?: {
-    keyed?: boolean | ((item: Item) => any);
-    fallback?: Accessor<any>;
-}): Accessor<MappedItem[]>;
-/**
- * Reactively repeats a callback function the count provided - underlying helper for the `<Repeat>` control flow
- *
- * @description https://docs.solidjs.com/reference/reactive-utilities/repeat
- */
-export declare function repeat(count: Accessor<number>, map: (index: number) => any, options?: {
-    from?: Accessor<number | undefined>;
-    fallback?: Accessor<any>;
-}): Accessor<any[]>;

websites/default/packages/solid-signals/v0.3.2-treeshaked/types/store/index.d.ts

@@ -1,6 +0,0 @@
-export type { Store, StoreSetter, StoreNode, NotWrappable, SolidStore } from "./store.js";
-export type { Merge, Omit } from "./utils.js";
-export { unwrap, isWrappable, createStore, deep, $RAW, $TRACK, $PROXY, $TARGET } from "./store.js";
-export { createProjection } from "./projection.js";
-export { reconcile } from "./reconcile.js";
-export { merge, omit } from "./utils.js";

websites/default/packages/solid-signals/v0.3.2-treeshaked/types/store/projection.d.ts

@@ -1,8 +0,0 @@
-import { type Store, type StoreSetter } from "./store.js";
-/**
- * Creates a mutable derived value
- *
- * @see {@link https://github.com/solidjs/x-reactivity#createprojection}
- */
-export declare function createProjection<T extends Object>(fn: (draft: T) => void, initialValue?: T): Store<T>;
-export declare function wrapProjection<T>(fn: (draft: T) => void, store: Store<T>, setStore: StoreSetter<T>): [Store<T>, StoreSetter<T>];

websites/default/packages/solid-signals/v0.3.2-treeshaked/types/store/reconcile.d.ts

@@ -1 +0,0 @@
-export declare function reconcile<T extends U, U>(value: T, key: string | ((item: NonNullable<any>) => any)): (state: U) => T;

websites/default/packages/solid-signals/v0.3.2-treeshaked/types/store/store.d.ts

@@ -1,35 +0,0 @@
-import { Computation } from "../core/index.js";
-export type Store<T> = Readonly<T>;
-export type StoreSetter<T> = (fn: (state: T) => void) => void;
-type DataNode = Computation<any>;
-type DataNodes = Record<PropertyKey, DataNode>;
-declare const $RAW: unique symbol, $TRACK: unique symbol, $TARGET: unique symbol, $PROXY: unique symbol;
-export declare const STORE_VALUE = "v", STORE_NODE = "n", STORE_HAS = "h";
-export { $PROXY, $TRACK, $RAW, $TARGET };
-export type StoreNode = {
-    [STORE_VALUE]: Record<PropertyKey, any>;
-    [STORE_NODE]?: DataNodes;
-    [STORE_HAS]?: DataNodes;
-};
-export declare namespace SolidStore {
-    interface Unwrappable {
-    }
-}
-export type NotWrappable = string | number | bigint | symbol | boolean | Function | null | undefined | SolidStore.Unwrappable[keyof SolidStore.Unwrappable];
-export declare function wrap<T extends Record<PropertyKey, any>>(value: T): T;
-export declare function isWrappable<T>(obj: T | NotWrappable): obj is T;
-/**
- * Returns the underlying data in the store without a proxy.
- * @param item store proxy object
- * @example
- * ```js
- * const initial = {z...};
- * const [state, setState] = createStore(initial);
- * initial === state; // => false
- * initial === unwrap(state); // => true
- * ```
- */
-export declare function unwrap<T>(item: T, deep?: boolean, set?: Set<unknown>): T;
-export declare function createStore<T extends object = {}>(store: T | Store<T>): [get: Store<T>, set: StoreSetter<T>];
-export declare function createStore<T extends object = {}>(fn: (store: T) => void, store: T | Store<T>): [get: Store<T>, set: StoreSetter<T>];
-export declare function deep<T extends object>(store: Store<T>): Store<any>;

websites/default/packages/solid-signals/v0.3.2-treeshaked/types/store/utils.d.ts

@@ -1,29 +0,0 @@
-type DistributeOverride<T, F> = T extends undefined ? F : T;
-type Override<T, U> = T extends any ? U extends any ? {
-    [K in keyof T]: K extends keyof U ? DistributeOverride<U[K], T[K]> : T[K];
-} & {
-    [K in keyof U]: K extends keyof T ? DistributeOverride<U[K], T[K]> : U[K];
-} : T & U : T & U;
-type OverrideSpread<T, U> = T extends any ? {
-    [K in keyof ({
-        [K in keyof T]: any;
-    } & {
-        [K in keyof U]?: any;
-    } & {
-        [K in U extends any ? keyof U : keyof U]?: any;
-    })]: K extends keyof T ? Exclude<U extends any ? U[K & keyof U] : never, undefined> | T[K] : U extends any ? U[K & keyof U] : never;
-} : T & U;
-type Simplify<T> = T extends any ? {
-    [K in keyof T]: T[K];
-} : T;
-type _Merge<T extends unknown[], Curr = {}> = T extends [
-    infer Next | (() => infer Next),
-    ...infer Rest
-] ? _Merge<Rest, Override<Curr, Next>> : T extends [...infer Rest, infer Next | (() => infer Next)] ? Override<_Merge<Rest, Curr>, Next> : T extends [] ? Curr : T extends (infer I | (() => infer I))[] ? OverrideSpread<Curr, I> : Curr;
-export type Merge<T extends unknown[]> = Simplify<_Merge<T>>;
-export declare function merge<T extends unknown[]>(...sources: T): Merge<T>;
-export type Omit<T, K extends readonly (keyof T)[]> = {
-    [P in keyof T as Exclude<P, K[number]>]: T[P];
-};
-export declare function omit<T extends Record<any, any>, K extends readonly (keyof T)[]>(props: T, ...keys: K): Omit<T, K>;
-export {};