bitview: fix top unit + add back lib types

.gitignore

@@ -26,5 +26,3 @@ flamegraph.svg
 
 # AI
 .claude
-CLAUDE.md
-CLAUDE*.md

crates/brk_indexer/src/lib.rs

@@ -5,11 +5,11 @@ use std::{collections::BTreeMap, path::Path, str::FromStr, thread, time::Instant
 use bitcoin::{Transaction, TxIn, TxOut};
 use brk_error::{Error, Result};
 
-use brk_parser::{BlockExtended, Parser};
+use brk_parser::Parser;
 use brk_store::AnyStore;
 use brk_structs::{
-    AddressBytes, AddressBytesHash, BlockHash, BlockHashPrefix, Height, InputIndex, OutputIndex,
-    OutputType, Sats, StoredBool, Timestamp, TxIndex, Txid, TxidPrefix, TypeIndex,
+    AddressBytes, AddressBytesHash, BlockExtended, BlockHash, BlockHashPrefix, Height, InputIndex,
+    OutputIndex, OutputType, Sats, StoredBool, Timestamp, TxIndex, Txid, TxidPrefix, TypeIndex,
     TypeIndexWithOutputindex, Unit, Version, Vin, Vout,
 };
 use log::{error, info};

crates/brk_parser/examples/main.rs

@@ -1,7 +1,7 @@
 use std::path::Path;
 
 use bitcoincore_rpc::{Auth, Client, Result};
-use brk_parser::{BlockExtended, Parser};
+use brk_parser::Parser;
 use brk_structs::Height;
 
 #[allow(clippy::needless_doctest_main)]

crates/brk_parser/src/any_block.rs

@@ -2,15 +2,16 @@ use bitcoin::{Block, consensus::Decodable, io::Cursor};
 
 use crate::{XORBytes, XORIndex};
 
-pub enum BlockState {
+pub enum AnyBlock {
     Raw(Vec<u8>),
     Decoded(Block),
+    Skipped,
 }
 
-impl BlockState {
+impl AnyBlock {
     pub fn decode(&mut self, xor_i: &mut XORIndex, xor_bytes: &XORBytes) {
         let bytes = match self {
-            BlockState::Raw(bytes) => bytes,
+            AnyBlock::Raw(bytes) => bytes,
             _ => unreachable!(),
         };
 
@@ -20,6 +21,6 @@ impl BlockState {
 
         let block = Block::consensus_decode(&mut cursor).unwrap();
 
-        *self = BlockState::Decoded(block);
+        *self = AnyBlock::Decoded(block);
     }
 }

crates/brk_parser/src/block.rs

@@ -1,20 +0,0 @@
-use std::borrow::Cow;
-
-use bitcoin::Block;
-
-pub trait BlockExtended {
-    fn coinbase_tag(&self) -> Cow<'_, str>;
-}
-
-impl BlockExtended for Block {
-    fn coinbase_tag(&self) -> Cow<'_, str> {
-        String::from_utf8_lossy(
-            self.txdata
-                .first()
-                .and_then(|tx| tx.input.first())
-                .unwrap()
-                .script_sig
-                .as_bytes(),
-        )
-    }
-}

crates/brk_parser/src/error.rs

@@ -1,35 +0,0 @@
-use std::{
-    fmt::{self, Debug},
-    io,
-};
-
-pub type Result<T, E = Error> = std::result::Result<T, E>;
-
-#[derive(Debug)]
-pub enum Error {
-    IO(io::Error),
-    ZeroCopyError,
-}
-
-impl From<io::Error> for Error {
-    fn from(value: io::Error) -> Self {
-        Self::IO(value)
-    }
-}
-
-impl<A, B> From<zerocopy::error::SizeError<A, B>> for Error {
-    fn from(_: zerocopy::error::SizeError<A, B>) -> Self {
-        Self::ZeroCopyError
-    }
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Error::IO(error) => Debug::fmt(&error, f),
-            Error::ZeroCopyError => write!(f, "Zero copy convert error"),
-        }
-    }
-}
-
-impl std::error::Error for Error {}

crates/brk_parser/src/lib.rs

@@ -2,30 +2,26 @@
 
 use std::{cmp::Ordering, collections::BTreeMap, fs, ops::ControlFlow, path::PathBuf, thread};
 
-use bitcoin::{Block, BlockHash};
+use bitcoin::BlockHash;
 use bitcoincore_rpc::RpcApi;
 use blk_index_to_blk_path::*;
 use blk_recap::BlkRecap;
-use brk_structs::Height;
+use brk_structs::{Block, Height};
 use crossbeam::channel::{Receiver, bounded};
 use rayon::prelude::*;
 
+mod any_block;
 mod blk_index_to_blk_path;
 mod blk_index_to_blk_recap;
 mod blk_metadata;
 mod blk_recap;
-mod block;
-mod block_state;
-mod error;
 mod utils;
 mod xor_bytes;
 mod xor_index;
 
+use any_block::*;
 use blk_index_to_blk_recap::*;
 use blk_metadata::*;
-pub use block::*;
-use block_state::*;
-pub use error::*;
 use utils::*;
 use xor_bytes::*;
 use xor_index::*;
@@ -54,13 +50,13 @@ impl Parser {
         }
     }
 
-    pub fn get(&self, height: Height) -> Block {
-        self.parse(Some(height), Some(height))
-            .iter()
-            .next()
-            .unwrap()
-            .1
-    }
+    // pub fn get(&self, height: Height) -> Block {
+    //     self.parse(Some(height), Some(height))
+    //         .iter()
+    //         .next()
+    //         .unwrap()
+    //         .1
+    // }
 
     ///
     /// Returns a crossbeam channel receiver that receives `(Height, Block, BlockHash)` tuples from an **inclusive** range (`start` and `end`)
