bruh 1.13.0 → 2.0.0-beta.1

package/dist/types/components/optimized-picture/hydrate.d.mts

@@ -0,0 +1,2 @@
+declare const hydrateOptimizedPictures: (className?: string) => void;
+export default hydrateOptimizedPictures;

package/dist/types/components/optimized-picture/server.d.ts

@@ -0,0 +1,8 @@
+declare const OptimizedPicture: (options: {
+    src: string;
+    alt?: string;
+    width?: number;
+    height?: number;
+    loading?: "lazy" | "eager";
+}) => Promise<any>;
+export default OptimizedPicture;

package/dist/types/components/utils.d.mts

@@ -0,0 +1,5 @@
+export declare const spaceSeparated: {
+    (s: string): string[];
+    (s?: null): undefined;
+    (s?: string | null): string[] | undefined;
+};

package/dist/types/dom/browser/jsx-runtime.d.mts

@@ -0,0 +1,3 @@
+import { jsx, Fragment } from '../index.browser.mts';
+export { jsx, jsx as jsxs, jsx as jsxDEV, Fragment };
+export type { JSX } from '../index.browser.mts';

package/dist/types/dom/index.browser.d.mts

@@ -0,0 +1,127 @@
+import { Reactive, MaybeReactive } from '../reactive/index.mts';
+import { PropertyWiseOr, LikelyAsString, LikelyAsAbsent, LikelyAsBoolean } from './types.mts';
+import { PropertiesHyphen as Styles } from 'csstype';
+import { ElementType, HTMLTag, SVGTag, MathMLTag, Namespace, HTMLNamespace, SVGNamespace, MathMLNamespace, ElementToEventMap, ElementToAttributes } from 'html-info';
+export type TerminalBruhChild = Node | LikelyAsString | LikelyAsAbsent;
+export type TerminalBruhChildOutputNode<Child extends TerminalBruhChild> = Child extends Node ? Child : Child extends LikelyAsString ? Text : Child extends LikelyAsAbsent ? Comment : Node;
+export type FlatBruhChild = MaybeReactive<TerminalBruhChild> | Reactive<TerminalBruhChild | Iterable<BruhChild>>;
+export type BruhChild = FlatBruhChild | Iterable<BruhChild>;
+export type StylesToApply = {
+    [Property in keyof Styles]: MaybeReactive<Styles[Property] | LikelyAsAbsent>;
+};
+export interface ClassesToApply {
+    [className: string]: MaybeReactive<LikelyAsBoolean>;
+}
+export type AttributesToApply<Name extends string, NS extends Namespace = HTMLNamespace> = {
+    [Attribute in keyof ElementToAttributes<Name, NS>]?: MaybeReactive<ElementToAttributes<Name, NS>[Attribute] | LikelyAsBoolean>;
+};
+type EventMapToListenerProps<EventMap> = {
+    [E in ((keyof EventMap) & string) as `on${E}`]: (event: EventMap[E]) => void;
+};
+type AttributeMapToProps<AttributeMap> = {
+    [Attribute in keyof AttributeMap]: MaybeReactive<AttributeMap[Attribute] | LikelyAsBoolean> | (Attribute extends "style" ? StylesToApply : Attribute extends "class" ? ClassesToApply : never);
+};
+export interface BruhOptions {
+    namespace?: Namespace;
+}
+interface BaseBruhProps {
+    bruh?: BruhOptions;
+    children?: BruhChild;
+}
+export type BruhProps<Name extends string, NS extends string = HTMLNamespace> = BaseBruhProps & (NS extends HTMLNamespace ? {
+    bruh?: {
+        namespace?: HTMLNamespace;
+    };
+} : {
+    bruh: {
+        namespace: NS;
+    };
+}) & Partial<EventMapToListenerProps<ElementToEventMap<Name, NS>> & AttributeMapToProps<ElementToAttributes<Name, NS>>>;
+export type HTMLTagToBruhProps = {
+    [Name in HTMLTag]: BruhProps<Name, HTMLNamespace>;
+};
+export type SVGTagToBruhProps = {
+    [Name in SVGTag]: BruhProps<Name, SVGNamespace>;
+};
+export type MathMLTagToBruhProps = {
+    [Name in MathMLTag]: BruhProps<Name, MathMLNamespace>;
+};
+export type TagToBruhProps = PropertyWiseOr<HTMLTagToBruhProps, PropertyWiseOr<SVGTagToBruhProps, MathMLTagToBruhProps>>;
+export declare namespace JSX {
+    /** @see https://www.typescriptlang.org/docs/handbook/jsx.html#children-type-checking */
+    interface ElementChildrenAttribute {
+        children: {};
+    }
+    /** @see https://www.typescriptlang.org/docs/handbook/jsx.html#attribute-type-checking */
+    interface IntrinsicElements extends TagToBruhProps {
+    }
+    type Element = any;
+    type ElementType = HTMLTag | SVGTag | MathMLTag | ((props: any) => Element);
+}
+export declare function bruhChildrenToNodes(children: Iterable<BruhChild>): IterableIterator<Node>;
+type ElementWithStyle = HTMLElement | SVGElement | MathMLElement;
+/**
+ * Style attribute rules from an object with
+ * potentially reactive and/or set as absent values
+ */
+export declare const applyStyles: <E extends ElementWithStyle>(element: E, styles: StylesToApply) => void;
+/**
+ * Class list from an object mapping from
+ * class names to potentially reactive booleans
+ */
+export declare const applyClasses: (element: Element, classes: ClassesToApply) => void;
+/**
+ * Attributes from an object with
+ * potentially reactive and/or set as absent values
+ */
+export declare const applyAttributes: <Name extends string, NS extends Namespace = HTMLNamespace>(element: ElementType<Name, NS>, attributes: AttributesToApply<Name, NS>) => void;
+export declare const t: (textContent: MaybeReactive<LikelyAsString>) => Text;
+declare global {
+    interface String {
+        startsWith<Prefix extends string>(prefix: Prefix, position?: 0): this is `${Prefix}${string}`;
+    }
+}
+export declare const jsx: {
+    /**
+     * Create an HTML element
+     */
+    <Name extends HTMLTag>(name: Name, props: HTMLTagToBruhProps[Name], key?: string): HTMLElementTagNameMap[Name];
+    /**
+     * Create an SVG element
+     */
+    <Name extends SVGTag>(name: Name, props: SVGTagToBruhProps[Name], key?: string): SVGElementTagNameMap[Name];
+    /**
+     * Create a MathML element
+     */
+    <Name extends MathMLTag>(name: Name, props: MathMLTagToBruhProps[Name], key?: string): MathMLElementTagNameMap[Name];
+    /**
+     * Create an element
+     */
+    <Name extends string, NS extends Namespace = HTMLNamespace>(name: Name, props: BruhProps<Name, NS>, key?: string): ElementType<Name, NS>;
+    /**
+     * Call a function as a JSX component
+     */
+    <Props extends Record<any, unknown>, Result>(component: (props: Props) => Result, props: Props, key?: string): Result;
+};
+export declare const Fragment: <Children extends BruhChild>(props: {
+    children: Children;
+}) => Children;
+export declare class BruhText extends HTMLElement {
+    static hydrated: {
+        readonly [tag: string]: ReadonlySet<Text>;
+    };
+    constructor();
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "bruh-text": BruhText;
+    }
+}
+declare module "html-info" {
+    interface HTMLTagToAttributes {
+        "bruh-text": {
+            "tag"?: string;
+        };
+    }
+}
+export {};

