global: snapshot

website/libraries/lean-qr/README.md

@@ -0,0 +1,3 @@
+URL + Version:
+
+https://unpkg.com/browse/lightweight-charts@4.2.0/

website/libraries/lean-qr/types.d.ts

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

website/libraries/lightweight-charts/NOTICE.md

@@ -0,0 +1,2 @@
+TradingView Lightweight Charts™
+Copyright (с) 2023 TradingView, Inc. https://www.tradingview.com/

website/libraries/lightweight-charts/README.md

@@ -0,0 +1,6 @@
+URL:
+https://github.com/leeoniya/ufuzzy/tree/main/dist
+
+Head:
+- SHA: 6bb27a8d8c41e4be5458844afc5c89f6c2399512
+- Date:  Feb 21, 2024

website/libraries/solid-signals/README.md

@@ -0,0 +1,5 @@
+Compiled version of: https://github.com/solidjs/signals
+
+Head:
+- SHA: 4d75d3f84ce22b560988f3b27a5065c0fd2e69a8
+- Date: Apr 17, 2024

website/libraries/solid-signals/types/constants.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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;

website/libraries/solid-signals/types/core.d.ts

@@ -0,0 +1,143 @@
+/**
+ * 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';
+import { Owner } from './owner';
+export interface SignalOptions<T> {
+    name?: string;
+    equals?: ((prev: T, next: T) => boolean) | false;
+}
+export interface MemoOptions<T> extends SignalOptions<T> {
+    initial?: T;
+}
+interface SourceType {
+    _observers: ObserverType[] | null;
+    _updateIfNecessary: () => void;
+    _stateFlags: Flags;
+}
+interface ObserverType {
+    _sources: SourceType[] | null;
+    _notify: (state: number) => void;
+    _handlerMask: Flags;
+    _notifyFlags: (mask: Flags, newFlags: Flags) => void;
+}
+/**
+ * Returns the current observer.
+ */
+export declare function getObserver(): ObserverType | 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;
+    _compute: null | (() => T);
+    _name: string | undefined;
+    _equals: false | ((a: T, b: T) => 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;
+    _error: Computation<boolean> | null;
+    _loading: Computation<boolean> | null;
+    constructor(initialValue: T | undefined, compute: null | (() => T), options?: MemoOptions<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;
+    /**
+     * Return true if the computation is the value is dependent on an unresolved promise
+     * Triggers re-execution of the computation when the loading state changes
+     *
+     * This is useful especially when effects want to re-execute when a computation's
+     * loading state changes
+     */
+    loading(): boolean;
+    /**
+     * Return true if the computation is the computation threw an error
+     * Triggers re-execution of the computation when the error state changes
+     */
+    error(): boolean;
+    /** 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): 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;
+/**
+ * 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, compute: (val: T) => T, observer: Computation<T>): T;
+export declare function compute<T>(owner: Owner | null, compute: (val: undefined) => T, observer: null): T;
+export {};

website/libraries/solid-signals/types/effect.d.ts

@@ -0,0 +1,25 @@
+import { Computation, type MemoOptions } from './core';
+/**
+ * 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;
+/**
+ * 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> {
+    constructor(initialValue: T, compute: () => T, options?: MemoOptions<T>);
+    _notify(state: number): void;
+    write(value: T): T;
+    _setError(error: unknown): void;
+}
+export declare class RenderEffect<T = any> extends Computation<T> {
+    effect: (val: T) => void;
+    modified: boolean;
+    constructor(initialValue: T, compute: () => T, effect: (val: T) => void, options?: MemoOptions<T>);
+    _notify(state: number): void;
+    write(value: T): T;
+    _setError(error: unknown): void;
+}

website/libraries/solid-signals/types/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 interface ErrorHandler {
+    (error: unknown): void;
+}

website/libraries/solid-signals/types/flags.d.ts

@@ -0,0 +1,8 @@
+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 DEFAULT_FLAGS: number;

website/libraries/solid-signals/types/index.d.ts

@@ -0,0 +1,8 @@
+export { ContextNotFoundError, NoOwnerError, NotReadyError, type ErrorHandler, } from './error';
+export { Owner, createContext, getContext, setContext, hasContext, getOwner, setOwner, onCleanup, type Context, type ContextRecord, type Disposable, } from './owner';
+export { Computation, compute, getObserver, isEqual, untrack, type MemoOptions, type SignalOptions, } from './core';
+export { flushSync, Effect, RenderEffect } from './effect';
+export { indexArray, mapArray, type Maybe } from './map';
+export { createSelector, type SelectorOptions, type SelectorSignal, } from './selector';
+export * from './signals';
+export * from './store';

website/libraries/solid-signals/types/map.d.ts

@@ -0,0 +1,26 @@
+import type { Accessor } from './signals';
+export type Maybe<T> = T | void | null | undefined | false;
+/**
+ * Reactive map helper that caches each item by index to reduce unnecessary mapping on updates.
+ * It only runs the mapping function once per item and adds/removes as needed. In a non-keyed map
+ * like this the index is fixed but value can change (opposite of a keyed map).
+ *
+ * Prefer `mapArray` when referential checks are required.
+ *
+ * @see {@link https://github.com/solidjs/x-reactivity#indexarray}
+ */
+export declare function indexArray<Item, MappedItem>(list: Accessor<Maybe<readonly Item[]>>, map: (value: Accessor<Item>, index: number) => MappedItem, options?: {
+    name?: string;
+}): Accessor<MappedItem[]>;
+/**
+ * Reactive map helper that caches each list item by reference to reduce unnecessary mapping on
+ * updates. It only runs the mapping function once per item and then moves or removes it as needed.
+ * In a keyed map like this the value is fixed but the index changes (opposite of non-keyed map).
+ *
+ * Prefer `indexArray` when working with primitives to avoid unnecessary re-renders.
+ *
+ * @see {@link https://github.com/solidjs/x-reactivity#maparray}
+ */
+export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly Item[]>>, map: (value: Item, index: Accessor<number>) => MappedItem, options?: {
+    name?: string;
+}): Accessor<MappedItem[]>;

website/libraries/solid-signals/types/owner.d.ts

@@ -0,0 +1,88 @@
+/**
+ * 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 ErrorHandler } from './error';
+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;
+    _handlers: ErrorHandler[] | null;
+    constructor(signal?: boolean);
+    append(child: Owner): void;
+    dispose(this: Owner, self?: boolean): void;
+    _disposeNode(): void;
+    emptyDisposal(): void;
+    handleError(error: unknown): void;
+}
+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 the given function when the parent owner computation is being disposed.
+ */
+export declare function onCleanup(disposable: Disposable): void;

website/libraries/solid-signals/types/selector.d.ts

@@ -0,0 +1,15 @@
+import type { Accessor } from './signals';
+export interface SelectorSignal<T> {
+    (key: T): Boolean;
+}
+export interface SelectorOptions<Key, Value> {
+    name?: string;
+    equals?: (key: Key, value: Value | undefined) => boolean;
+}
+/**
+ * Creates a signal that observes the given `source` and returns a new signal who only notifies
+ * observers when entering or exiting a specified key.
+ *
+ * @see {@link https://github.com/solidjs/x-reactivity#createselector}
+ */
+export declare function createSelector<Source, Key = Source>(source: Accessor<Source>, options?: SelectorOptions<Key, Source>): SelectorSignal<Key>;

website/libraries/solid-signals/types/signals.d.ts

@@ -0,0 +1,55 @@
+import type { MemoOptions, SignalOptions } from './core';
+import { Owner } from './owner';
+export interface Accessor<T> {
+    (): T;
+}
+export interface Setter<T> {
+    (value: T | SetValue<T>): T;
+}
+export interface SetValue<T> {
+    (currentValue: T): T;
+}
+export type Signal<T> = [read: Accessor<T>, write: Setter<T>];
+/**
+ * Wraps the given value into a signal. The signal will return the current value when invoked
+ * `fn()`, and provide a simple write API via `write()`. The value can now be observed
+ * when used inside other computations created with `computed` and `effect`.
+ */
+export declare function createSignal<T>(initialValue: T, options?: SignalOptions<T>): Signal<T>;
+export declare function createAsync<T>(fn: () => Promise<T>, initial?: T, options?: SignalOptions<T>): Accessor<T>;
+/**
+ * Creates a new computation whose value is computed and returned by the given function. The given
+ * compute function is _only_ re-run when one of it's dependencies are updated. Dependencies are
+ * are all signals that are read during execution.
+ */
+export declare function createMemo<T>(compute: () => T, initialValue?: T, options?: MemoOptions<T>): Accessor<T>;
+/**
+ * Invokes the given function each time any of the signals that are read inside are updated
+ * (i.e., their value changes). The effect is immediately invoked on initialization.
+ */
+export declare function createEffect<T>(effect: () => T, initialValue?: T, options?: {
+    name?: string;
+}): void;
+/**
+ * Invokes the given function each time any of the signals that are read inside are updated
+ * (i.e., their value changes). The effect is immediately invoked on initialization.
+ */
+export declare function createRenderEffect<T>(compute: () => T, effect: (v: T) => T, initialValue?: T, options?: {
+    name?: string;
+}): void;
+/**
+ * Creates a computation root which is given a `dispose()` function to dispose of all inner
+ * computations.
+ */
+export declare function createRoot<T>(init: ((dispose: () => void) => T) | (() => T)): T;
+/**
+ * Runs the given function in the given owner so that error handling and cleanups continue to work.
+ *
+ * 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 | undefined;
+/**
+ * Runs the given function when an error is thrown in a child owner. If the error is thrown again
+ * inside the error handler, it will trigger the next available parent owner handler.
+ */
+export declare function catchError<T>(fn: () => T, handler: (error: unknown) => void): void;

website/libraries/solid-signals/types/store.d.ts

@@ -0,0 +1,22 @@
+export type Store<T> = Readonly<T>;
+export type StoreSetter<T> = (fn: (state: T) => void) => void;
+export type StoreNode = Record<PropertyKey, 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 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, set?: Set<unknown>): T;
+export declare function createStore<T extends object = {}>(store: T | Store<T>): [get: Store<T>, set: StoreSetter<T>];

website/libraries/solid-signals/types/utils.d.ts

@@ -0,0 +1 @@
+export declare function isUndefined(value: any): value is undefined;

website/libraries/ufuzzy/README.md

@@ -0,0 +1,3 @@
+URL + Version:
+
+https://unpkg.com/browse/lean-qr@2.3.4/

website/libraries/ufuzzy/types.d.ts

@@ -0,0 +1,196 @@
+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): 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];
+
+  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?
+
+    sort?: (info: Info, haystack: string[], needle: string) => 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[];
+
+    /** offset ranges within match for highlighting: [startIdx0, endIdx0, startIdx1, endIdx1,...] */
+    ranges: number[][];
+  }
+}
+
+export as namespace uFuzzy;