sygnal 5.3.7 → 6.0.0

package/dist/astro/collection.d.ts

@@ -1,12 +0,0 @@
-import type { Lens } from './cycle/state/types';
-interface CollectionOptions {
-    combineList?: string[];
-    globalList?: string[];
-    stateSourceName?: string;
-    domSourceName?: string;
-    container?: string;
-    containerClass?: string;
-}
-export default function collection(component: (...args: any[]) => any, stateLense: string | Lens<any, any>, opts?: CollectionOptions): (sources: any) => any;
-declare const Collection: (props: any) => import("snabbdom/build/vnode").VNode;
-export { Collection };

package/dist/astro/component.d.ts

@@ -1,22 +0,0 @@
-export declare const ABORT: unique symbol;
-export interface ComponentOptions {
-    name?: string;
-    sources?: Record<string, any>;
-    intent?: ((sources: Record<string, any>) => any) | Record<string, any>;
-    model?: Record<string, any>;
-    hmrActions?: string | string[];
-    context?: Record<string, boolean | ((state: any) => any)>;
-    response?: Record<string, any>;
-    view?: (...args: any[]) => any;
-    peers?: Record<string, (...args: any[]) => any>;
-    components?: Record<string, any>;
-    initialState?: Record<string, any>;
-    calculated?: Record<string, ((state: any) => any) | [string[], (...args: any[]) => any]>;
-    storeCalculatedInState?: boolean;
-    DOMSourceName?: string;
-    stateSourceName?: string;
-    requestSourceName?: string;
-    isolateOpts?: string | boolean | Record<string, any>;
-    debug?: boolean;
-}
-export default function component(opts: ComponentOptions): any;

package/dist/astro/cycle/dom/BodyDOMSource.d.ts

@@ -1,10 +0,0 @@
-import { Stream, MemoryStream } from 'xstream';
-import { EventsFnOptions } from './DOMSource';
-export declare class BodyDOMSource {
-    private _name;
-    constructor(_name: string);
-    select(selector: string): BodyDOMSource;
-    elements(): MemoryStream<Array<HTMLBodyElement>>;
-    element(): MemoryStream<HTMLBodyElement>;
-    events<K extends keyof HTMLBodyElementEventMap>(eventType: K, options?: EventsFnOptions, bubbles?: boolean): Stream<HTMLBodyElementEventMap[K]>;
-}

package/dist/astro/cycle/dom/DOMSource.d.ts

@@ -1,11 +0,0 @@
-import { PreventDefaultOpt } from './fromEvent';
-import { MainDOMSource } from './MainDOMSource';
-import { DocumentDOMSource } from './DocumentDOMSource';
-import { BodyDOMSource } from './BodyDOMSource';
-export interface EventsFnOptions {
-    useCapture?: boolean;
-    passive?: boolean;
-    bubbles?: boolean;
-    preventDefault?: PreventDefaultOpt;
-}
-export type DOMSource = MainDOMSource | DocumentDOMSource | BodyDOMSource;

package/dist/astro/cycle/dom/DocumentDOMSource.d.ts

@@ -1,12 +0,0 @@
-import { MemoryStream } from 'xstream';
-import { EventsFnOptions } from './DOMSource';
-import { EnrichedEventStream } from './enrichEventStream';
-export declare class DocumentDOMSource {
-    private _name;
-    private _selector;
-    constructor(_name: string, selector?: string);
-    select(selector: string): DocumentDOMSource;
-    elements(): MemoryStream<Array<Document | Element>>;
-    element(): MemoryStream<Document | Element | null>;
-    events<K extends keyof DocumentEventMap>(eventType: K, options?: EventsFnOptions, bubbles?: boolean): EnrichedEventStream<DocumentEventMap[K]>;
-}

package/dist/astro/cycle/dom/ElementFinder.d.ts

@@ -1,8 +0,0 @@
-import { Scope } from './isolate';
-import { IsolateModule } from './IsolateModule';
-export declare class ElementFinder {
-    namespace: Array<Scope>;
-    isolateModule: IsolateModule;
-    constructor(namespace: Array<Scope>, isolateModule: IsolateModule);
-    call(): Array<Element>;
-}