package/dist/types/dom/index.server.d.mts

@@ -0,0 +1,174 @@
+import { PropertyWiseOr, MaybePromise, LikelyAsString, LikelyAsAbsent, LikelyAsBoolean } from './types.mts';
+import { PropertiesHyphen as Styles } from 'csstype';
+import { HTMLTag, SVGTag, MathMLTag, Namespace, HTMLNamespace, SVGNamespace, MathMLNamespace, ElementToEventMap, ElementToAttributes } from 'html-info';
+export type TerminalBruhChild = LikelyAsString | LikelyAsAbsent | MetaNode | MetaRawString;
+export type BruhChild = MaybePromise<TerminalBruhChild> | Promise<BruhChild> | Iterable<BruhChild> | AsyncIterable<BruhChild>;
+export type StylesToApply = {
+    [Property in keyof Styles]: MaybePromise<Styles[Property] | LikelyAsAbsent>;
+};
+export interface ClassesToApply {
+    [className: string]: MaybePromise<LikelyAsBoolean>;
+}
+export type AttributesToApply<Name extends string, NS extends Namespace = HTMLNamespace> = {
+    [Attribute in keyof ElementToAttributes<Name, NS>]?: MaybePromise<ElementToAttributes<Name, NS>[Attribute] | LikelyAsBoolean>;
+};
+type EventMapToListenerProps<EventMap> = {
+    [E in ((keyof EventMap) & string) as `on${E}`]: string;
+};
+type AttributeMapToProps<AttributeMap> = {
+    [Attribute in keyof AttributeMap]: MaybePromise<AttributeMap[Attribute] | LikelyAsBoolean> | (Attribute extends "style" ? StylesToApply : Attribute extends "class" ? ClassesToApply : never);
+};
+export interface BruhOptions {
+    namespace?: Namespace;
+}
+interface BaseBruhProps {
+    bruh?: BruhOptions;
+    children?: BruhChild;
+}
+export type BruhProps<Name extends string, NS extends string = HTMLNamespace> = BaseBruhProps & (NS extends HTMLNamespace ? {
+    bruh?: {
+        namespace?: HTMLNamespace;
+    };
+} : {
+    bruh: {
+        namespace: NS;
+    };
+}) & Partial<EventMapToListenerProps<ElementToEventMap<Name, NS>> & AttributeMapToProps<ElementToAttributes<Name, NS>>>;
+export type HTMLTagToBruhProps = {
+    [Name in HTMLTag]: BruhProps<Name, HTMLNamespace>;
+};
+export type SVGTagToBruhProps = {
+    [Name in SVGTag]: BruhProps<Name, SVGNamespace>;
+};
+export type MathMLTagToBruhProps = {
+    [Name in MathMLTag]: BruhProps<Name, MathMLNamespace>;
+};
+export type TagToBruhProps = PropertyWiseOr<HTMLTagToBruhProps, PropertyWiseOr<SVGTagToBruhProps, MathMLTagToBruhProps>>;
+export declare namespace JSX {
+    /** @see https://www.typescriptlang.org/docs/handbook/jsx.html#children-type-checking */
+    interface ElementChildrenAttribute {
+        children: {};
+    }
+    /** @see https://www.typescriptlang.org/docs/handbook/jsx.html#attribute-type-checking */
+    interface IntrinsicElements extends TagToBruhProps {
+    }
+    type Element = any;
+    type ElementType = HTMLTag | SVGTag | MathMLTag | ((props: any) => Element);
+}
+declare const isMetaNode: unique symbol;
+declare const isMetaTextNode: unique symbol;
+declare const isMetaElement: unique symbol;
+declare const isMetaRawString: unique symbol;
+type MetaNode = MetaTextNode | MetaElement<string, Namespace>;
+export declare class MetaTextNode {
+    [isMetaNode]: boolean;
+    [isMetaTextNode]: boolean;
+    textContent: MaybePromise<LikelyAsString>;
+    tag?: string;
+    constructor(textContent: MaybePromise<LikelyAsString>);
+    [Symbol.iterator](): IterableIterator<string>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<string>;
+    toString(): string;
+    toStringPromise(): Promise<string>;
+    setTag(tag: string): this;
+}
+export declare class MetaElement<Name extends string, NS extends Namespace = HTMLNamespace> {
+    #private;
+    [isMetaNode]: boolean;
+    [isMetaElement]: boolean;
+    name: Name;
+    attributes: AttributesToApply<Name, NS>;
+    children: Array<BruhChild>;
+    constructor(name: Name);
+    [Symbol.iterator](): IterableIterator<string>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<string>;
+    toString(): string;
+    toStringPromise(): Promise<string>;
+}
+export declare class MetaRawString extends String {
+    [isMetaRawString]: boolean;
+    constructor(string: LikelyAsString);
+}
+type ElementWithStyle = MetaElement<string, HTMLNamespace | SVGNamespace | MathMLNamespace>;
+export declare const applyStyles: (element: ElementWithStyle, styles: StylesToApply) => void;
+export declare const applyClasses: (element: MetaElement<string, Namespace>, classes: ClassesToApply) => void;
+export declare const applyAttributes: <Name extends string, NS extends Namespace = HTMLNamespace>(element: MetaElement<Name, NS>, attributes: AttributesToApply<Name, NS>) => void;
+export declare const rawString: (string: LikelyAsString) => MetaRawString;
+export declare const t: (textContent: MaybePromise<LikelyAsString>) => MetaTextNode;
+export declare const jsx: {
+    /**
+     * Create an HTML element
+     */
+    <Name extends HTMLTag>(name: Name, props: HTMLTagToBruhProps[Name], key?: string): MetaElement<Name, HTMLNamespace>;
+    /**
+     * Create an SVG element
+     */
+    <Name extends SVGTag>(name: Name, props: SVGTagToBruhProps[Name], key?: string): MetaElement<Name, SVGNamespace>;
+    /**
+     * Create a MathML element
+     */
+    <Name extends MathMLTag>(name: Name, props: MathMLTagToBruhProps[Name], key?: string): MetaElement<Name, MathMLNamespace>;
+    /**
+     * Create an element
+     */
+    <Name extends string, NS extends Namespace = HTMLNamespace>(name: Name, props: BruhProps<Name, NS>, key?: string): MetaElement<Name, NS>;
+    /**
+     * Call a function as a JSX component
+     */
+    <Props extends Record<any, unknown>, Result>(component: (props: Props) => Result, props: Props, key?: string): Result;
+};
+export declare const Fragment: <Children extends BruhChild>(props: {
+    children: Children;
+}) => Children;
+declare global {
+    interface HTMLElementTagNameMap {
+        "bruh-deferred": HTMLElement;
+    }
+}
+declare module "html-info" {
+    interface HTMLTagToAttributes {
+        "bruh-deferred": {
+            "data-replace": `bruh-deferred-${number}`;
+        };
+    }
+}
+export declare const replaceDeferredScriptContent: string;
+/**
+ * "Content-Security-Policy": `script-src '${replaceDeferredHash}'`
+ */
+export declare const replaceDeferredHash = "sha512-+xpsela6B2jMNhk2cPpAgB4Z89EeB6yltQ208+kvcbUKlkg11dBjAlj2FbNFxeE0kqOuZhdVVldl3hz1yZD38Q==";
+type MetaDocumentDeferFunction = <P extends BruhChild>(context: {
+    placeholder: (id: `bruh-deferred-${number}`) => P;
+    content: Promise<BruhChild>;
+}) => P;
+type MetaDocumentDisabledDeferFunction = (context: {
+    content: Promise<BruhChild>;
+}) => Promise<BruhChild>;
+type MetaDocumentFunction = (context: {
+    defer: MetaDocumentDeferFunction;
+    deferred: AsyncIterableIterator<MetaElement<"template" | "bruh-deferred">>;
+    replaceDeferredScript: MetaElement<"script">;
+} | {
+    defer: MetaDocumentDisabledDeferFunction;
+    deferred?: undefined;
+    replaceDeferredScript?: undefined;
+}) => MetaElement<string>;
+export declare class MetaDocument {
+    #private;
+    constructor(metaElementOrFunction: MetaElement<string> | MetaDocumentFunction);
+    [Symbol.iterator](): IterableIterator<string>;
+    [Symbol.asyncIterator]({ deferred: allowDefer }?: {
+        deferred?: boolean | undefined;
+    }): AsyncIterableIterator<string>;
+    toStream({ deferred }?: {
+        deferred?: boolean | undefined;
+    }): ReadableStream<Uint8Array>;
+    toResponse({ deferred }?: {
+        deferred?: boolean | undefined;
+    }): Response;
+    toString(): string;
+    toStringPromise({ deferred }?: {
+        deferred?: boolean | undefined;
+    }): Promise<string>;
+}
+export {};