@@ -71,13 +67,13 @@ impl Parser {
         &self,
         start: Option<Height>,
         end: Option<Height>,
-    ) -> Receiver<(Height, Block, BlockHash)> {
+    ) -> Receiver<(Height, bitcoin::Block, BlockHash)> {
         let blocks_dir = self.blocks_dir.as_path();
         let rpc = self.rpc;
 
         let (send_bytes, recv_bytes) = bounded(BOUND_CAP);
         let (send_block, recv_block) = bounded(BOUND_CAP);
-        let (send_height_block_hash, recv_height_block_hash) = bounded(BOUND_CAP);
+        let (send_ordered, recv_ordered) = bounded(BOUND_CAP);
 
         let blk_index_to_blk_path = BlkIndexToBlkPath::scan(blocks_dir);
 
@@ -135,7 +131,7 @@ impl Parser {
                         let block_bytes = (blk_bytes[i..(i + len)]).to_vec();
 
                         if send_bytes
-                            .send((blk_metadata, BlockState::Raw(block_bytes), xor_i))
+                            .send((blk_metadata, AnyBlock::Raw(block_bytes), xor_i))
                             .is_err()
                         {
                             return ControlFlow::Break(());
@@ -157,23 +153,22 @@ impl Parser {
 
             let drain_and_send = |bulk: &mut Vec<_>| {
                 // Using a vec and sending after to not end up with stuck threads in par iter
-                bulk.par_iter_mut().for_each(|(_, block_state, xor_i)| {
-                    BlockState::decode(block_state, xor_i, &xor_bytes);
+                bulk.par_iter_mut().for_each(|(_, any_block, xor_i)| {
+                    AnyBlock::decode(any_block, xor_i, &xor_bytes);
                 });
 
-                bulk.drain(..)
-                    .try_for_each(|(blk_metadata, block_state, _)| {
-                        let block = match block_state {
-                            BlockState::Decoded(block) => block,
-                            _ => unreachable!(),
-                        };
+                bulk.drain(..).try_for_each(|(blk_metadata, any_block, _)| {
+                    let block = match any_block {
+                        AnyBlock::Decoded(block) => block,
+                        _ => unreachable!(),
+                    };
 
-                        if send_block.send((blk_metadata, block)).is_err() {
-                            return ControlFlow::Break(());
-                        }
+                    if send_block.send((blk_metadata, block)).is_err() {
+                        return ControlFlow::Break(());
+                    }
 
-                        ControlFlow::Continue(())
-                    })
+                    ControlFlow::Continue(())
+                })
             };
 
             recv_bytes.iter().try_for_each(|tuple| {
@@ -259,9 +254,7 @@ impl Parser {
                             return ControlFlow::Break(());
                         }
 
-                        send_height_block_hash
-                            .send((current_height, block, hash))
-                            .unwrap();
+                        send_ordered.send((current_height, block, hash)).unwrap();
 
                         if end.is_some_and(|end| end == current_height) {
                             return ControlFlow::Break(());
@@ -276,6 +269,6 @@ impl Parser {
             blk_index_to_blk_recap.export();
         });
 
-        recv_height_block_hash
+        recv_ordered
     }
 }

crates/brk_structs/src/structs/block.rs

@@ -0,0 +1,94 @@
+use std::{borrow::Cow, collections::HashMap, ops::Deref};
+
+use bitcoin::{Txid, block::Header, consensus::Decodable};
+use brk_error::Result;
+
+use super::{BlockHash, Height};
+
+#[derive(Debug)]
+pub struct Block {
+    pub block: bitcoin::Block,
+    pub hash: BlockHash,
+    pub height: Height,
+    pub tx_positions: HashMap<Txid, usize>, // txid -> offset
+    pub block_start_offset: usize,
+}
+
+impl Block {
+    pub fn parse(block_data: &[u8], file_offset: usize) -> Result<Self> {
+        let mut cursor = std::io::Cursor::new(block_data);
+
+        let header = Header::consensus_decode(&mut cursor)?;
+
+        // Parse transactions with positions
+        let tx_count = bitcoin::VarInt::consensus_decode(&mut cursor)?.0 as usize;
+        let mut transactions = Vec::with_capacity(tx_count);
+        let mut tx_positions = HashMap::with_capacity(tx_count);
+
+        for _ in 0..tx_count {
+            let start = cursor.position() as usize;
+            let tx = bitcoin::Transaction::consensus_decode(&mut cursor)?;
+
+            tx_positions.insert(tx.compute_txid(), start);
+            transactions.push(tx);
+        }
+
+        let block = bitcoin::Block {
+            header,
+            txdata: transactions,
+        };
+
+        // block.bip34_block_height()
+
+        let hash = block.block_hash();
+
+        Ok(Block {
+            block,
+            hash: hash.into(),
+            height: Height::ZERO,
+            tx_positions,
+            block_start_offset: file_offset,
+        })
+    }
+
+    pub fn get_absolute_position(&self, txid: &Txid) -> Option<usize> {
+        self.tx_positions
+            .get(txid)
+            .map(|offset| self.block_start_offset + offset)
+    }
+
+    pub fn coinbase_tag(&self) -> Cow<'_, str> {
+        String::from_utf8_lossy(
+            self.txdata
+                .first()
+                .and_then(|tx| tx.input.first())
+                .unwrap()
+                .script_sig
+                .as_bytes(),
+        )
+    }
+}
+
+impl Deref for Block {
+    type Target = bitcoin::Block;
+    fn deref(&self) -> &Self::Target {
+        &self.block
+    }
+}
+
+pub trait BlockExtended {
+    fn coinbase_tag(&self) -> Cow<'_, str>;
+}
+
+impl BlockExtended for bitcoin::Block {
+    fn coinbase_tag(&self) -> Cow<'_, str> {
+        String::from_utf8_lossy(
+            self.txdata
+                .first()
+                .and_then(|tx| tx.input.first())
+                .unwrap()
+                .script_sig
+                .as_bytes(),
+        )
+    }
+}

crates/brk_structs/src/structs/mod.rs

@@ -4,6 +4,7 @@ mod addressbytes;
 mod addressbyteshash;
 mod anyaddressindex;
 mod bitcoin;
+mod block;
 mod blockhash;
 mod blockhashprefix;
 mod cents;
@@ -67,6 +68,7 @@ pub use addressbytes::*;
 pub use addressbyteshash::*;
 pub use anyaddressindex::*;
 pub use bitcoin::*;
+pub use block::*;
 pub use blockhash::*;
 pub use blockhashprefix::*;
 pub use cents::*;

docs/.gitignore

@@ -0,0 +1,3 @@
+CLAUDE*.md
+OPENSATS*.md
+DUMP.md

websites/bitview/packages/.gitignore

@@ -10,6 +10,5 @@ dev.js
 *.iife.*
 nano.*
 worker.*
-*.ts
 *.mts
 *.cts

websites/bitview/packages/lean-qr/2.5.0/index.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/bitview/packages/leeoniya-ufuzzy/1.0.19/dist/uFuzzy.d.ts

@@ -0,0 +1,215 @@
+declare class uFuzzy {
+  constructor(opts?: uFuzzy.Options);
+
+  /** search API composed of filter/info/sort, with a info/ranking threshold (1e3) and fast outOfOrder impl */
+  search(
+    haystack: string[],
+    needle: string,
+    /** limit how many terms will be permuted, default = 0; 5 will result in up to 5! (120) search iterations. be careful with this! */
+    outOfOrder?: number,
+    /** default = 1e3 */
+    infoThresh?: number,
+    preFiltered?: uFuzzy.HaystackIdxs | null,
+  ): uFuzzy.SearchResult;
+
+  /** initial haystack filter, can accept idxs from previous prefix/typeahead match as optimization */
+  filter(
+    haystack: string[],
+    needle: string,
+    idxs?: uFuzzy.HaystackIdxs,
+  ): uFuzzy.HaystackIdxs | null;
+
+  /** collects stats about pre-filtered matches, does additional filtering based on term boundary settings, finds highlight ranges */
+  info(
+    idxs: uFuzzy.HaystackIdxs,
+    haystack: string[],
+    needle: string,
+  ): uFuzzy.Info;
+
+  /** performs final result sorting via Array.sort(), relying on Info */
+  sort(
+    info: uFuzzy.Info,
+    haystack: string[],
+    needle: string,
+  ): uFuzzy.InfoIdxOrder;
+
+  /** utility for splitting needle into terms following defined interSplit/intraSplit opts. useful for out-of-order permutes */
+  split(needle: string, keepCase?: boolean): uFuzzy.Terms;
+
+  /** util for creating out-of-order permutations of a needle terms array */
+  static permute(arr: unknown[]): unknown[][];
+
+  /** util for replacing common diacritics/accents */
+  static latinize<T extends string[] | string>(strings: T): T;
+
+  /** util for highlighting matched substr parts of a result */
+  static highlight<TAccum = string, TMarkedPart = string>(
+    match: string,
+    ranges: number[],
+
+    mark?: (part: string, matched: boolean) => TMarkedPart,
+    accum?: TAccum,
+    append?: (accum: TAccum, part: TMarkedPart) => TAccum | undefined,
+  ): TAccum;
+}
+
+export = uFuzzy;
+
+declare namespace uFuzzy {
+  /** needle's terms */
+  export type Terms = string[];
+
+  /** subset of idxs of a haystack array */
+  export type HaystackIdxs = number[];
+
+  /** sorted order in which info facets should be iterated */
+  export type InfoIdxOrder = number[];
+
+  export type AbortedResult = [null, null, null];
+
+  export type FilteredResult = [uFuzzy.HaystackIdxs, null, null];
+
+  export type RankedResult = [
+    uFuzzy.HaystackIdxs,
+    uFuzzy.Info,
+    uFuzzy.InfoIdxOrder,
+  ];
+
+  export type SearchResult = FilteredResult | RankedResult | AbortedResult;
+
+  /** partial RegExp */
+  type PartialRegExp = string;
+
+  /** what should be considered acceptable term bounds */
+  export const enum BoundMode {
+    /** will match 'man' substr anywhere. e.g. tasmania */
+    Any = 0,
+    /** will match 'man' at whitespace, punct, case-change, and alpha-num boundaries. e.g. mantis, SuperMan, fooManBar, 0007man */
+    Loose = 1,
+    /** will match 'man' at whitespace, punct boundaries only. e.g. mega man, walk_man, man-made, foo.man.bar */
+    Strict = 2,
+  }
+
+  export const enum IntraMode {
+    /** allows any number of extra char insertions within a term, but all term chars must be present for a match */
+    MultiInsert = 0,
+    /** allows for a single-char substitution, transposition, insertion, or deletion within terms (excluding first and last chars) */
+    SingleError = 1,
+  }
+
+  export type IntraSliceIdxs = [from: number, to: number];
+
+  type CompareFn = (a: string, b: string) => number;
+
+  export interface Options {
+    // whether regexps use a /u unicode flag
+    unicode?: boolean; // false
+
+    /** @deprecated renamed to opts.alpha */
+    letters?: PartialRegExp | null; // a-z
+
+    // regexp character class [] of chars which should be treated as letters (case insensitive)
+    alpha?: PartialRegExp | null; // a-z
+
+    /** term segmentation & punct/whitespace merging */
+    interSplit?: PartialRegExp; // '[^A-Za-z\\d']+'
+    intraSplit?: PartialRegExp | null; // '[a-z][A-Z]'
+
+    /** inter bounds that will be used to increase lft2/rgt2 info counters */
+    interBound?: PartialRegExp | null; // '[^A-Za-z\\d]'
+    /** intra bounds that will be used to increase lft1/rgt1 info counters */
+    intraBound?: PartialRegExp | null; // '[A-Za-z][0-9]|[0-9][A-Za-z]|[a-z][A-Z]'
+
+    /** inter-term modes, during .info() can discard matches when bounds conditions are not met */
+    interLft?: BoundMode; // 0
+    interRgt?: BoundMode; // 0
+
+    /** allowance between terms */
+    interChars?: PartialRegExp; // '.'
+    interIns?: number; // Infinity
+
+    /** allowance between chars within terms */
+    intraChars?: PartialRegExp; // '[a-z\\d]'
+    intraIns?: number; // 0
+
+    /** contractions detection */
+    intraContr?: PartialRegExp; // "'[a-z]{1,2}\\b"
+
+    /** error tolerance mode within terms. will clamp intraIns to 1 when set to SingleError */
+    intraMode?: IntraMode; // 0
+
+    /** which part of each term should tolerate errors (when intraMode: 1) */
+    intraSlice?: IntraSliceIdxs; // [1, Infinity]
+
+    /** max substitutions (when intraMode: 1) */
+    intraSub?: 0 | 1; // 0
+    /** max transpositions (when intraMode: 1) */
+    intraTrn?: 0 | 1; // 0
+    /** max omissions/deletions (when intraMode: 1) */
+    intraDel?: 0 | 1; // 0
+
+    /** can dynamically adjust error tolerance rules per term in needle (when intraMode: 1) */
+    intraRules?: (term: string) => {
+      intraSlice?: IntraSliceIdxs;
+      intraIns: 0 | 1;
+      intraSub: 0 | 1;
+      intraTrn: 0 | 1;
+      intraDel: 0 | 1;
+    };
+
+    /** post-filters matches during .info() based on cmp of term in needle vs partial match */
+    intraFilt?: (term: string, match: string, index: number) => boolean; // should this also accept WIP info?
+
+    /** default: toLocaleUpperCase() */
+    toUpper?: (str: string) => string;
+
+    /** default: toLocaleLowerCase() */
+    toLower?: (str: string) => string;
+
+    /** final sorting cmp when all other match metrics are equal */
+    compare?: CompareFn;
+
+    sort?: (
+      info: Info,
+      haystack: string[],
+      needle: string,
+      compare?: CompareFn,
+    ) => InfoIdxOrder;
+  }
+
+  export interface Info {
+    /** matched idxs from haystack */
+    idx: HaystackIdxs;
+
+    /** match offsets */
+    start: number[];
+
+    /** number of left BoundMode.Strict term boundaries found */
+    interLft2: number[];
+    /** number of right BoundMode.Strict term boundaries found */
+    interRgt2: number[];
+    /** number of left BoundMode.Loose term boundaries found */
+    interLft1: number[];
+    /** number of right BoundMode.Loose term boundaries found */
+    interRgt1: number[];
+
+    /** total number of extra chars matched within all terms. higher = matched terms have more fuzz in them */
+    intraIns: number[];
+    /** total number of chars found in between matched terms. higher = terms are more sparse, have more fuzz in between them */
+    interIns: number[];
+
+    /** total number of matched contiguous chars (substrs but not necessarily full terms) */
+    chars: number[];
+
+    /** number of exactly-matched terms (intra = 0) where both lft and rgt landed on a BoundMode.Loose or BoundMode.Strict boundary */
+    terms: number[];
+
+    /** number of needle terms with case-sensitive partial matches */
+    cases: number[];
+
+    /** offset ranges within match for highlighting: [startIdx0, endIdx0, startIdx1, endIdx1,...] */
+    ranges: number[][];
+  }
+}
+
+export as namespace uFuzzy;

websites/bitview/packages/modern-screenshot/4.6.6/dist/index.d.ts

@@ -0,0 +1,353 @@
+interface Options {
+    /**
+     * Width in pixels to be applied to node before rendering.
+     */
+    width?: number;
+    /**
+     * Height in pixels to be applied to node before rendering.
+     */
+    height?: number;
+    /**
+     * A number between `0` and `1` indicating image quality (e.g. 0.92 => 92%) of the JPEG image.
+     */
+    quality?: number;
+    /**
+     * A string indicating the image format. The default type is image/png; that type is also used if the given type isn't supported.
+     */
+    type?: string;
+    /**
+     * The pixel ratio of captured image.
+     *
+     * DPI = 96 * scale
+     *
+     * default: 1
+     */
+    scale?: number;
+    /**
+     * A string value for the background color, any valid CSS color value.
+     */
+    backgroundColor?: string | null;
+    /**
+     * An object whose properties to be copied to node's style before rendering.
+     */
+    style?: Partial<CSSStyleDeclaration> | null;
+    /**
+     * A function taking DOM node as argument. Should return `true` if passed
+     * node should be included in the output. Excluding node means excluding
+     * it's children as well.
+     */
+    filter?: ((el: Node) => boolean) | null;
+    /**
+     * Maximum canvas size (pixels).
+     *
+     * https://developer.mozilla.org/en-US/docs/Web/HTML/Element/canvas#maximum_canvas_size
+     */
+    maximumCanvasSize?: number;
+    /**
+     * Load media timeout and fetch remote asset timeout (millisecond).
+     *
+     * default: 30000
+     */
+    timeout?: number;
+    /**
+     * Embed assets progress.
+     */
+    progress?: ((current: number, total: number) => void) | null;
+    /**
+     * Enable debug mode to view the execution time log.
+     */
+    debug?: boolean;
+    /**
+     * Custom implementation to get image data for a custom URL.
+     * This can be helpful for Capacitor or Cordova when using
+     * native fetch to bypass CORS issues.
+     *
+     * If returns a string, will completely bypass any `Options.fetch`
+     * settings with your custom implementation.
+     *
+     * If returns false, will fall back to normal fetch implementation
+     *
+     * @param url
+     * @returns A data URL for the image
+     */
+    fetchFn?: ((url: string) => Promise<string | false>) | null;
+    /**
+     * The options of fetch resources.
+     */
+    fetch?: {
+        /**
+         * The second parameter of `window.fetch` RequestInit
+         *
+         * default: {
+         *   cache: 'force-cache',
+         * }
+         */
+        requestInit?: RequestInit;
+        /**
+         * Set to `true` to append the current time as a query string to URL
+         * requests to enable cache busting.
+         *
+         * default: false
+         */
+        bypassingCache?: boolean | RegExp;
+        /**
+         * A data URL for a placeholder image that will be used when fetching
+         * an image fails. Defaults to an empty string and will render empty
+         * areas for failed images.
+         *
+         * default: data:image/png;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7
+         */
+        placeholderImage?: string | ((cloned: HTMLImageElement | SVGImageElement) => string | Promise<string>);
+    };
+    /**
+     * The options of fonts download and embed.
+     */
+    font?: false | {
+        /**
+         * Font minify
+         */
+        minify?: (font: ArrayBuffer, subset: string) => ArrayBuffer;
+        /**
+         * The preferred font format. If specified all other font formats are ignored.
+         */
+        preferredFormat?: 'woff' | 'woff2' | 'truetype' | 'opentype' | 'embedded-opentype' | 'svg' | string;
+        /**
+         * A CSS string to specify for font embeds. If specified only this CSS will
+         * be present in the resulting image.
+         */
+        cssText?: string;
+    };
+    /**
+     * All enabled features
+     *
+     * default: true
+     */
+    features?: boolean | {
+        /**
+         * Copy scrollbar css styles
+         *
+         * default: true
+         */
+        copyScrollbar?: boolean;
+        /**
+         * Remove abnormal attributes to cloned node (for normalize XML)
+         *
+         * default: true
+         */
+        removeAbnormalAttributes?: boolean;
+        /**
+         * Remove control characters (for normalize XML)
+         *
+         * default: true
+         */
+        removeControlCharacter?: boolean;
+        /**
+         * Fix svg+xml image decode (for Safari、Firefox)
+         *
+         * default: true
+         */
+        fixSvgXmlDecode?: boolean;
+        /**
+         * Render scrolled children with scrolled content
+         *
+         * default: false
+         */
+        restoreScrollPosition?: boolean;
+    };
+    /**
+     * Canvas `drawImage` interval
+     * is used to fix errors in decoding images in Safari、Firefox
+     *
+     * default: 100
+     */
+    drawImageInterval?: number;
+    /**
+     * Web Worker script url
+     */
+    workerUrl?: string | null;
+    /**
+     * Web Worker number
+     */
+    workerNumber?: number;
+    /**
+     * Triggered after each node is cloned
+     */
+    onCloneEachNode?: ((cloned: Node) => void | Promise<void>) | null;
+    /**
+     * Triggered after a node is cloned
+     */
+    onCloneNode?: ((cloned: Node) => void | Promise<void>) | null;
+    /**
+     * Triggered after a node is embed
+     */
+    onEmbedNode?: ((cloned: Node) => void | Promise<void>) | null;
+    /**
+     * Triggered after a ForeignObjectSvg is created
+     */
+    onCreateForeignObjectSvg?: ((svg: SVGSVGElement) => void | Promise<void>) | null;
+    /**
+     * An array of style property names.
+     * Can be used to manually specify which style properties are
+     * included when cloning nodes.
+     * This can be useful for performance-critical scenarios.
+     */
+    includeStyleProperties?: string[] | null;
+}
+
+interface Request {
+    type: 'image' | 'text';
+    resolve?: (response: string) => void;
+    reject?: (error: Error) => void;
+    response: Promise<string>;
+}
+interface InternalContext<T extends Node> {
+    /**
+     * FLAG
+     */
+    __CONTEXT__: true;
+    /**
+     * Logger
+     */
+    log: {
+        time: (label: string) => void;
+        timeEnd: (label: string) => void;
+        warn: (...args: any[]) => void;
+    };
+    /**
+     * Node
+     */
+    node: T;
+    /**
+     * Owner document
+     */
+    ownerDocument?: Document;
+    /**
+     * Owner window
+     */
+    ownerWindow?: Window;
+    /**
+     * DPI
+     *
+     * scale === 1 ? null : 96 * scale
+     */
+    dpi: number | null;
+    /**
+     * The `style` element under the root `svg` element
+     */
+    svgStyleElement?: HTMLStyleElement;
+    /**
+     * The `defs` element under the root `svg` element
+     */
+    svgDefsElement?: SVGDefsElement;
+    /**
+     * The `svgStyleElement` class styles
+     *
+     * Map<cssText, class[]>
+     */
+    svgStyles: Map<string, string[]>;
+    /**
+     * The map of default `getComputedStyle` for all tagnames
+     */
+    defaultComputedStyles: Map<string, Map<string, any>>;
+    /**
+     * The IFrame sandbox used to get the `defaultComputedStyles`
+     */
+    sandbox?: HTMLIFrameElement;
+    /**
+     * Web Workers
+     */
+    workers: Worker[];
+    /**
+     * The map of `font-family` values for all cloend elements
+     */
+    fontFamilies: Map<string, Set<string>>;
+    /**
+     * Map<CssUrl, DataUrl>
+     */
+    fontCssTexts: Map<string, string>;
+    /**
+     * `headers.accept` to use when `window.fetch` fetches images
+     */
+    acceptOfImage: string;
+    /**
+     * All requests for `fetch`
+     */
+    requests: Map<string, Request>;
+    /**
+     * Canvas multiple draw image fix svg+xml image decoding in Safari and Firefox
+     */
+    drawImageCount: number;
+    /**
+     * Wait for all tasks embedded in
+     */
+    tasks: Promise<void>[];
+    /**
+     * Automatically destroy context
+     */
+    autoDestruct: boolean;
+    /**
+     * Is enable
+     *
+     * @param key
+     */
+    isEnable: (key: string) => boolean;
+    /**
+     * [cloning phase] To get the node style set by the user
+     */
+    currentNodeStyle?: Map<string, [string, string]>;
+    currentParentNodeStyle?: Map<string, [string, string]>;
+    /**
+     * [cloning phase] shadowDOM root list
+     */
+    shadowRoots: ShadowRoot[];
+}
+type Context<T extends Node = Node> = InternalContext<T> & Required<Options>;
+
+declare function domToBlob<T extends Node>(node: T, options?: Options): Promise<Blob>;
+declare function domToBlob<T extends Node>(context: Context<T>): Promise<Blob>;
+
+declare function domToCanvas<T extends Node>(node: T, options?: Options): Promise<HTMLCanvasElement>;
+declare function domToCanvas<T extends Node>(context: Context<T>): Promise<HTMLCanvasElement>;
+
+declare function domToDataUrl<T extends Node>(node: T, options?: Options): Promise<string>;
+declare function domToDataUrl<T extends Node>(context: Context<T>): Promise<string>;
+
+declare function domToForeignObjectSvg<T extends Node>(node: T, options?: Options): Promise<SVGElement>;
+declare function domToForeignObjectSvg<T extends Node>(context: Context<T>): Promise<SVGElement>;
+
+declare function domToImage<T extends Node>(node: T, options?: Options): Promise<HTMLImageElement>;
+declare function domToImage<T extends Node>(context: Context<T>): Promise<HTMLImageElement>;
+
+declare function domToJpeg<T extends Node>(node: T, options?: Options): Promise<string>;
+declare function domToJpeg<T extends Node>(context: Context<T>): Promise<string>;
+
+declare function domToPixel<T extends Node>(node: T, options?: Options): Promise<Uint8ClampedArray>;
+declare function domToPixel<T extends Node>(context: Context<T>): Promise<Uint8ClampedArray>;
+
+declare function domToPng<T extends Node>(node: T, options?: Options): Promise<string>;
+declare function domToPng<T extends Node>(context: Context<T>): Promise<string>;
+
+declare function domToSvg<T extends Node>(node: T, options?: Options): Promise<string>;
+declare function domToSvg<T extends Node>(context: Context<T>): Promise<string>;
+
+declare function domToWebp<T extends Node>(node: T, options?: Options): Promise<string>;
+declare function domToWebp<T extends Node>(context: Context<T>): Promise<string>;
+
+declare function createContext<T extends Node>(node: T, options?: Options & {
+    autoDestruct?: boolean;
+}): Promise<Context<T>>;
+
+declare function destroyContext(context: Context): void;
+
+type Media = HTMLVideoElement | HTMLImageElement | SVGImageElement;
+interface LoadMediaOptions {
+    ownerDocument?: Document;
+    timeout?: number;
+    onError?: (error: Error) => void;
+    onWarn?: (...args: any[]) => void;
+}
+declare function loadMedia<T extends Media>(media: T, options?: LoadMediaOptions): Promise<T>;
+declare function loadMedia(media: string, options?: LoadMediaOptions): Promise<HTMLImageElement>;
+declare function waitUntilLoad(node: Node, options?: LoadMediaOptions): Promise<void>;
+
+export { type Context, type Options, createContext, destroyContext, domToBlob, domToCanvas, domToDataUrl, domToForeignObjectSvg, domToImage, domToJpeg, domToPixel, domToPng, domToSvg, domToWebp, loadMedia, waitUntilLoad };

websites/bitview/packages/solidjs-signals/0.4.1/dist/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/bitview/packages/solidjs-signals/0.4.1/dist/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/bitview/packages/solidjs-signals/0.4.1/dist/types/core/core.d.ts

@@ -0,0 +1,157 @@
+/**
+ * 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;
+    pureWrite?: boolean;
+    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;
+    _pureWrite: boolean;
+    /** 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/bitview/packages/solidjs-signals/0.4.1/dist/types/core/effect.d.ts

@@ -0,0 +1,37 @@
+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, cleanup: () => 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;
+    _run(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;
+    _run(): void;
+}
+export declare class FirewallComputation extends Computation {
+    firewall: boolean;
+    constructor(compute: () => void);
+    _notify(state: number, skipQueue?: boolean): void;
+    _run(): void;
+}

websites/bitview/packages/solidjs-signals/0.4.1/dist/types/core/error.d.ts

@@ -0,0 +1,8 @@
+export declare class NotReadyError extends Error {
+}
+export declare class NoOwnerError extends Error {
+    constructor();
+}
+export declare class ContextNotFoundError extends Error {
+    constructor();
+}

websites/bitview/packages/solidjs-signals/0.4.1/dist/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/bitview/packages/solidjs-signals/0.4.1/dist/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 { flush, Queue, incrementClock, getClock, type IQueue } from "./scheduler.js";
+export * from "./constants.js";
+export * from "./flags.js";

websites/bitview/packages/solidjs-signals/0.4.1/dist/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/bitview/packages/solidjs-signals/0.4.1/dist/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 `flush()`.
+ */
+export declare function flush(): void;
+export {};

websites/bitview/packages/solidjs-signals/0.4.1/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+export { Computation, ContextNotFoundError, NoOwnerError, NotReadyError, Owner, Queue, createContext, flush, getContext, setContext, hasContext, getOwner, onCleanup, getObserver, isEqual, untrack, hasUpdated, isPending, latest, runWithObserver, SUPPORTS_PROXY } from "./core/index.js";
+export type { SignalOptions, Context, ContextRecord, Disposable, IQueue } from "./core/index.js";
+export { mapArray, repeat, type Maybe } from "./map.js";
+export * from "./signals.js";
+export * from "./store/index.js";
+export { createSuspense, createErrorBoundary, createBoundary, flatten, type BoundaryMode } from "./boundaries.js";

websites/bitview/packages/solidjs-signals/0.4.1/dist/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/bitview/packages/solidjs-signals/0.4.1/dist/types/signals.d.ts

@@ -0,0 +1,182 @@
+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 type EffectBundle<Prev, Next extends Prev = Prev> = {
+    effect: EffectFunction<Prev, Next>;
+    error: (err: unknown, cleanup: () => 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
+ */
+export declare function createAsync<T>(compute: (prev: T | undefined, refreshing: boolean) => Promise<T> | AsyncIterable<T> | T, value?: T, options?: MemoOptions<T>): Accessor<T> & {
+    refresh: () => void;
+};
+/**
+ * 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> | EffectBundle<NoInfer<Next>, Next>): void;
+export declare function createEffect<Next, Init = Next>(compute: ComputeFunction<Init | Next, Next>, effect: EffectFunction<Next, Next> | EffectBundle<Next, Next>, 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
+ */
+export declare function createRenderEffect<Next>(compute: ComputeFunction<undefined | NoInfer<Next>, Next>, effect: EffectFunction<NoInfer<Next>, Next>): void;
+export declare function createRenderEffect<Next, Init = Next>(compute: ComputeFunction<Init | Next, Next>, effect: EffectFunction<Next, Next>, 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;
+/**
+ * Returns a promise of the resolved value of a reactive expression
+ * @param fn a reactive expression to resolve
+ */
+export declare function resolve<T>(fn: () => T): Promise<T>;
+/**
+ * Runs the given function and returns a tuple with the result or an error.
+ * If the function throws an error, it will be caught and returned as the first element of the tuple.
+ * If the function returns a promise, it will resolve to a tuple with the result or an error.
+ *
+ * @param fn The function to run.
+ * @returns A tuple with either [undefined, result] or [error].
+ *
+ * @description https://docs.solidjs.com/reference/reactive-utilities/try-catch
+ */
+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>;
+/**
+ * Runs the given function in a transition scope, allowing for batch updates and optimizations.
+ * This is useful for grouping multiple state updates together to avoid unnecessary re-renders.
+ *
+ * @param fn A function that receives a resume function to continue the transition.
+ * The resume function can be called with another function to continue the transition.
+ *
+ * @description https://docs.solidjs.com/reference/advanced-reactivity/transition
+ */
+export declare function transition(fn: (resume: (fn: () => any | Promise<any>) => void) => any | Promise<any>): void;
+/**
+ * Creates an optimistic signal that can be used to optimistically update a value
+ * and then revert it back to the previous value at end of transition.
+ *
+ * @param initial The initial value of the signal.
+ * @param compute An optional function to compute the next value based on the previous value and change.
+ * @param options Optional signal options.
+ *
+ * @returns A tuple containing an accessor for the current value and a setter function to apply changes.
+ */
+export declare function createOptimistic<T, U>(initial: T, compute?: (prev: T, change: U) => void, options?: SignalOptions<T>): [Accessor<T>, (v: U) => void];

websites/bitview/packages/solidjs-signals/0.4.1/dist/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 { isWrappable, createStore, deep, $TRACK, $PROXY, $TARGET } from "./store.js";
+export { createProjection } from "./projection.js";
+export { reconcile } from "./reconcile.js";
+export { snapshot, merge, omit } from "./utils.js";

websites/bitview/packages/solidjs-signals/0.4.1/dist/types/store/projection.d.ts

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

websites/bitview/packages/solidjs-signals/0.4.1/dist/types/store/reconcile.d.ts

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

websites/bitview/packages/solidjs-signals/0.4.1/dist/types/store/store.d.ts

@@ -0,0 +1,33 @@
+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>;
+export declare const $TRACK: unique symbol, $DEEP: unique symbol, $TARGET: unique symbol, $PROXY: unique symbol, $DELETED: unique symbol;
+export declare const STORE_VALUE = "v", STORE_OVERRIDE = "o", STORE_NODE = "n", STORE_HAS = "h", STORE_WRAP = "w", STORE_LOOKUP = "l";
+export type StoreNode = {
+    [$PROXY]: any;
+    [STORE_VALUE]: Record<PropertyKey, any>;
+    [STORE_OVERRIDE]?: Record<PropertyKey, any>;
+    [STORE_NODE]?: DataNodes;
+    [STORE_HAS]?: DataNodes;
+    [STORE_WRAP]?: (value: any, target?: StoreNode) => any;
+    [STORE_LOOKUP]?: WeakMap<any, any>;
+};
+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 createStoreProxy<T extends object>(value: T, traps?: ProxyHandler<StoreNode>, extend?: Record<PropertyKey, any>): any;
+export declare const storeLookup: WeakMap<object, any>;
+export declare function wrap<T extends Record<PropertyKey, any>>(value: T, target?: StoreNode): T;
+export declare function isWrappable<T>(obj: T | NotWrappable): obj is T;
+export declare function getKeys(source: Record<PropertyKey, any>, override: Record<PropertyKey, any> | undefined, enumerable?: boolean): PropertyKey[];
+export declare function getPropertyDescriptor(source: Record<PropertyKey, any>, override: Record<PropertyKey, any> | undefined, property: PropertyKey): PropertyDescriptor | undefined;
+export declare const storeTraps: ProxyHandler<StoreNode>;
+export declare function storeSetter<T extends object>(store: Store<T>, fn: (draft: T) => void): void;
+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>;
+export {};

websites/bitview/packages/solidjs-signals/0.4.1/dist/types/store/utils.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Returns a non reactive copy of the store object.
+ * It will attempt to preserver the original reference unless the value has been modified.
+ * @param item store proxy object
+ */
+export declare function snapshot<T>(item: T): T;
+export declare function snapshot<T>(item: T, map?: Map<unknown, unknown>, lookup?: WeakMap<any, any>): T;
+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/bitview/scripts/chart.js

@@ -174,12 +174,12 @@ export function init({
 
   const { field: topUnitField, selected: topUnit } =
     utils.dom.createHorizontalChoiceField({
-      defaultValue: "USD",
+      defaultValue: "usd",
       keyPrefix,
       key: "unit-0",
       choices: /** @type {const} */ ([
-        /** @satisfies {Unit} */ ("USD"),
-        /** @satisfies {Unit} */ ("Sats"),
+        /** @satisfies {Unit} */ ("usd"),
+        /** @satisfies {Unit} */ ("sats"),
       ]),
       signals,
       sorted: true,
@@ -210,7 +210,7 @@ export function init({
 
     const latest = { ..._latest };
 
-    if (unit === "Sats") {
+    if (unit === "sats") {
       latest.open = Math.floor(ONE_BTC_IN_SATS / latest.open);
       latest.high = Math.floor(ONE_BTC_IN_SATS / latest.high);
       latest.low = Math.floor(ONE_BTC_IN_SATS / latest.low);
@@ -332,7 +332,7 @@ export function init({
           console.log({ topUnit, topSeriesType });
 
           switch (topUnit) {
-            case "USD": {
+            case "usd": {
               switch (topSeriesType) {
                 case null:
                 case CANDLE: {
@@ -362,7 +362,7 @@ export function init({
               }
               break;
             }
-            case "Sats": {
+            case "sats": {
               switch (topSeriesType) {
                 case null:
                 case CANDLE: {

websites/bitview/scripts/simulation.js

@@ -691,7 +691,7 @@ export function init({
     elements,
     config: [
       {
-        unit: "USD",
+        unit: "usd",
         blueprints: [
           {
             title: "Bitcoin Value",
@@ -736,7 +736,7 @@ export function init({
     utils,
     config: [
       {
-        unit: "BTC",
+        unit: "btc",
         blueprints: [
           {
             title: "Bitcoin Stack",
@@ -761,7 +761,7 @@ export function init({
     elements,
     config: [
       {
-        unit: "USD",
+        unit: "usd",
         blueprints: [
           {
             title: "Bitcoin Price",
@@ -792,7 +792,7 @@ export function init({
     elements,
     config: [
       {
-        unit: "USD",
+        unit: "usd",
         blueprints: [
           {
             title: "Return Of Investment",

websites/bitview/scripts/table.js

@@ -141,7 +141,7 @@ function createTable({
         list: serializedIndexes,
         signal: serializedIndex,
       }),
-      unit: "Index",
+      unit: "index",
     });
 
     let from = 0;
@@ -163,7 +163,7 @@ function createTable({
           const th = window.document.createElement("th");
           th.innerHTML = serializeValue({
             value,
-            unit: "Index",
+            unit: "index",
           });
           th.scope = "row";
           tr.append(th);
@@ -527,12 +527,12 @@ function serializeValue({ value, unit }) {
   } else if (t !== "number") {
     return JSON.stringify(value).replaceAll('"', "").slice(1, -1);
   } else if (value !== 18446744073709552000) {
-    if (unit === "USD" || unit === "Difficulty" || unit === "sat/vB") {
+    if (unit === "usd" || unit === "difficulty" || unit === "sat/vb") {
       return value.toLocaleString("en-us", {
         minimumFractionDigits: 2,
         maximumFractionDigits: 2,
       });
-    } else if (unit === "BTC") {
+    } else if (unit === "btc") {
       return value.toLocaleString("en-us", {
         minimumFractionDigits: 8,
         maximumFractionDigits: 8,