package/dist/astro/cycle/dom/EventDelegator.d.ts

@@ -1,34 +0,0 @@
-import { Stream } from 'xstream';
-import { IsolateModule } from './IsolateModule';
-import { EventsFnOptions } from './DOMSource';
-import { Scope } from './isolate';
-export interface CycleDOMEvent extends Event {
-    propagationHasBeenStopped: boolean;
-    ownerTarget: Element;
-}
-export declare const eventTypesThatDontBubble: string[];
-export declare class EventDelegator {
-    private rootElement$;
-    isolateModule: IsolateModule;
-    private virtualListeners;
-    private origin;
-    private domListeners;
-    private nonBubblingListeners;
-    private domListenersToAdd;
-    private nonBubblingListenersToAdd;
-    private virtualNonBubblingListener;
-    constructor(rootElement$: Stream<Element>, isolateModule: IsolateModule);
-    addEventListener(eventType: string, namespace: Array<Scope>, options: EventsFnOptions, bubbles?: boolean): Stream<Event>;
-    removeElement(element: Element, namespace?: Array<Scope>): void;
-    private insertListener;
-    private getVirtualListeners;
-    private setupDOMListener;
-    private setupNonBubblingListener;
-    private resetEventListeners;
-    private putNonBubblingListener;
-    private onEvent;
-    private bubble;
-    private doBubbleStep;
-    private patchEvent;
-    private mutateEventCurrentTarget;
-}

package/dist/astro/cycle/dom/IsolateModule.d.ts

@@ -1,23 +0,0 @@
-import { VNode } from './snabbdom';
-import { EventDelegator } from './EventDelegator';
-import { Scope } from './isolate';
-export declare class IsolateModule {
-    private namespaceTree;
-    private namespaceByElement;
-    private eventDelegator;
-    private vnodesBeingRemoved;
-    constructor();
-    setEventDelegator(del: EventDelegator): void;
-    private insertElement;
-    private removeElement;
-    getElement(namespace: Array<Scope>, max?: number): Element | undefined;
-    getRootElement(elm: Element): Element | undefined;
-    getNamespace(elm: Element): Array<Scope> | undefined;
-    createModule(): {
-        create(emptyVNode: VNode, vNode: VNode): void;
-        update(oldVNode: VNode, vNode: VNode): void;
-        destroy(vNode: VNode): void;
-        remove(vNode: VNode, cb: Function): void;
-        post(): void;
-    };
-}

package/dist/astro/cycle/dom/MainDOMSource.d.ts

@@ -1,32 +0,0 @@
-import { Stream, MemoryStream } from 'xstream';
-import { EventsFnOptions } from './DOMSource';
-import { DocumentDOMSource } from './DocumentDOMSource';
-import { BodyDOMSource } from './BodyDOMSource';
-import { VNode } from './snabbdom';
-import { EnrichedEventStream } from './enrichEventStream';
-import { Scope, IsolateSink } from './isolate';
-import { IsolateModule } from './IsolateModule';
-import { EventDelegator } from './EventDelegator';
-export interface SpecialSelector {
-    body: BodyDOMSource;
-    document: DocumentDOMSource;
-}
-export declare class MainDOMSource {
-    private _rootElement$;
-    private _sanitation$;
-    private _namespace;
-    _isolateModule: IsolateModule;
-    private _eventDelegator;
-    private _name;
-    constructor(_rootElement$: Stream<Element>, _sanitation$: Stream<null>, _namespace: Array<Scope>, _isolateModule: IsolateModule, _eventDelegator: EventDelegator, _name: string);
-    private _elements;
-    elements(): MemoryStream<Array<Element>>;
-    element(): MemoryStream<Element>;
-    get namespace(): Array<Scope>;
-    select<T extends keyof SpecialSelector>(selector: T): SpecialSelector[T];
-    select(selector: string): MainDOMSource;
-    events<K extends keyof HTMLElementEventMap>(eventType: K, options?: EventsFnOptions, bubbles?: boolean): EnrichedEventStream<HTMLElementEventMap[K]>;
-    dispose(): void;
-    isolateSource: (source: MainDOMSource, scope: string) => MainDOMSource;
-    isolateSink: IsolateSink<VNode>;
-}