package/dist/types/dom/server/jsx-runtime.d.mts

@@ -0,0 +1,3 @@
+import { jsx, Fragment } from '../index.server.mts';
+export { jsx, jsx as jsxs, jsx as jsxDEV, Fragment };
+export type { JSX } from '../index.server.mts';

package/dist/types/dom/types.d.mts

@@ -0,0 +1,9 @@
+export type PropertyWiseOr<A extends {}, B extends {}> = {
+    [K in keyof (A & B)]: K extends keyof (A | B) ? (A | B)[K] : K extends keyof A ? A[K] : K extends keyof B ? B[K] : never;
+};
+export type MaybePromise<T> = T | Promise<T>;
+export type LikelyAsString = string | number | bigint;
+/** Like `LikelyAsBoolean`, but `true` is treated as a missing value */
+export type LikelyAsAbsent = null | undefined | boolean;
+/** Like `LikelyAsAbsent`, but `true` is not treated as a missing value */
+export type LikelyAsBoolean = boolean | null | undefined;

package/dist/types/media/images.node.d.mts

@@ -0,0 +1 @@
+export declare const processImages: (directory: string) => Promise<void>;

package/dist/types/polyfills/weakref.d.mts

@@ -0,0 +1,4 @@
+/**
+ * Was unsupported in safari until spring 2021
+ */
+export declare const weakRefPolyfill: () => void;

