sygnal 5.3.7 → 5.4.0

package/dist/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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 {};

package/dist/extra/devtools.d.ts

@@ -1,78 +0,0 @@
-declare global {
-    interface Window {
-        __SYGNAL_DEVTOOLS__?: SygnalDevTools;
-        __SYGNAL_DEVTOOLS_APP__?: {
-            sinks?: {
-                STATE?: {
-                    shamefullySendNext: (fn: any) => void;
-                };
-            };
-        };
-        __SYGNAL_DEVTOOLS_PAGE__?: boolean;
-        SYGNAL_DEBUG?: string | false;
-        __SYGNAL_HMR_UPDATING?: boolean;
-        __SYGNAL_HMR_STATE?: unknown;
-        __SYGNAL_HMR_PERSISTED_STATE?: unknown;
-        __SYGNAL_HMR_LAST_CAPTURED_STATE?: unknown;
-        Cyclejs?: {
-            sinks?: any;
-        };
-        CyclejsDevTool_startGraphSerializer?: (sinks: any) => void;
-    }
-}
-interface StateHistoryEntry {
-    componentId: number;
-    componentName: string;
-    timestamp: number;
-    state: any;
-}
-interface ComponentMeta {
-    id: number;
-    name: string;
-    isSubComponent: boolean;
-    hasModel: boolean;
-    hasIntent: boolean;
-    hasContext: boolean;
-    hasCalculated: boolean;
-    components: string[];
-    parentId: number | null;
-    children: number[];
-    debug: boolean;
-    createdAt: number;
-    _instanceRef: WeakRef<any>;
-}
-interface ExtensionMessage {
-    type: string;
-    payload?: any;
-    source?: string;
-}
-declare class SygnalDevTools {
-    _connected: boolean;
-    _components: Map<number, ComponentMeta>;
-    _stateHistory: StateHistoryEntry[];
-    _maxHistory: number;
-    constructor();
-    get connected(): boolean;
-    init(): void;
-    _handleExtensionMessage(msg: ExtensionMessage): void;
-    onComponentCreated(componentNumber: number, name: string, instance: any): void;
-    onStateChanged(componentNumber: number, name: string, state: any): void;
-    onActionDispatched(componentNumber: number, name: string, actionType: string, data: any): void;
-    onSubComponentRegistered(parentNumber: number, childNumber: number): void;
-    onContextChanged(componentNumber: number, name: string, context: any): void;
-    onDebugLog(componentNumber: number, message: string): void;
-    _setDebug({ componentId, enabled }: {
-        componentId?: number;
-        enabled: boolean;
-    }): void;
-    _timeTravel({ historyIndex }: {
-        historyIndex: number;
-    }): void;
-    _sendComponentState(componentId: number): void;
-    _sendFullTree(): void;
-    _post(type: string, payload: any): void;
-    _safeClone(obj: any): any;
-    _serializeMeta(meta: ComponentMeta): Omit<ComponentMeta, '_instanceRef'>;
-}
-export declare function getDevTools(): SygnalDevTools;
-export default getDevTools;

package/dist/extra/dragDriver.d.ts

@@ -1,20 +0,0 @@
-import { Stream } from 'xstream';
-export interface DragConfig {
-    category: string;
-    draggable?: string;
-    dropZone?: string;
-    accepts?: string;
-    dragImage?: string;
-}
-export interface DragSourceEvents {
-    events(eventType: string): Stream<any>;
-}
-export interface DragSource {
-    select(category: string): DragSourceEvents;
-    dragstart(category: string): Stream<any>;
-    dragend(category: string): Stream<any>;
-    drop(category: string): Stream<any>;
-    dragover(category: string): Stream<any>;
-    dispose(): void;
-}
-export declare function makeDragDriver(): (sink$: Stream<any>) => DragSource;

package/dist/extra/driverFactories.d.ts