package/dist/astro/cycle/dom/PriorityQueue.d.ts

@@ -1,7 +0,0 @@
-export default class PriorityQueue<T> {
-    private arr;
-    private prios;
-    add(t: T, prio: number): void;
-    forEach(f: (t: T, i: number, arr: Array<T>) => void): void;
-    delete(t: T): void;
-}

package/dist/astro/cycle/dom/ScopeChecker.d.ts

@@ -1,9 +0,0 @@
-import { IsolateModule } from './IsolateModule';
-import { Scope } from './isolate';
-export declare class ScopeChecker {
-    readonly namespace: Array<Scope>;
-    private isolateModule;
-    readonly _namespace: Array<Scope>;
-    constructor(namespace: Array<Scope>, isolateModule: IsolateModule);
-    isDirectlyInScope(leaf: Element): boolean;
-}

package/dist/astro/cycle/dom/SymbolTree.d.ts

@@ -1,9 +0,0 @@
-export default class SymbolTree<Payload, T> {
-    private mapper;
-    private tree;
-    constructor(mapper: (t: T) => string);
-    set(path: Array<T>, element: Payload | undefined, max?: number): void;
-    getDefault(path: Array<T>, mkDefaultElement: () => Payload, max?: number): Payload;
-    get(path: Array<T>, mkDefaultElement?: () => Payload, max?: number): Payload | undefined;
-    delete(path: Array<T>): void;
-}

package/dist/astro/cycle/dom/VNodeWrapper.d.ts

@@ -1,8 +0,0 @@
-import { VNode } from './snabbdom';
-export declare class VNodeWrapper {
-    rootElement: Element | DocumentFragment;
-    constructor(rootElement: Element | DocumentFragment);
-    call(vnode: VNode | null): VNode;
-    private wrapDocFrag;
-    private wrap;
-}

package/dist/astro/cycle/dom/enrichEventStream.d.ts

@@ -1,24 +0,0 @@
-import { Stream } from 'xstream';
-export interface EnrichedEventStream<T = Event> extends Stream<T> {
-    value(): EnrichedEventStream<string>;
-    value<R>(fn: (val: string) => R): EnrichedEventStream<R>;
-    checked(): EnrichedEventStream<boolean>;
-    checked<R>(fn: (val: boolean) => R): EnrichedEventStream<R>;
-    data(name: string): EnrichedEventStream<string | undefined>;
-    data<R>(name: string, fn: (val: string | undefined) => R): EnrichedEventStream<R>;
-    target(): EnrichedEventStream<EventTarget | null>;
-    target<R>(fn: (el: EventTarget | null) => R): EnrichedEventStream<R>;
-    key(): EnrichedEventStream<string>;
-    key<R>(fn: (key: string) => R): EnrichedEventStream<R>;
-}
-/**
- * Adds chainable convenience methods to a DOM event stream.
- *
- *   DOM.select('.input').events('input').value()
- *   DOM.input('.input').value()
- *   DOM.select('.item').events('click').data('id')
- *   DOM.click('.item').data('id', Number)
- *   DOM.change('.checkbox').checked()
- *   DOM.keydown('.field').key()
- */
-export declare function enrichEventStream(stream$: any): any;

package/dist/astro/cycle/dom/fromEvent.d.ts

@@ -1,6 +0,0 @@
-import { Stream } from 'xstream';
-export type Predicate = (ev: Event) => boolean;
-export type Comparator = Record<string, unknown>;
-export type PreventDefaultOpt = boolean | Predicate | Comparator;
-export declare function fromEvent(element: Element | Document, eventName: string, useCapture?: boolean, preventDefault?: PreventDefaultOpt, passive?: boolean): Stream<Event>;
-export declare function preventDefaultConditional(event: Event, preventDefault: PreventDefaultOpt): void;

package/dist/astro/cycle/dom/index.d.ts