package/dist/types/reactive/index.d.mts

@@ -0,0 +1,91 @@
+export declare const isReactiveSymbol: unique symbol;
+export declare const isReactive: (x: unknown) => x is Reactive<unknown>;
+type Reaction = () => void;
+type StopReacting = () => void;
+export interface Reactive<T> {
+    [isReactiveSymbol]: true;
+    value: T;
+    addReaction(reaction: Reaction): StopReacting;
+}
+export type Unreactive<T> = Exclude<T, {
+    [isReactiveSymbol]: true;
+}>;
+export type MaybeReactive<T> = Reactive<T> | Unreactive<T>;
+/**
+ * A super simple and performant reactive value implementation
+ */
+export declare class SimpleReactive<T> implements Reactive<T> {
+    #private;
+    [isReactiveSymbol]: true;
+    constructor(value: T);
+    get value(): T;
+    set value(newValue: T);
+    /**
+     * @param reaction called every time that the value changes
+     * @returns a function that stops the reactions
+     */
+    addReaction(reaction: Reaction): () => boolean;
+}
+export type SourceNode<T> = FunctionalReactive<T, "source">;
+export type DerivativeNode<T> = FunctionalReactive<T, "derivative">;
+/**
+ * A reactive implementation for building functional reactive graphs.
+ * Ensures state consistency, minimal node updates, and transparent update batching.
+ */
+export declare class FunctionalReactive<T, U extends "source" | "derivative" = any> implements Reactive<T> {
+    #private;
+    [isReactiveSymbol]: true;
+    constructor(value: T);
+    constructor(dependencies: ReadonlyArray<FunctionalReactive<unknown>>, f: () => T);
+    get value(): T;
+    set value(newValue: T);
+    /**
+     * @param reaction called every time that the value changes
+     * @returns a function that stops the reactions
+     */
+    addReaction(reaction: Reaction): () => boolean;
+    /**
+     * Apply pending updates from actually changed source nodes
+     */
+    static applyUpdates(): void;
+}
+type R = {
+    /**
+     * An initially undefined source node
+     */
+    <T>(): SourceNode<T | undefined>;
+    /**
+     * A source node
+     */
+    <T>(value: T): SourceNode<T>;
+    /**
+     * A derived node
+     */
+    <T>(dependencies: ReadonlyArray<FunctionalReactive<unknown>>, f: () => T): DerivativeNode<T>;
+};
+/**
+ * A convenient wrapper for FunctionalReactive
+ */
+export declare const r: R;
+type ReactiveDo = {
+    /**
+     * Calls the given function with the reactive's value whenever it changes
+     * @returns a function that stops the reactions
+     */
+    <T>(reactive: Reactive<T>, f: (value: T) => unknown): StopReacting;
+    /**
+     * Calls the given function with the value once
+     */
+    <T>(value: Unreactive<T>, f: (value: Unreactive<T>) => unknown): undefined;
+    /**
+     * If the value is not reactive, it calls the given function with that value once.
+     * If it is a reactive value, it calls the given function with the reactive's value whenever it changes.
+     * @returns a function that stops the reactions, if the value is reactive
+     */
+    <T>(x: MaybeReactive<T>, f: (value: T) => unknown): StopReacting | undefined;
+};
+/**
+ * Do something with a value, updating if it is reactive
+ */
+export declare const reactiveDo: ReactiveDo;
+export {};