@@ -1,12 +0,0 @@
-import { Stream } from 'xstream';
-interface DriverFromAsyncOptions {
-    selector?: string;
-    args?: string | string[] | ((val: any) => any);
-    return?: string;
-    pre?: (val: any) => any;
-    post?: (val: any, incoming?: any) => any;
-}
-declare function driverFromAsync(promiseReturningFunction: (...args: any[]) => Promise<any>, opts?: DriverFromAsyncOptions): (fromApp$: Stream<any>) => {
-    select: (selector?: any) => Stream<any>;
-};
-export { driverFromAsync };

package/dist/extra/eventDriver.d.ts

@@ -1,9 +0,0 @@
-import { Stream } from 'xstream';
-export interface EventBusSource {
-    select(type?: string | string[]): any;
-}
-export interface BusEvent {
-    type: string;
-    data?: any;
-}
-export default function eventBusDriver(out$: Stream<BusEvent>): EventBusSource;

package/dist/extra/exactState.d.ts

@@ -1 +0,0 @@
-export default function exactState<S>(): (state: S) => S;

package/dist/extra/hmr.d.ts

@@ -1,17 +0,0 @@
-interface HotModule {
-    accept: (...args: any[]) => void;
-    dispose?: (cb: () => void) => void;
-}
-interface SygnalApp {
-    hmr: (next: any, state?: any) => void;
-    dispose?: () => void;
-    sources?: {
-        STATE?: {
-            stream?: {
-                _v?: any;
-            };
-        };
-    };
-}
-export default function enableHMR(app: SygnalApp, hot: HotModule, loadComponent?: () => Promise<any>, acceptDependencies?: string | string[]): SygnalApp;
-export {};

package/dist/extra/logDriver.d.ts

@@ -1,2 +0,0 @@
-import { Stream } from 'xstream';
-export default function logDriver(out$: Stream<any>): void;

package/dist/extra/processDrag.d.ts

@@ -1,19 +0,0 @@
-import { Stream } from 'xstream';
-interface DOMSelector {
-    events(eventType: string): Stream<any>;
-}
-interface ProcessDragSources {
-    draggable?: DOMSelector;
-    dropZone?: DOMSelector;
-}
-interface ProcessDragOptions {
-    effectAllowed?: DataTransfer['effectAllowed'];
-}
-interface ProcessDragStreams {
-    dragStart$: Stream<DragEvent>;
-    dragEnd$: Stream<null>;
-    dragOver$: Stream<null>;
-    drop$: Stream<DragEvent>;
-}
-export default function processDrag({ draggable, dropZone }?: ProcessDragSources, options?: ProcessDragOptions): ProcessDragStreams;
-export {};

package/dist/extra/processForm.d.ts

@@ -1,15 +0,0 @@
-import { Stream } from 'xstream';
-interface DOMSelector {
-    events(eventType: string): Stream<any>;
-}
-interface ProcessFormOptions {
-    events?: string | string[];
-    preventDefault?: boolean;
-}
-interface FormEntries {
-    event: Event;
-    eventType: string;
-    [key: string]: any;
-}
-export default function processForm(form: DOMSelector, options?: ProcessFormOptions): Stream<FormEntries>;
-export {};

package/dist/extra/run.d.ts

@@ -1,13 +0,0 @@
-interface RunOptions {
-    mountPoint?: string;
-    fragments?: boolean;
-    useDefaultDrivers?: boolean;
-}
-interface SygnalRunResult {
-    sources: any;
-    sinks: any;
-    dispose: () => void;
-    hmr?: (newComponent: any, explicitState?: any) => void;
-}
-export default function run(app: any, drivers?: Record<string, any>, options?: RunOptions): SygnalRunResult;
-export {};

package/dist/extra/xstreamCompat.d.ts

@@ -1,5 +0,0 @@
-export declare function resolveInteropDefault(namespaceValue: any): any;
-declare const xs: any;
-declare const Stream: any;
-export { Stream };
-export default xs;

package/dist/jsx-dev-runtime.d.ts

@@ -1 +0,0 @@
-export { jsx, jsxs, jsxDEV, Fragment } from './jsx-runtime';