@@ -1,8 +0,0 @@
-export { thunk, Thunk, ThunkData } from './thunk';
-export { VNode, VNodeData } from './snabbdom';
-export { DOMSource, EventsFnOptions } from './DOMSource';
-export { MainDOMSource } from './MainDOMSource';
-export { makeDOMDriver, DOMDriverOptions } from './makeDOMDriver';
-export { mockDOMSource, MockConfig, MockedDOMSource } from './mockDOMSource';
-export { CycleDOMEvent } from './EventDelegator';
-export { h } from './snabbdom';

package/dist/astro/cycle/dom/isolate.d.ts

@@ -1,9 +0,0 @@
-import { Stream } from 'xstream';
-import { VNode } from './snabbdom';
-export interface Scope {
-    type: 'sibling' | 'total' | 'selector';
-    scope: string;
-}
-export type IsolateSink<T extends VNode> = (s: Stream<T>, scope: string) => Stream<T>;
-export declare function makeIsolateSink<T extends VNode>(namespace: Array<Scope>): IsolateSink<T>;
-export declare function getScopeObj(scope: string): Scope;

package/dist/astro/cycle/dom/makeDOMDriver.d.ts

@@ -1,11 +0,0 @@
-import { Driver } from '../run/types';
-import { Module, Options as SnabbdomOptions, VNode } from './snabbdom';
-import { Stream } from 'xstream';
-import { MainDOMSource } from './MainDOMSource';
-export interface DOMDriverOptions {
-    modules?: Array<Partial<Module>>;
-    reportSnabbdomError?(err: unknown): void;
-    snabbdomOptions?: SnabbdomOptions;
-}
-declare function makeDOMDriver(container: string | Element | DocumentFragment, options?: DOMDriverOptions): Driver<Stream<VNode>, MainDOMSource>;
-export { makeDOMDriver };

package/dist/astro/cycle/dom/mockDOMSource.d.ts

@@ -1,17 +0,0 @@
-import { FantasyObservable } from '../run/types';
-import { EventsFnOptions } from './DOMSource';
-export type MockConfig = {
-    [name: string]: FantasyObservable<any> | MockConfig;
-};
-export declare class MockedDOMSource {
-    private _mockConfig;
-    private _elements;
-    constructor(_mockConfig: MockConfig);
-    elements(): any;
-    element(): any;
-    events(eventType: string, options?: EventsFnOptions, bubbles?: boolean): any;
-    select(selector: string): MockedDOMSource;
-    isolateSource(source: MockedDOMSource, scope: string): MockedDOMSource;
-    isolateSink(sink: any, scope: string): any;
-}
-export declare function mockDOMSource(mockConfig: MockConfig): MockedDOMSource;

package/dist/astro/cycle/dom/modules.d.ts

@@ -1,5 +0,0 @@
-import { Module, classModule, propsModule, attributesModule, datasetModule } from './snabbdom';
-import { styleModule } from './styleModule';
-declare const modules: Array<Module>;
-export { styleModule, classModule, propsModule, attributesModule, datasetModule };
-export default modules;

package/dist/astro/cycle/dom/snabbdom.d.ts

@@ -1,22 +0,0 @@
-/**
- * Local snabbdom re-export barrel.
- *
- * Imports from specific snabbdom subpaths instead of the main barrel to avoid
- * triggering the broken `styleModule` top-level `window` reference in
- * snabbdom 3.6.3 (which causes ReferenceError in Node.js environments).
- *
- * The styleModule is provided separately by ./styleModule.ts with a fixed
- * window guard.
- */
-export { h, fragment as HFragment } from 'snabbdom/build/h';
-export { init } from 'snabbdom/build/init';
-export type { Options } from 'snabbdom/build/init';
-export { toVNode } from 'snabbdom/build/tovnode';
-export { vnode } from 'snabbdom/build/vnode';
-export type { VNode, VNodeData } from 'snabbdom/build/vnode';
-export { Fragment } from 'snabbdom/build/jsx';
-export type { Module } from 'snabbdom/build/modules/module';
-export { classModule } from 'snabbdom/build/modules/class';
-export { propsModule } from 'snabbdom/build/modules/props';
-export { attributesModule } from 'snabbdom/build/modules/attributes';
-export { datasetModule } from 'snabbdom/build/modules/dataset';