package/dist/types/reactive/sync/transport/websocket/browser.d.mts

@@ -0,0 +1,11 @@
+import { MaybeReactive } from '../../../../reactive/index.mts';
+export declare const resolveWebSocketURL: (url?: URL | string) => URL;
+export declare const connectToWebSocket: (url: URL | string, initialReconnectDelay?: number, // 1/4 second
+reconnectDelayCeiling?: number) => import('../../../../reactive/index.mts').SourceNode<WebSocket | undefined>;
+export type WebSocketHandlers = {
+    raw?: (data: Blob | ArrayBuffer) => void;
+    byType?: {
+        [type: string]: (data: any) => void;
+    };
+};
+export declare const handleWebSocket: (maybeReactiveWebSocket: MaybeReactive<WebSocket | undefined>, handlers: WebSocketHandlers) => (data: unknown) => void;

package/dist/types/utils/browser.d.mts

@@ -0,0 +1,2 @@
+import { SourceNode } from '../reactive/index.mts';
+export declare const currentUrl: SourceNode<URL>;

package/dist/types/utils/index.d.mts

@@ -0,0 +1,122 @@
+import { LikelyAsString } from '../dom/types.mts';
+/**
+ * Dispatch a custom event to (capturing) and from (bubbling) a target (usually a DOM node).
+ * Returns false if the event was cancelled (preventDefault()) and true otherwise.
+ *
+ * Note that this is synchronous
+ */
+export declare const dispatch: (target: EventTarget, type: string, detail: unknown, options: CustomEventInit) => boolean;
+/**
+ * Inspired by https://antfu.me/posts/destructuring-with-object-or-array#take-away
+ *
+ * Creates an object that is both destructable with {...} and [...]
+ *
+ * Useful for writing library functions à la react-use & vueuse
+ *
+ * @example
+ * ```typescript
+ * const useExample = () => {
+ *   const a = "a"
+ *   const b = "b"
+ *   return createDestructable(
+ *     { a, b },
+ *     [ a, b ]
+ *   )
+ * }
+ *
+ * const { a, b } = useExample()
+ * // or
+ * const [ a, b ] = useExample()
+ * ```
+ */
+export declare const createDestructable: <const T extends {}, const U extends Iterable<unknown>>(object: T, iterable: U) => T & U;
+/**
+ * Creates an object (as a Proxy) that acts as a function
+ *
+ * So functionAsObject(f).property is equivalent to f("property")
+ *
+ * This is can be useful when combined with destructuring syntax
+ *
+ * @example
+ * ```typescript
+ * const { html, head, title, body, main, h1, p } = functionAsObject(e)
+ * ```
+ */
+export declare const functionAsObject: <T extends {
+    [input: PropertyKey]: any;
+}>(f: <K extends keyof T>(property: K) => T[K]) => T;
+export declare const pick: <T, K extends keyof T>(t: T, ...keys: ReadonlyArray<K>) => Pick<T, K>;
+export declare const omit: <T, K extends keyof T>(t: T, ...keys: ReadonlyArray<K>) => Omit<T, K>;
+export declare const mapObject: <const O extends {}, const K extends keyof O, const V extends O[K], const RK extends PropertyKey, const RV>(o: O, f: ([k, v]: [K, V]) => [RK, RV]) => { [Entry in { [Key in keyof O]: [RK, RV]; }[keyof O] as Entry[0]]: Entry[1]; };
+export type InvertObject<O extends Record<PropertyKey, PropertyKey>> = {
+    [Entry in {
+        [Key in keyof O]: [O[Key], Key];
+    }[keyof O] as Entry[0]]: Entry[1];
+};
+export declare const invertObject: <const O extends Record<PropertyKey, PropertyKey>>(o: O) => InvertObject<O>;
+export declare const camelToDashCase: (s: string) => string;
+export declare const dashToCamelCase: (s: string) => string;
+export declare const unique: <T, K>(values: Iterable<T>, getKey?: (value: T) => K) => T[];
+export declare const attempt: {
+    <T, R = undefined>(f: () => T, recover?: (e: unknown) => R): T | R;
+    <T, R = undefined>(f: () => Promise<T>, recover?: (e: unknown) => R): Promise<T | R>;
+};
+export declare const makePromiseQueue: <T extends unknown, E extends unknown>() => {
+    enqueue: (promise: Promise<T>) => void;
+    [Symbol.asyncIterator](): AsyncGenerator<{
+        status: "fulfilled";
+        value: T;
+    } | {
+        status: "rejected";
+        reason: E;
+    }, void, unknown>;
+};
+export declare const concatenateStreams: <T extends any>(streams: ReadonlyArray<ReadableStream<T>>) => Promise<ReadableStream<T>>;
+export declare const originLock: (name: string, options?: LockOptions) => Promise<() => void>;
+export declare const range: (from: number, to: number, stepSize?: number) => number[];
+export declare const randomId: () => string;
+export declare const basicLatin: string;
+export declare const makeRandomPassword: ({ length, characters }?: {
+    /** Max 256 */
+    length?: number;
+    characters?: string | ReadonlyArray<string>;
+}) => string;
+export declare const hash: (data: string | BufferSource, algorithm?: AlgorithmIdentifier) => Promise<string>;
+/**
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions#escaping
+ */
+export declare const regexEscape: (s: string) => string;
+export declare const regexTag: (strings: TemplateStringsArray, ...substitutions: ReadonlyArray<unknown>) => (flags?: string) => RegExp;
+export declare const urlTag: (strings: TemplateStringsArray, ...substitutions: ReadonlyArray<unknown>) => string;
+type UrlParts = {
+    pathname: string;
+    search: string;
+    hash: string;
+};
+export declare const modifyUrl: (url: URL | string, f: (parts: UrlParts) => Partial<UrlParts>) => string;
+export declare const urlWithParams: (url: URL | string, searchParameters?: Record<string, LikelyAsString | ReadonlyArray<LikelyAsString> | undefined>) => string;
+export declare class NodeTreeIterator implements IterableIterator<Node> {
+    #private;
+    constructor(root: ParentNode, filter?: (node: Node) => boolean);
+    /** Skip descendents of the current node */
+    skip(): void;
+    next(): {
+        done: false;
+        value: Node;
+    } | {
+        done: true;
+        value: undefined;
+    };
+    [Symbol.iterator](): this;
+}
+export declare const makeFlatRange: (firstNode: ChildNode, isLastNode: (node: ChildNode) => boolean) => Range;
+type SearchPath = ReadonlyArray<{
+    parent: {};
+    key: PropertyKey;
+    value: unknown;
+}>;
+export declare const recursivelySearchFor: <T extends unknown>(x: unknown, f: (value: unknown) => value is T, path?: SearchPath) => ReadonlyArray<{
+    path: SearchPath;
+    value: T;
+}>;
+export {};

