release: v0.0.45

Cargo.lock

@@ -388,7 +388,7 @@ dependencies = [
 
 [[package]]
 name = "brk"
-version = "0.0.42"
+version = "0.0.45"
 dependencies = [
  "brk_cli",
  "brk_computer",
@@ -407,7 +407,7 @@ dependencies = [
 
 [[package]]
 name = "brk_cli"
-version = "0.0.42"
+version = "0.0.45"
 dependencies = [
  "bitcoincore-rpc",
  "brk_computer",
@@ -432,7 +432,7 @@ dependencies = [
 
 [[package]]
 name = "brk_computer"
-version = "0.0.42"
+version = "0.0.45"
 dependencies = [
  "bitcoin",
  "bitcoincore-rpc",
@@ -453,7 +453,7 @@ dependencies = [
 
 [[package]]
 name = "brk_core"
-version = "0.0.42"
+version = "0.0.45"
 dependencies = [
  "bincode",
  "bitcoin",
@@ -474,7 +474,7 @@ dependencies = [
 
 [[package]]
 name = "brk_exit"
-version = "0.0.42"
+version = "0.0.45"
 dependencies = [
  "brk_logger",
  "ctrlc",
@@ -483,7 +483,7 @@ dependencies = [
 
 [[package]]
 name = "brk_fetcher"
-version = "0.0.42"
+version = "0.0.45"
 dependencies = [
  "brk_core",
  "brk_logger",
@@ -496,7 +496,7 @@ dependencies = [
 
 [[package]]
 name = "brk_indexer"
-version = "0.0.42"
+version = "0.0.45"
 dependencies = [
  "bitcoin",
  "bitcoincore-rpc",
@@ -514,7 +514,7 @@ dependencies = [
 
 [[package]]
 name = "brk_logger"
-version = "0.0.42"
+version = "0.0.45"
 dependencies = [
  "color-eyre",
  "env_logger",
@@ -524,7 +524,7 @@ dependencies = [
 
 [[package]]
 name = "brk_parser"
-version = "0.0.42"
+version = "0.0.45"
 dependencies = [
  "bitcoin",
  "bitcoincore-rpc",
@@ -539,7 +539,7 @@ dependencies = [
 
 [[package]]
 name = "brk_query"
-version = "0.0.42"
+version = "0.0.45"
 dependencies = [
  "brk_computer",
  "brk_core",
@@ -557,7 +557,7 @@ dependencies = [
 
 [[package]]
 name = "brk_server"
-version = "0.0.42"
+version = "0.0.45"
 dependencies = [
  "axum",
  "bitcoincore-rpc",
@@ -586,7 +586,7 @@ dependencies = [
 
 [[package]]
 name = "brk_state"
-version = "0.0.42"
+version = "0.0.45"
 dependencies = [
  "bincode",
  "brk_core",
@@ -600,7 +600,7 @@ dependencies = [
 
 [[package]]
 name = "brk_store"
-version = "0.0.42"
+version = "0.0.45"
 dependencies = [
  "arc-swap",
  "brk_core",
@@ -610,7 +610,7 @@ dependencies = [
 
 [[package]]
 name = "brk_vec"
-version = "0.0.42"
+version = "0.0.45"
 dependencies = [
  "arc-swap",
  "brk_core",

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.42"
+package.version = "0.0.45"
 package.homepage = "https://bitcoinresearchkit.org"
 package.repository = "https://github.com/bitcoinresearchkit/brk"
 

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

@@ -54,8 +54,8 @@ pub struct Vecs {
     pub height_to_satblocks_destroyed: EagerVec<Height, Sats>,
     pub height_to_satdays_destroyed: EagerVec<Height, Sats>,
 
-    pub indexes_to_coinblocks_destroyed: ComputedVecsFromHeight<Bitcoin>,
+    pub indexes_to_coinblocks_destroyed: ComputedVecsFromHeight<StoredF64>,
-    pub indexes_to_coindays_destroyed: ComputedVecsFromHeight<Bitcoin>,
+    pub indexes_to_coindays_destroyed: ComputedVecsFromHeight<StoredF64>,
     pub dateindex_to_adjusted_spent_output_profit_ratio: Option<EagerVec<DateIndex, StoredF32>>,
     pub dateindex_to_realized_cap_30d_change: Option<EagerVec<DateIndex, Dollars>>,
     pub dateindex_to_sell_side_risk_ratio: Option<EagerVec<DateIndex, StoredF32>>,
@@ -891,7 +891,7 @@ impl Vecs {
                 path,
                 &suffix("coinblocks_destroyed"),
                 true,
-                version + VERSION + Version::ONE,
+                version + VERSION + Version::TWO,
                 format,
                 StorableVecGeneatorOptions::default().add_sum(),
             )?,
@@ -899,7 +899,7 @@ impl Vecs {
                 path,
                 &suffix("coindays_destroyed"),
                 true,
-                version + VERSION + Version::ONE,
+                version + VERSION + Version::TWO,
                 format,
                 StorableVecGeneatorOptions::default().add_sum(),
             )?,
@@ -1839,9 +1839,10 @@ impl Vecs {
             starting_indexes,
             exit,
             |v, _, _, starting_indexes, exit| {
-                v.compute_from_sats(
+                v.compute_transform(
                     starting_indexes.height,
                     &self.height_to_satblocks_destroyed,
+                    |(i, v, ..)| (i, StoredF64::from(Bitcoin::from(v))),
                     exit,
                 )
             },
@@ -1853,9 +1854,10 @@ impl Vecs {
             starting_indexes,
             exit,
             |v, _, _, starting_indexes, exit| {
-                v.compute_from_sats(
+                v.compute_transform(
                     starting_indexes.height,
                     &self.height_to_satdays_destroyed,
+                    |(i, v, ..)| (i, StoredF64::from(Bitcoin::from(v))),
                     exit,
                 )
             },

crates/brk_core/src/structs/dateindex.rs

@@ -1,4 +1,7 @@
-use std::ops::Add;
+use std::{
+    fmt,
+    ops::{Add, Rem},
+};
 
 use serde::Serialize;
 // use color_eyre::eyre::eyre;
@@ -77,3 +80,16 @@ impl CheckedSub for DateIndex {
         self.0.checked_sub(rhs.0).map(Self)
     }
 }
+
+impl Rem<usize> for DateIndex {
+    type Output = Self;
+    fn rem(self, rhs: usize) -> Self::Output {
+        Self(self.0 % rhs as u16)
+    }
+}
+
+impl fmt::Display for DateIndex {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}

crates/brk_fetcher/examples/main.rs

@@ -1,11 +1,15 @@
-use brk_core::Date;
+use brk_core::{Date, Height};
-use brk_fetcher::Fetcher;
+use brk_fetcher::{BRK, Fetcher};
 
 fn main() -> color_eyre::Result<()> {
     color_eyre::install()?;
 
     brk_logger::init(None);
 
+    let mut brk = BRK::default();
+    dbg!(brk.get_from_height(Height::new(900_000))?);
+    dbg!(brk.get_from_date(Date::new(2025, 6, 7))?);
+
     let mut fetcher = Fetcher::import(None)?;
 
     dbg!(fetcher.get_date(Date::new(2025, 6, 5))?);

crates/brk_fetcher/src/fetchers/brk.rs

@@ -0,0 +1,143 @@
+use std::collections::BTreeMap;
+
+use brk_core::{Cents, CheckedSub, Date, DateIndex, Height, OHLCCents};
+use color_eyre::eyre::{ContextCompat, eyre};
+use log::info;
+use serde_json::Value;
+
+use crate::{Close, Dollars, High, Low, Open, fetchers::retry};
+
+#[derive(Default, Clone)]
+pub struct BRK {
+    height_to_ohlc: BTreeMap<Height, Vec<OHLCCents>>,
+    dateindex_to_ohlc: BTreeMap<DateIndex, Vec<OHLCCents>>,
+}
+
+const API_URL: &str = "https://bitcoinresearchkit.org/api";
+
+const RETRIES: usize = 10;
+
+const CHUNK_SIZE: usize = 10_000;
+
+impl BRK {
+    pub fn get_from_height(&mut self, height: Height) -> color_eyre::Result<OHLCCents> {
+        let key = height.checked_sub(height % CHUNK_SIZE).unwrap();
+
+        #[allow(clippy::map_entry)]
+        if !self.height_to_ohlc.contains_key(&key)
+            || ((key + self.height_to_ohlc.get(&key).unwrap().len()) <= height)
+        {
+            self.height_to_ohlc.insert(
+                key,
+                Self::fetch_height_prices(key).inspect_err(|e| {
+                    dbg!(e);
+                })?,
+            );
+        }
+
+        self.height_to_ohlc
+            .get(&key)
+            .unwrap()
+            .get(usize::from(height.checked_sub(key).unwrap()))
+            .cloned()
+            .ok_or(eyre!("Couldn't find height in kibo"))
+    }
+
+    fn fetch_height_prices(height: Height) -> color_eyre::Result<Vec<OHLCCents>> {
+        info!("Fetching Kibo height {height} prices...");
+
+        retry(
+            |_| {
+                let url = format!(
+                    "{API_URL}/query?index=height&values=ohlc&from={}&to={}",
+                    height,
+                    height + CHUNK_SIZE
+                );
+
+                let body: Value = minreq::get(url).send()?.json()?;
+
+                body.as_array()
+                    .context("Expect to be an array")?
+                    .iter()
+                    .map(Self::value_to_ohlc)
+                    .collect::<Result<Vec<_>, _>>()
+            },
+            30,
+            RETRIES,
+        )
+    }
+
+    pub fn get_from_date(&mut self, date: Date) -> color_eyre::Result<OHLCCents> {
+        let dateindex = DateIndex::try_from(date)?;
+
+        let key = dateindex.checked_sub(dateindex % CHUNK_SIZE).unwrap();
+
+        #[allow(clippy::map_entry)]
+        if !self.dateindex_to_ohlc.contains_key(&key)
+            || ((key + self.dateindex_to_ohlc.get(&key).unwrap().len()) <= dateindex)
+        {
+            self.dateindex_to_ohlc.insert(
+                key,
+                Self::fetch_date_prices(key).inspect_err(|e| {
+                    dbg!(e);
+                })?,
+            );
+        }
+
+        self.dateindex_to_ohlc
+            .get(&key)
+            .unwrap()
+            .get(usize::from(dateindex.checked_sub(key).unwrap()))
+            .cloned()
+            .ok_or(eyre!("Couldn't find date in kibo"))
+    }
+
+    fn fetch_date_prices(dateindex: DateIndex) -> color_eyre::Result<Vec<OHLCCents>> {
+        info!("Fetching Kibo dateindex {dateindex} prices...");
+
+        retry(
+            |_| {
+                let url = format!(
+                    "{API_URL}/query?index=dateindex&values=ohlc&from={}&to={}",
+                    dateindex,
+                    dateindex + CHUNK_SIZE
+                );
+
+                let body: Value = minreq::get(url).send()?.json()?;
+
+                body.as_array()
+                    .context("Expect to be an array")?
+                    .iter()
+                    .map(Self::value_to_ohlc)
+                    .collect::<Result<Vec<_>, _>>()
+            },
+            30,
+            RETRIES,
+        )
+    }
+
+    fn value_to_ohlc(value: &Value) -> color_eyre::Result<OHLCCents> {
+        let ohlc = value.as_array().context("Expect as_array to work")?;
+
+        let get_value = |index: usize| -> color_eyre::Result<_> {
+            Ok(Cents::from(Dollars::from(
+                ohlc.get(index)
+                    .context("Expect index key to work")?
+                    .as_f64()
+                    .context("Expect as_f64 to work")?,
+            )))
+        };
+
+        Ok(OHLCCents::from((
+            Open::new(get_value(0)?),
+            High::new(get_value(1)?),
+            Low::new(get_value(2)?),
+            Close::new(get_value(3)?),
+        )))
+    }
+
+    pub fn clear(&mut self) {
+        self.height_to_ohlc.clear();
+        self.dateindex_to_ohlc.clear();
+    }
+}

crates/brk_fetcher/src/fetchers/kibo.rs

@@ -1,155 +0,0 @@
-use std::{collections::BTreeMap, str::FromStr};
-
-use brk_core::{CheckedSub, Date, Height, OHLCCents};
-use color_eyre::eyre::{ContextCompat, eyre};
-use log::info;
-use serde_json::Value;
-
-use crate::{Cents, Close, Dollars, High, Low, Open, fetchers::retry};
-
-#[derive(Default, Clone)]
-pub struct Kibo {
-    height_to_ohlc_vec: BTreeMap<Height, Vec<OHLCCents>>,
-    year_to_date_to_ohlc: BTreeMap<u16, BTreeMap<Date, OHLCCents>>,
-}
-
-const KIBO_OFFICIAL_URL: &str = "https://kibo.money/api";
-
-const RETRIES: usize = 10;
-
-impl Kibo {
-    pub fn get_from_height(&mut self, height: Height) -> color_eyre::Result<OHLCCents> {
-        let key = height.checked_sub(height % 10_000).unwrap_or_default();
-
-        #[allow(clippy::map_entry)]
-        if !self.height_to_ohlc_vec.contains_key(&key)
-            || ((key + self.height_to_ohlc_vec.get(&key).unwrap().len()) <= height)
-        {
-            self.height_to_ohlc_vec.insert(
-                key,
-                Self::fetch_height_prices(key).inspect_err(|e| {
-                    dbg!(e);
-                })?,
-            );
-        }
-
-        self.height_to_ohlc_vec
-            .get(&key)
-            .unwrap()
-            .get(usize::from(height.checked_sub(key).unwrap()))
-            .cloned()
-            .ok_or(eyre!("Couldn't find height in kibo"))
-    }
-
-    fn fetch_height_prices(height: Height) -> color_eyre::Result<Vec<OHLCCents>> {
-        info!("Fetching Kibo height {height} prices...");
-
-        retry(
-            |_| {
-                let url = format!("{KIBO_OFFICIAL_URL}/height-to-price?chunk={}", height);
-
-                let body: Value = minreq::get(url).send()?.json()?;
-
-                body.as_object()
-                    .context("Expect to be an object")?
-                    .get("dataset")
-                    .context("Expect object to have dataset")?
-                    .as_object()
-                    .context("Expect to be an object")?
-                    .get("map")
-                    .context("Expect to have map")?
-                    .as_array()
-                    .context("Expect to be an array")?
-                    .iter()
-                    .map(Self::value_to_ohlc)
-                    .collect::<Result<Vec<_>, _>>()
-            },
-            30,
-            RETRIES,
-        )
-    }
-
-    pub fn get_from_date(&mut self, date: &Date) -> color_eyre::Result<OHLCCents> {
-        let year = date.year();
-
-        #[allow(clippy::map_entry)]
-        if !self.year_to_date_to_ohlc.contains_key(&year)
-            || self
-                .year_to_date_to_ohlc
-                .get(&year)
-                .unwrap()
-                .last_key_value()
-                .unwrap()
-                .0
-                <= date
-        {
-            self.year_to_date_to_ohlc
-                .insert(year, Self::fetch_date_prices(year)?);
-        }
-
-        self.year_to_date_to_ohlc
-            .get(&year)
-            .unwrap()
-            .get(date)
-            .cloned()
-            .ok_or(eyre!("Couldn't find date in kibo"))
-    }
-
-    fn fetch_date_prices(year: u16) -> color_eyre::Result<BTreeMap<Date, OHLCCents>> {
-        info!("Fetching Kibo date {year} prices...");
-
-        retry(
-            |_| {
-                let body: Value =
-                    minreq::get(format!("{KIBO_OFFICIAL_URL}/date-to-price?chunk={}", year))
-                        .send()?
-                        .json()?;
-
-                body.as_object()
-                    .context("Expect to be an object")?
-                    .get("dataset")
-                    .context("Expect object to have dataset")?
-                    .as_object()
-                    .context("Expect to be an object")?
-                    .get("map")
-                    .context("Expect to have map")?
-                    .as_object()
-                    .context("Expect to be an object")?
-                    .iter()
-                    .map(|(serialized_date, value)| -> color_eyre::Result<_> {
-                        let date =
-                            Date::from(jiff::civil::Date::from_str(serialized_date).unwrap());
-                        Ok((date, Self::value_to_ohlc(value)?))
-                    })
-                    .collect::<Result<BTreeMap<_, _>, _>>()
-            },
-            30,
-            RETRIES,
-        )
-    }
-
-    fn value_to_ohlc(value: &Value) -> color_eyre::Result<OHLCCents> {
-        let ohlc = value.as_object().context("Expect as_object to work")?;
-
-        let get_value = |key: &str| -> color_eyre::Result<_> {
-            Ok(Cents::from(Dollars::from(
-                ohlc.get(key)
-                    .context("Expect get key to work")?
-                    .as_f64()
-                    .context("Expect as_f64 to work")?,
-            )))
-        };
-
-        Ok(OHLCCents::from((
-            Open::new(get_value("open")?),
-            High::new(get_value("high")?),
-            Low::new(get_value("low")?),
-            Close::new(get_value("close")?),
-        )))
-    }
-
-    pub fn clear(&mut self) {
-        self.height_to_ohlc_vec.clear();
-        self.year_to_date_to_ohlc.clear();
-    }
-}

crates/brk_fetcher/src/fetchers/mod.rs

@@ -1,9 +1,9 @@
 mod binance;
-// mod kibo;
+mod brk;
 mod kraken;
 mod retry;
 
 pub use binance::*;
-// pub use kibo::*;
+pub use brk::*;
 pub use kraken::*;
 use retry::*;

crates/brk_fetcher/src/lib.rs

@@ -10,7 +10,7 @@ use color_eyre::eyre::Error;
 
 mod fetchers;
 
-use fetchers::*;
+pub use fetchers::*;
 use log::info;
 
 const TRIES: usize = 12 * 60;
@@ -19,7 +19,7 @@ const TRIES: usize = 12 * 60;
 pub struct Fetcher {
     binance: Binance,
     kraken: Kraken,
-    // kibo: Kibo,
+    brk: BRK,
 }
 
 impl Fetcher {
@@ -31,7 +31,7 @@ impl Fetcher {
         Ok(Self {
             binance: Binance::init(hars_path),
             kraken: Kraken::default(),
-            // kibo: Kibo::default(),
+            brk: BRK::default(),
         })
     }
 
@@ -46,6 +46,10 @@ impl Fetcher {
                 // eprintln!("{e}");
                 self.kraken.get_from_1d(&date)
             })
+            .or_else(|_| {
+                // eprintln!("{e}");
+                self.brk.get_from_date(date)
+            })
             .or_else(|e| {
                 sleep(Duration::from_secs(60));
 
@@ -94,28 +98,28 @@ impl Fetcher {
                     .get_from_1mn(timestamp, previous_timestamp)
                     .unwrap_or_else(|_report| {
                         //         // eprintln!("{_report}");
-                        // self.kibo.get_from_height(height).unwrap_or_else(|_report| {
+                        self.brk.get_from_height(height).unwrap_or_else(|_report| {
-                        // eprintln!("{_report}");
+                            // eprintln!("{_report}");
 
-                        sleep(Duration::from_secs(60));
+                            sleep(Duration::from_secs(60));
 
-                        if tries < TRIES {
+                            if tries < TRIES {
-                            self.clear();
+                                self.clear();
 
-                            info!("Retrying to fetch height prices...");
+                                info!("Retrying to fetch height prices...");
-                            // dbg!((height, timestamp, previous_timestamp));
+                                // dbg!((height, timestamp, previous_timestamp));
 
-                            return self
+                                return self
-                                .get_height_(height, timestamp, previous_timestamp, tries + 1)
+                                    .get_height_(height, timestamp, previous_timestamp, tries + 1)
-                                .unwrap();
+                                    .unwrap();
-                        }
+                            }
 
-                        info!("Failed to fetch height prices");
+                            info!("Failed to fetch height prices");
 
-                        let date = Date::from(timestamp);
+                            let date = Date::from(timestamp);
-                        // eprintln!("{e}");
+                            // eprintln!("{e}");
-                        panic!(
+                            panic!(
-                            "
+                                "
 Can't find the price for: height: {height} - date: {date}
 1mn APIs are limited to the last 16 hours for Binance's and the last 10 hours for Kraken's
 How to fix this:
@@ -130,8 +134,8 @@ How to fix this:
 8. Export to a har file (if there is no explicit button, click on the cog button)
 9. Move the file to 'parser/imports/binance.har'
         "
-                        )
+                            )
-                        // })
+                        })
                     })
             });
 
@@ -182,7 +186,7 @@ How to fix this:
 
     pub fn clear(&mut self) {
         self.binance.clear();
-        // self.kibo.clear();
+        self.brk.clear();
         self.kraken.clear();
     }
 }

crates/brk_server/src/files/file.rs

@@ -43,7 +43,7 @@ fn any_handler(
 
         let mut path = website_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,

websites/default/index.html

@@ -2,7 +2,7 @@
 <html lang="en">
   <head>
     <meta charset="utf-8" />
-    <title>kibo.money</title>
+    <!-- <title>kibo.money</title> -->
     <meta
       name="description"
       content="An open source Bitcoin Core data extractor and visualizer"
@@ -764,7 +764,7 @@
           text-transform: uppercase;
 
           & + * {
-            margin-top: 1.5rem;
+            margin-top: 1.25rem;
           }
 
           > details,
@@ -887,7 +887,7 @@
         bottom: 0;
         left: 0;
         right: 0;
-        z-index: 20;
+        z-index: 10;
         pointer-events: none;
       }
       .shadow-left {
@@ -901,7 +901,7 @@
         left: 0;
         top: 0;
         bottom: 0;
-        z-index: 40 !important;
+        z-index: 50;
         pointer-events: none;
       }
       .shadow-right {
@@ -915,7 +915,7 @@
         right: 0;
         top: 0;
         bottom: 0;
-        z-index: 10;
+        z-index: 30;
         pointer-events: none;
       }
 
@@ -1160,7 +1160,6 @@
         window.document.documentElement.dataset.display = "standalone";
       }
 
-      console.log(navigator);
       if ("serviceWorker" in navigator) {
         navigator.serviceWorker.register("/scripts/service-worker.js");
       }
@@ -1535,29 +1534,11 @@
   </head>
   <body>
     <main id="main">
-      <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`;
-        }
-      </script>
-
       <div class="shadow-top"></div>
       <div class="shadow-bottom"></div>
       <div id="resize-bar"></div>
 
-      <nav id="nav" hidden>
+      <nav id="nav" hidden></nav>
-        <h4 style="margin-top: 0.25rem">
-          <a href="/"
-            ><span style="font-weight: 500">kibo</span
-            ><span style="color: var(--gray)">.</span
-            ><span style="color: var(--orange)">money</span></a
-          >
-        </h4>
-      </nav>
 
       <search id="search" hidden>
         <header>
@@ -1625,5 +1606,15 @@
         <a id="share-anchor" href="/"></a>
       </div>
     </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`;
+      }
+    </script>
   </body>
 </html>

websites/default/packages/lightweight-charts/wrapper.js

@@ -1,6 +1,6 @@
 // @ts-check
 
-/** @import {IChartApi, ISeriesApi, SeriesDefinition, SingleValueData as _SingleValueData, CandlestickData as _CandlestickData, BaselineData, SeriesType, IPaneApi, BaselineStyleOptions} from './v5.0.6-treeshaked/types' */
+/** @import {IChartApi, ISeriesApi, SeriesDefinition, SingleValueData as _SingleValueData, CandlestickData as _CandlestickData, BaselineData, SeriesType, IPaneApi, BaselineStyleOptions} from './v5.0.7-treeshaked/types' */
 
 /**
  * @typedef {[number, number, number, number]} OHLCTuple
@@ -22,7 +22,7 @@
  * @typedef {ChartData<_CandlestickData>} CandlestickData
  */
 
-export default import("./v5.0.6-treeshaked/script.js").then((lc) => {
+export default import("./v5.0.7-treeshaked/script.js").then((lc) => {
   const oklchToRGBA = createOklchToRGBA();
 
   /**

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

@@ -1,4 +1,4 @@
-import { Accessor, Setter } from "./v0.3.0-treeshaked/types/signals";
+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.2-treeshaked/script.js

@@ -0,0 +1,678 @@
+// @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/boundaries.d.ts

@@ -0,0 +1,21 @@
+import { Computation, Queue } from "./core/index.js";
+import type { Effect } from "./core/index.js";
+export declare class CollectionQueue extends Queue {
+    _collectionType: number;
+    _nodes: Set<Effect>;
+    _disabled: Computation<boolean>;
+    constructor(type: number);
+    run(type: number): void;
+    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;
+export declare function flatten(children: any, options?: {
+    skipNonRendered?: boolean;
+    doNotUnwrap?: boolean;
+}): any;

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

@@ -0,0 +1,14 @@
+/**
+ * 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/core.d.ts

@@ -0,0 +1,155 @@
+/**
+ * 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> {
+    id?: string;
+    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 that 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 {};

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

@@ -0,0 +1,34 @@
+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(type: number): 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.2-treeshaked/types/core/error.d.ts

@@ -0,0 +1,11 @@
+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);
+}

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

@@ -0,0 +1,11 @@
+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/core/index.d.ts

@@ -0,0 +1,7 @@
+export { ContextNotFoundError, NoOwnerError, NotReadyError } 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, UNCHANGED, compute, runWithObserver, type SignalOptions } from "./core.js";
+export { Effect, EagerComputation } from "./effect.js";
+export { flushSync, Queue, incrementClock, getClock, type IQueue } from "./scheduler.js";
+export * from "./constants.js";
+export * from "./flags.js";

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

@@ -0,0 +1,95 @@
+/**
+ * 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;
+    _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.2-treeshaked/types/core/scheduler.d.ts

@@ -0,0 +1,33 @@
+export declare function getClock(): number;
+export declare function incrementClock(): void;
+type QueueCallback = (type: number) => void;
+export interface IQueue {
+    enqueue(type: number, fn: QueueCallback): 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: [QueueCallback[], QueueCallback[]];
+    _children: IQueue[];
+    created: number;
+    enqueue(type: number, fn: QueueCallback): void;
+    run(type: number): void;
+    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;
+export {};

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

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

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

@@ -0,0 +1,22 @@
+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/signals.d.ts

@@ -0,0 +1,138 @@
+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 readonly derived async reactive memoized signal
+ * ```typescript
+ * export function createAsync<T>(
+ *   compute: (v: T) => Promise<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-async
+ */
+/**
+ * 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 reactive computation that runs during the render phase as DOM elements are created and updated but not necessarily connected
+ * ```typescript
+ * export function createRenderEffect<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
+ * @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/secondary-primitives/create-render-effect
+ */
+/**
+ * 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;
+/**
+ * Returns a promise of the resolved value of a reactive expression
+ * @param fn a reactive expression to resolve
+ */

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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1 @@
+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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,29 @@
+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 {};

websites/default/packages/solid-signals/wrapper.js

@@ -1,13 +1,13 @@
 // @ts-check
 
 /**
- * @import { SignalOptions } from "./v0.3.0-treeshaked/types/core/core"
+ * @import { SignalOptions } from "./v0.3.2-treeshaked/types/core/core"
- * @import { getOwner as GetOwner, onCleanup as OnCleanup, Owner } from "./v0.3.0-treeshaked/types/core/owner"
+ * @import { getOwner as GetOwner, onCleanup as OnCleanup } from "./v0.3.2-treeshaked/types/core/owner"
- * @import { createSignal as CreateSignal, createEffect as CreateEffect, Accessor, Setter, createMemo as CreateMemo, createRoot as CreateRoot, runWithOwner as RunWithOwner } from "./v0.3.0-treeshaked/types/signals";
+ * @import { createSignal as CreateSignal, createEffect as CreateEffect, createMemo as CreateMemo, createRoot as CreateRoot, runWithOwner as RunWithOwner } from "./v0.3.2-treeshaked/types/signals";
  * @import { Signal } from "./types";
  */
 
-const importSignals = import("./v0.3.0-treeshaked/script.js").then(
+const importSignals = import("./v0.3.2-treeshaked/script.js").then(
   (_signals) => {
     const signals = {
       createSolidSignal: /** @type {typeof CreateSignal} */ (

websites/default/scripts/main.js

@@ -4,11 +4,11 @@
  * @import { Option, PartialChartOption, ChartOption, AnyPartialOption, ProcessedOptionAddons, OptionsTree, SimulationOption, AnySeriesBlueprint, ChartableIndex,CreatePriceLineOptions, CreatePriceLine } from "./options"
  * @import {Valued,  SingleValueData, CandlestickData, ChartData, OHLCTuple} from "../packages/lightweight-charts/wrapper"
  * @import * as _ from "../packages/ufuzzy/v1.0.14/types"
- * @import { createChart as CreateClassicChart, LineStyleOptions, DeepPartial, ChartOptions, IChartApi, IHorzScaleBehavior, WhitespaceData, ISeriesApi, Time, LineData, LogicalRange, BaselineStyleOptions, SeriesOptionsCommon, BaselineData, CandlestickStyleOptions } from "../packages/lightweight-charts/v5.0.6-treeshaked/types"
+ * @import { createChart as CreateClassicChart, LineStyleOptions, DeepPartial, ChartOptions, IChartApi, IHorzScaleBehavior, WhitespaceData, ISeriesApi, Time, LineData, LogicalRange, BaselineStyleOptions, SeriesOptionsCommon, BaselineData, CandlestickStyleOptions } from "../packages/lightweight-charts/v5.0.7-treeshaked/types"
- * @import { SignalOptions } from "../packages/solid-signals/v0.3.0-treeshaked/types/core/core"
+ * @import { SignalOptions } from "../packages/solid-signals/v0.3.2-treeshaked/types/core/core"
  * @import {Signal, Signals} from "../packages/solid-signals/types";
- * @import { getOwner as GetOwner, onCleanup as OnCleanup, Owner } from "../packages/solid-signals/v0.3.0-treeshaked/types/core/owner"
+ * @import { getOwner as GetOwner, onCleanup as OnCleanup, Owner } from "../packages/solid-signals/v0.3.2-treeshaked/types/core/owner"
- * @import { createEffect as CreateEffect, Accessor, Setter, createMemo as CreateMemo } from "../packages/solid-signals/v0.3.0-treeshaked/types/signals";
+ * @import { createEffect as CreateEffect, Accessor, Setter, createMemo as CreateMemo } from "../packages/solid-signals/v0.3.2-treeshaked/types/signals";
  * @import {DateIndex, DecadeIndex, DifficultyEpoch, Index, HalvingEpoch, Height, MonthIndex, P2PK33Index, P2PK65Index, P2PKHIndex, P2SHIndex, P2MSIndex, P2AIndex, P2TRIndex, P2WPKHIndex, P2WSHIndex, TxIndex, InputIndex, OutputIndex, VecId, WeekIndex, YearIndex, VecIdToIndexes, QuarterIndex, EmptyOutputIndex, OpReturnIndex, UnknownOutputIndex} from "./vecid-to-indexes"
  */
 
@@ -2062,7 +2062,7 @@ function initWebSockets(signals, utils) {
 
         window.document.title = `${latest.close.toLocaleString(
           "en-us",
-        )} | kibo.money`;
+        )} | ${window.location.host}`;
       }
     });
   }

websites/default/styles/chart.css

@@ -28,11 +28,12 @@
     flex: 1;
   }
 
-  .lightweight-chart {
+  > .chart > legend,
-    z-index: 30;
+  > fieldset {
+    z-index: 20;
   }
 
-  > * {
+  .lightweight-chart {
-    /* z-index: 30; */
+    z-index: 40;
   }
 }