package/dist/astro/cycle/dom/styleModule.d.ts

@@ -1,13 +0,0 @@
-/**
- * Local copy of snabbdom's styleModule with a fixed `window` guard.
- *
- * snabbdom 3.6.3 introduced a regression where the top-level `raf` assignment
- * evaluates `window` directly (via `window === null || window === void 0`)
- * before the `typeof` check, causing a ReferenceError in Node.js environments.
- *
- * This copy restores the safe `typeof window !== "undefined"` guard while
- * keeping all other 3.6.x improvements (arrow functions, `in` operator for
- * style removal checks, etc.).
- */
-import { Module } from './snabbdom';
-export declare const styleModule: Module;

package/dist/astro/cycle/dom/thunk.d.ts

@@ -1,11 +0,0 @@
-import { VNode, VNodeData } from './snabbdom';
-export interface ThunkData extends VNodeData {
-    fn(): VNode;
-    args: Array<any>;
-}
-export interface Thunk extends VNode {
-    data: ThunkData;
-}
-export declare function thunk(sel: string, fn: Function, args: Array<any>): Thunk;
-export declare function thunk(sel: string, key: any, fn: Function, args: Array<any>): Thunk;
-export default thunk;

package/dist/astro/cycle/dom/utils.d.ts

@@ -1,8 +0,0 @@
-import { Scope } from './isolate';
-export declare function isClassOrId(str: string): boolean;
-export declare function isDocFrag(el: Element | DocumentFragment): el is DocumentFragment;
-export declare function checkValidContainer(container: Element | DocumentFragment | string): void;
-export declare function getValidNode(selectors: Element | DocumentFragment | string): Element | DocumentFragment | null;
-export declare function getSelectors(namespace: Array<Scope>): string;
-export declare function isEqualNamespace(a: Array<Scope> | undefined, b: Array<Scope> | undefined): boolean;
-export declare function makeInsert(map: Map<string, Map<Element, any>>): (type: string, elm: Element, value: any) => void;

package/dist/astro/cycle/isolate/index.d.ts

@@ -1,42 +0,0 @@
-import { Stream } from 'xstream';
-export type Component<So, Si> = (sources: So, ...rest: Array<any>) => Si;
-export type FirstArg<T extends (r: any, ...args: Array<any>) => any> = T extends (r: infer R, ...args: Array<any>) => any ? R : any;
-export type IsolateableSource<A = any, B = any> = {
-    isolateSource(source: IsolateableSource<A, B>, scope: any): IsolateableSource<A, B>;
-    isolateSink(sink: A, scope: any): B;
-};
-export type Sources = {
-    [name: string]: IsolateableSource;
-};
-export type WildcardScope = {
-    ['*']?: string;
-};
-export type ScopesPerChannel<So> = {
-    [K in keyof So]: any;
-};
-export type Scopes<So> = (Partial<ScopesPerChannel<So>> & WildcardScope) | string;
-export type OuterSo<ISo> = {
-    [K in keyof ISo]: ISo[K] extends IsolateableSource ? FirstArg<IsolateableSource['isolateSource']> : ISo[K];
-};
-export type OuterSi<ISo, ISi> = {
-    [K in keyof ISo & keyof ISi]: ISo[K] extends IsolateableSource ? (ReturnType<ISo[K]['isolateSink']> extends Stream<infer T> ? Stream<T> : (ReturnType<ISo[K]['isolateSink']> extends Stream<any> ? Stream<unknown> : unknown)) : ISi[K];
-} & {
-    [K in Exclude<keyof ISi, keyof ISo>]: ISi[K];
-};
-/**
- * Takes a `component` function and a `scope`, and returns an isolated version
- * of the `component` function.
- *
- * When the isolated component is invoked, each source provided to it is
- * isolated to the given `scope` using `source.isolateSource(source, scope)`,
- * if possible. Likewise, the sinks returned from the isolated component are
- * isolated to the given `scope` using `source.isolateSink(sink, scope)`.
- *
- * @param {Function} component a function that takes `sources` as input and outputs a collection of `sinks`.
- * @param {String} scope an optional string that is used to isolate each `sources` and `sinks`.
- * @return {Function} the scoped component function.
- * @function isolate
- */
-declare function isolate<InnerSo, InnerSi>(component: Component<InnerSo, InnerSi>, scope?: any): Component<OuterSo<InnerSo>, OuterSi<InnerSo, InnerSi>>;
-export default isolate;
-export declare function toIsolated<InnerSo, InnerSi>(scope?: any): (c: Component<InnerSo, InnerSi>) => Component<OuterSo<InnerSo>, OuterSi<InnerSo, InnerSi>>;