package/dist/utils/browser.mjs

@@ -0,0 +1,27 @@
+import { r } from '../reactive.mjs';
+
+const currentUrl = r();
+const reflectUrl = () => {
+  currentUrl.value = new URL(location.href);
+};
+reflectUrl();
+addEventListener("hashchange", reflectUrl);
+if ("navigation" in window)
+  navigation.addEventListener("navigate", reflectUrl);
+else {
+  const replacedPushState = history.pushState;
+  history.pushState = function() {
+    const result = replacedPushState.apply(this, arguments);
+    reflectUrl();
+    return result;
+  };
+  const replacedReplaceState = history.replaceState;
+  history.replaceState = function() {
+    const result = replacedReplaceState.apply(this, arguments);
+    reflectUrl();
+    return result;
+  };
+}
+
+export { currentUrl };
+//# sourceMappingURL=browser.mjs.map

package/dist/utils/browser.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.mjs","sources":["../../src/utils/browser.mts"],"sourcesContent":["import { r, type SourceNode } from \"../reactive/index.mts\"\n\nexport const currentUrl = r() as SourceNode<URL>\n\nconst reflectUrl = () => {\n  currentUrl.value = new URL(location.href)\n}\nreflectUrl()\n\naddEventListener(\"hashchange\", reflectUrl)\n\ndeclare var navigation: EventTarget\nif (\"navigation\" in window)\n  navigation.addEventListener(\"navigate\", reflectUrl)\nelse {\n  const replacedPushState = history.pushState\n  history.pushState = function() {\n    const result = replacedPushState.apply(this, arguments as any)\n    reflectUrl()\n    return result\n  }\n\n  const replacedReplaceState = history.replaceState\n  history.replaceState = function() {\n    const result = replacedReplaceState.apply(this, arguments as any)\n    reflectUrl()\n    return result\n  }\n}\n"],"names":[],"mappings":";;AAEO,MAAM,aAAa,CAAE;AAE5B,MAAM,aAAa,MAAM;AACvB,EAAA,UAAA,CAAW,KAAQ,GAAA,IAAI,GAAI,CAAA,QAAA,CAAS,IAAI,CAAA;AAC1C,CAAA;AACA,UAAW,EAAA;AAEX,gBAAA,CAAiB,cAAc,UAAU,CAAA;AAGzC,IAAI,YAAgB,IAAA,MAAA;AAClB,EAAW,UAAA,CAAA,gBAAA,CAAiB,YAAY,UAAU,CAAA;AAAA,KAC/C;AACH,EAAA,MAAM,oBAAoB,OAAQ,CAAA,SAAA;AAClC,EAAA,OAAA,CAAQ,YAAY,WAAW;AAC7B,IAAA,MAAM,MAAS,GAAA,iBAAA,CAAkB,KAAM,CAAA,IAAA,EAAM,SAAgB,CAAA;AAC7D,IAAW,UAAA,EAAA;AACX,IAAO,OAAA,MAAA;AAAA,GACT;AAEA,EAAA,MAAM,uBAAuB,OAAQ,CAAA,YAAA;AACrC,EAAA,OAAA,CAAQ,eAAe,WAAW;AAChC,IAAA,MAAM,MAAS,GAAA,oBAAA,CAAqB,KAAM,CAAA,IAAA,EAAM,SAAgB,CAAA;AAChE,IAAW,UAAA,EAAA;AACX,IAAO,OAAA,MAAA;AAAA,GACT;AACF;;;;"}