package/dist/astro/cycle/run/adapt.d.ts

@@ -1,6 +0,0 @@
-import { Stream } from 'xstream';
-export interface AdaptStream {
-    (s: Stream<any>): any;
-}
-export declare function setAdapt(f: AdaptStream): void;
-export declare function adapt(stream: Stream<any>): any;

package/dist/astro/cycle/run/index.d.ts

@@ -1,36 +0,0 @@
-import { CycleProgram, DisposeFunction, Drivers, MatchingDrivers, MatchingMain, Engine } from './types';
-export { FantasyObserver, FantasySubscription, FantasyObservable, DevToolEnabledSource, Sources, Sinks, SinkProxies, Driver, Drivers, DisposeFunction, MatchingDrivers, MatchingMain, Main, CycleProgram, Engine, WidenStream, GetValidInputs, } from './types';
-/**
- * A function that prepares the Cycle application to be executed. Takes a `main`
- * function and prepares to circularly connects it to the given collection of
- * driver functions. As an output, `setup()` returns an object with three
- * properties: `sources`, `sinks` and `run`. Only when `run()` is called will
- * the application actually execute. Refer to the documentation of `run()` for
- * more details.
- *
- * @param {Function} main a function that takes `sources` as input and outputs `sinks`.
- * @param {Object} drivers an object where keys are driver names and values are driver functions.
- * @return {Object} an object with three properties: `sources`, `sinks` and `run`.
- * @function setup
- */
-export declare function setup<D extends MatchingDrivers<D, M>, M extends MatchingMain<D, M>>(main: M, drivers: D): CycleProgram<D, M>;
-/**
- * A partially-applied variant of setup() which accepts only the drivers, and
- * allows many `main` functions to execute and reuse this same set of drivers.
- *
- * @param {Object} drivers an object where keys are driver names and values are driver functions.
- * @return {Object} an object with three properties: `sources`, `run` and `dispose`.
- * @function setupReusable
- */
-export declare function setupReusable<D extends Drivers>(drivers: D): Engine<D>;
-/**
- * Takes a `main` function and circularly connects it to the given collection
- * of driver functions.
- *
- * @param {Function} main a function that takes `sources` as input and outputs `sinks`.
- * @param {Object} drivers an object where keys are driver names and values are driver functions.
- * @return {Function} a dispose function, used to terminate the execution of the Cycle.js program.
- * @function run
- */
-export declare function run<D extends MatchingDrivers<D, M>, M extends MatchingMain<D, M>>(main: M, drivers: D): DisposeFunction;
-export default run;

package/dist/astro/cycle/run/internals.d.ts

@@ -1,8 +0,0 @@
-import { DisposeFunction, Drivers, SinkProxies, Sources } from './types';
-export declare function makeSinkProxies<D extends Drivers>(drivers: D): SinkProxies<D>;
-export declare function callDrivers<D extends Drivers>(drivers: D, sinkProxies: SinkProxies<D>): Sources<D>;
-export declare function adaptSources<So>(sources: So): So;
-export declare function replicateMany<Si extends any>(sinks: Si, sinkProxies: SinkProxies<Si>): DisposeFunction;
-export declare function disposeSinkProxies<Si>(sinkProxies: SinkProxies<Si>): void;
-export declare function disposeSources<So>(sources: So): void;
-export declare function isObjectEmpty(obj: any): boolean;

package/dist/astro/cycle/run/types.d.ts

@@ -1,49 +0,0 @@
-import { Stream } from 'xstream';
-export type FantasyObserver<T> = {
-    next(x: T): void;
-    error(err: any): void;
-    complete(c?: any): void;
-};
-export type FantasySubscription = {
-    unsubscribe(): void;
-};
-export type FantasyObservable<T> = {
-    subscribe(observer: FantasyObserver<T>): FantasySubscription;
-};
-export type DevToolEnabledSource = {
-    _isCycleSource: string;
-};
-export type SinkProxies<Si> = {
-    [P in keyof Si]: Si[P] extends Stream<infer T> ? Stream<T> : Stream<any>;
-};
-export type Driver<Si, So> = Si extends void ? (() => So) : ((stream: Si) => So);
-export type DisposeFunction = () => void;
-export type Drivers = {
-    [name: string]: Driver<Stream<any>, any | void>;
-};
-export type Main = (...args: Array<any>) => any;
-export type Sources<D extends Drivers> = {
-    [k in keyof D]: ReturnType<D[k]>;
-};
-export type Sinks<M extends Main> = ReturnType<M>;
-export type MatchingMain<D extends Drivers, M extends Main> = (Main & {
-    (so: Sources<D>): Sinks<M>;
-}) | (Main & {
-    (): Sinks<M>;
-});
-export type ToStream<S> = S extends FantasyObservable<infer T> ? Stream<T> : S;
-export type WidenStream<S, U> = S extends Stream<infer T> ? (T extends U ? U : never) : any;
-export type GetValidInputs<D extends Driver<any, any>> = D extends Driver<infer S, any> ? (S extends Stream<infer T> ? T : never) : never;
-export type MatchingDrivers<D extends Drivers, M extends Main> = Drivers & {
-    [k in string & keyof Sinks<M>]: (() => Sources<D>[k]) | ((si: Stream<WidenStream<ToStream<Sinks<M>[k]>, GetValidInputs<D[k]>>>) => Sources<D>[k]);
-};
-export interface CycleProgram<D extends MatchingDrivers<D, M>, M extends MatchingMain<D, M>> {
-    sources: Sources<D>;
-    sinks: Sinks<M>;
-    run(): DisposeFunction;
-}
-export interface Engine<D extends Drivers> {
-    sources: Sources<D>;
-    run<M extends MatchingMain<D, M>>(sinks: Sinks<M>): DisposeFunction;
-    dispose(): void;
-}

package/dist/astro/cycle/state/Collection.d.ts

@@ -1,29 +0,0 @@
-import { Stream } from 'xstream';
-import { InternalInstances, ItemKeyFn, ItemScopeFn, ItemFactoryFn } from './types';
-/**
- * An object representing all instances in a collection of components. Has the
- * methods pickCombine and pickMerge to get the combined sinks of all instances.
- */
-export declare class Instances<Si> {
-    private _instances$;
-    constructor(instances$: Stream<InternalInstances<Si>>);
-    pickMerge(selector: string): Stream<any>;
-    pickCombine(selector: string): Stream<Array<any>>;
-}
-interface BaseOptions<S, So, Si> {
-    collectSinks(instances: Instances<Si>): any;
-    itemKey?: ItemKeyFn<S>;
-    itemScope?: ItemScopeFn;
-    channel?: string;
-}
-interface HomogenousOptions<S, So, Si> extends BaseOptions<S, So, Si> {
-    item(so: So): Si;
-    itemFactory?: never;
-}
-interface HeterogenousOptions<S, So, Si> extends BaseOptions<S, So, Si> {
-    item?: never;
-    itemFactory: ItemFactoryFn<S, So, Si>;
-}
-export type CollectionOptions<S, So, Si> = HomogenousOptions<S, So, Si> | HeterogenousOptions<S, So, Si>;
-export declare function makeCollection<S, So = any, Si = any>(opts: CollectionOptions<S, So, Si>): (sources: any) => any;
-export {};

package/dist/astro/cycle/state/StateSource.d.ts

@@ -1,20 +0,0 @@
-import { Stream, MemoryStream } from 'xstream';
-import { Scope, Reducer } from './types';
-export declare function isolateSource<T, R>(source: StateSource<T>, scope: Scope<T, R>): StateSource<R>;
-export declare function isolateSink<T, R>(innerReducer$: Stream<Reducer<R>>, scope: Scope<T, R>): Stream<Reducer<T>>;
-/**
- * Represents a piece of application state dynamically changing over time.
- */
-export declare class StateSource<S> {
-    stream: MemoryStream<S>;
-    private _stream;
-    private _name;
-    constructor(stream: Stream<S>, name: string);
-    /**
-     * Selects a part (or scope) of the state object and returns a new StateSource
-     * dynamically representing that selected part of the state.
-     */
-    select<R>(scope: Scope<S, R>): StateSource<R>;
-    isolateSource: typeof isolateSource;
-    isolateSink: typeof isolateSink;
-}

package/dist/astro/cycle/state/index.d.ts

@@ -1,5 +0,0 @@
-export { Getter, Setter, Lens, Scope, Reducer, MainFn } from './types';
-export { StateSource, isolateSource, isolateSink } from './StateSource';
-export { Instances, CollectionOptions } from './Collection';
-export { withState } from './withState';
-export { makeCollection } from './Collection';

package/dist/astro/cycle/state/pickCombine.d.ts

@@ -1,3 +0,0 @@
-import { Stream } from 'xstream';
-import { InternalInstances } from './types';
-export declare function pickCombine(selector: string): (inst$: Stream<InternalInstances<any>>) => Stream<Array<any>>;

package/dist/astro/cycle/state/pickMerge.d.ts

@@ -1,3 +0,0 @@
-import { Stream } from 'xstream';
-import { InternalInstances } from './types';
-export declare function pickMerge(selector: string): (inst$: Stream<InternalInstances<any>>) => Stream<any>;

package/dist/astro/cycle/state/types.d.ts

@@ -1,18 +0,0 @@
-export type MainFn<So, Si> = (sources: So) => Si;
-export type Reducer<T> = (state: T | undefined) => T | undefined;
-export type Getter<T, R> = (state: T | undefined) => R | undefined;
-export type Setter<T, R> = (state: T | undefined, childState: R | undefined) => T | undefined;
-export type Lens<T, R> = {
-    get: Getter<T, R>;
-    set: Setter<T, R>;
-};
-export type ItemScopeFn = (key: string) => string | object;
-export type ItemKeyFn<S> = (state: S, index?: number) => string;
-export type ItemFactoryFn<S, So, Si> = (state: S, index?: number) => MainFn<So, Si>;
-export type Scope<T, R> = string | number | Lens<T, R>;
-export type InternalInstances<Si> = {
-    dict: Map<string, Si>;
-    arr: Array<Si & {
-        _key: string;
-    }>;
-};

package/dist/astro/cycle/state/withState.d.ts

@@ -1,17 +0,0 @@
-import { Stream } from 'xstream';
-import { MainFn, Reducer } from './types';
-import { StateSource } from './StateSource';
-export type Omit<T, K extends keyof T> = {
-    [P in Exclude<keyof T, K>]: T[P];
-};
-export type Forbid<T, K extends keyof T> = Omit<T, K> & {
-    [P in K]?: never;
-};
-export type OSo<T, N extends string> = {
-    [P in N]: StateSource<T>;
-};
-export type OSi<T, N extends string> = {
-    [P in N]: Stream<Reducer<T>>;
-};
-export type MainWithState<So extends OSo<T, N>, Si extends OSi<T, N>, T, N extends string> = MainFn<Forbid<So, N>, Omit<Si, N>>;
-export declare function withState<So extends OSo<T, N>, Si extends OSi<T, N>, T = any, N extends string = 'state'>(main: MainFn<So, Si>, name?: N): MainWithState<So, Si, T, N>;

package/dist/astro/extra/classes.d.ts

@@ -1,7 +0,0 @@
-type ClassArg = string | string[] | Record<string, boolean | (() => boolean)>;
-/**
- * Return a validated and properly separated string of CSS class names from
- * any number of strings, arrays, and objects.
- */
-export default function classes(...args: ClassArg[]): string;
-export {};