@tomorrowevening/theatre-dataverse 1.0.0 → 1.0.1

package/dist/Atom.d.ts

@@ -1,127 +1,85 @@
-import type { Prism } from './prism/Interface';
-import type { Pointer } from './pointer';
-import type { PointerToPrismProvider } from './pointerToPrism';
-/**
- * Wraps an object whose (sub)properties can be individually tracked.
- */
-export default class Atom<State> implements PointerToPrismProvider {
-    private _currentState;
-    private readonly _rootScope;
-    /**
-     * Convenience property that gives you a pointer to the root of the atom.
-     *
-     * @remarks
-     * Equivalent to `pointer({ root: thisAtom, path: [] })`.
-     */
-    readonly pointer: Pointer<State>;
-    readonly prism: Prism<State>;
-    constructor(initialState: State);
-    /**
-     * Sets the state of the atom.
-     *
-     * @param newState - The new state of the atom.
-     */
-    set(newState: State): void;
-    /**
-     * Returns the current state of the atom.
-     */
-    get(): State;
-    /**
-     * Returns the value at the given pointer
-     *
-     * @param pointerOrFn - A pointer to the desired path. Could also be a function returning a pointer
-     *
-     * Example
-     * ```ts
-     * const atom = atom({ a: { b: 1 } })
-     * atom.getByPointer(atom.pointer.a.b) // 1
-     * atom.getByPointer((p) => p.a.b) // 1
-     * ```
-     */
-    getByPointer<S>(pointerOrFn: Pointer<S> | ((p: Pointer<State>) => Pointer<S>)): S;
-    /**
-     * Gets the state of the atom at `path`.
-     */
-    private _getIn;
-    reduce(fn: (state: State) => State): void;
-    /**
-     * Reduces the value at the given pointer
-     *
-     * @param pointerOrFn - A pointer to the desired path. Could also be a function returning a pointer
-     *
-     * Example
-     * ```ts
-     * const atom = atom({ a: { b: 1 } })
-     * atom.reduceByPointer(atom.pointer.a.b, (b) => b + 1) // atom.get().a.b === 2
-     * atom.reduceByPointer((p) => p.a.b, (b) => b + 1) // atom.get().a.b === 2
-     * ```
-     */
-    reduceByPointer<S>(pointerOrFn: Pointer<S> | ((p: Pointer<State>) => Pointer<S>), reducer: (s: S) => S): void;
-    /**
-     * Sets the value at the given pointer
-     *
-     * @param pointerOrFn - A pointer to the desired path. Could also be a function returning a pointer
-     *
-     * Example
-     * ```ts
-     * const atom = atom({ a: { b: 1 } })
-     * atom.setByPointer(atom.pointer.a.b, 2) // atom.get().a.b === 2
-     * atom.setByPointer((p) => p.a.b, 2) // atom.get().a.b === 2
-     * ```
-     */
-    setByPointer<S>(pointerOrFn: Pointer<S> | ((p: Pointer<State>) => Pointer<S>), val: S): void;
-    private _checkUpdates;
-    private _getOrCreateScopeForPath;
-    /**
-     * Adds a listener that will be called whenever the value at the given pointer changes.
-     * @param pointer - The pointer to listen to
-     * @param cb - The callback to call when the value changes
-     * @returns A function that can be called to unsubscribe from the listener
-     *
-     * **NOTE** Unlike {@link prism}s, `onChangeByPointer` and `onChange()` are traditional event listeners. They don't
-     * provide any of the benefits of prisms. They don't compose, they can't be coordinated via a Ticker, their derivations
-     * aren't cached, etc. You're almost always better off using a prism (which will internally use `onChangeByPointer`).
-     *
-     * ```ts
-     * const a = atom({foo: 1})
-     * const unsubscribe = a.onChangeByPointer(a.pointer.foo, (v) => {
-     *  console.log('foo changed to', v)
-     * })
-     * a.setByPointer(a.pointer.foo, 2) // logs 'foo changed to 2'
-     * a.set({foo: 3}) // logs 'foo changed to 3'
-     * unsubscribe()
-     * ```
-     */
-    onChangeByPointer: <S>(pointerOrFn: Pointer<S> | ((p: Pointer<State>) => Pointer<S>), cb: (v: S) => void) => (() => void);
-    /**
-     * Adds a listener that will be called whenever the state of the atom changes.
-     * @param cb - The callback to call when the value changes
-     * @returns A function that can be called to unsubscribe from the listener
-     *
-     * **NOTE** Unlike {@link prism}s, `onChangeByPointer` and `onChange()` are traditional event listeners. They don't
-     * provide any of the benefits of prisms. They don't compose, they can't be coordinated via a Ticker, their derivations
-     * aren't cached, etc. You're almost always better off using a prism (which will internally use `onChangeByPointer`).
-     *
-     * ```ts
-     * const a = atom({foo: 1})
-     * const unsubscribe = a.onChange((v) => {
-     * console.log('a changed to', v)
-     * })
-     * a.set({foo: 3}) // logs 'a changed to {foo: 3}'
-     * unsubscribe()
-     * ```
-     */
-    onChange(cb: (v: State) => void): () => void;
-    /**
-     * Returns a new prism of the value at the provided path.
-     *
-     * @param pointer - The path to create the prism at.
-     *
-     * ```ts
-     * const pr = atom({ a: { b: 1 } }).pointerToPrism(atom.pointer.a.b)
-     * pr.getValue() // 1
-     * ```
-     */
-    pointerToPrism<P>(pointer: Pointer<P>): Prism<P>;
-}
-//# sourceMappingURL=Atom.d.ts.map
+import type { Prism } from './prism/Interface';
+import type { Pointer } from './pointer';
+import type { PointerToPrismProvider } from './pointerToPrism';
+/**
+ * Wraps an object whose (sub)properties can be individually tracked.
+ */
+export default class Atom<State> implements PointerToPrismProvider {
+    private _currentState;
+    private readonly _rootScope;
+    /**
+     * Convenience property that gives you a pointer to the root of the atom.
+     *
+     * @remarks
+     * Equivalent to `pointer({ root: thisAtom, path: [] })`.
+     */
+    readonly pointer: Pointer<State>;
+    readonly prism: Prism<State>;
+    constructor(initialState: State);
+    /**
+     * Sets the state of the atom.
+     *
+     * @param newState - The new state of the atom.
+     */
+    set(newState: State): void;
+    get(): State;
+    /**
+     * Returns the value at the given pointer
+     *
+     * @param pointerOrFn - A pointer to the desired path. Could also be a function returning a pointer
+     *
+     * Example
+     * ```ts
+     * const atom = atom({ a: { b: 1 } })
+     * atom.getByPointer(atom.pointer.a.b) // 1
+     * atom.getByPointer((p) => p.a.b) // 1
+     * ```
+     */
+    getByPointer<S>(pointerOrFn: Pointer<S> | ((p: Pointer<State>) => Pointer<S>)): S;
+    /**
+     * Gets the state of the atom at `path`.
+     */
+    private _getIn;
+    reduce(fn: (state: State) => State): void;
+    /**
+     * Reduces the value at the given pointer
+     *
+     * @param pointerOrFn - A pointer to the desired path. Could also be a function returning a pointer
+     *
+     * Example
+     * ```ts
+     * const atom = atom({ a: { b: 1 } })
+     * atom.reduceByPointer(atom.pointer.a.b, (b) => b + 1) // atom.get().a.b === 2
+     * atom.reduceByPointer((p) => p.a.b, (b) => b + 1) // atom.get().a.b === 2
+     * ```
+     */
+    reduceByPointer<S>(pointerOrFn: Pointer<S> | ((p: Pointer<State>) => Pointer<S>), reducer: (s: S) => S): void;
+    /**
+     * Sets the value at the given pointer
+     *
+     * @param pointerOrFn - A pointer to the desired path. Could also be a function returning a pointer
+     *
+     * Example
+     * ```ts
+     * const atom = atom({ a: { b: 1 } })
+     * atom.setByPointer(atom.pointer.a.b, 2) // atom.get().a.b === 2
+     * atom.setByPointer((p) => p.a.b, 2) // atom.get().a.b === 2
+     * ```
+     */
+    setByPointer<S>(pointerOrFn: Pointer<S> | ((p: Pointer<State>) => Pointer<S>), val: S): void;
+    private _checkUpdates;
+    private _getOrCreateScopeForPath;
+    private _onPointerValueChange;
+    /**
+     * Returns a new prism of the value at the provided path.
+     *
+     * @param pointer - The path to create the prism at.
+     *
+     * ```ts
+     * const pr = atom({ a: { b: 1 } }).pointerToPrism(atom.pointer.a.b)
+     * pr.getValue() // 1
+     * ```
+     */
+    pointerToPrism<P>(pointer: Pointer<P>): Prism<P>;
+}
+//# sourceMappingURL=Atom.d.ts.map

package/dist/Atom.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Atom.d.ts","sourceRoot":"","sources":["../src/Atom.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,mBAAmB,CAAA;AAC5C,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAOtC,OAAO,KAAK,EAAC,sBAAsB,EAAC,MAAM,kBAAkB,CAAA;AAqF5D;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,IAAI,CAAC,KAAK,CAAE,YAAW,sBAAsB;IAChE,OAAO,CAAC,aAAa,CAAO;IAK5B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAO;IAClC;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,CAA4C;IAE5E,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAER;gBAER,YAAY,EAAE,KAAK;IAK/B;;;;OAIG;IACH,GAAG,CAAC,QAAQ,EAAE,KAAK;IAOnB;;OAEG;IACH,GAAG,IAAI,KAAK;IAIZ;;;;;;;;;;;OAWG;IACH,YAAY,CAAC,CAAC,EACZ,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC,GAC5D,CAAC;IASJ;;OAEG;IACH,OAAO,CAAC,MAAM;IAId,MAAM,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,KAAK;IAIlC;;;;;;;;;;;OAWG;IACH,eAAe,CAAC,CAAC,EACf,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC,EAC7D,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC;IAWtB;;;;;;;;;;;OAWG;IACH,YAAY,CAAC,CAAC,EACZ,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC,EAC7D,GAAG,EAAE,CAAC;IAKR,OAAO,CAAC,aAAa;IAsBrB,OAAO,CAAC,wBAAwB;IAQhC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,iBAAiB,qCACgB,QAAQ,KAAK,CAAC,gCAC/B,IAAI,KACjB,CAAC,MAAM,IAAI,CAAC,CAWd;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,QAAQ,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,KAAK,IAAI,GAAG,MAAM,IAAI;IAI5C;;;;;;;;;OASG;IACH,cAAc,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC;CAWjD"}
+{"version":3,"file":"Atom.d.ts","sourceRoot":"","sources":["../src/Atom.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,mBAAmB,CAAA;AAC5C,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAOtC,OAAO,KAAK,EAAC,sBAAsB,EAAC,MAAM,kBAAkB,CAAA;AAqF5D;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,IAAI,CAAC,KAAK,CAAE,YAAW,sBAAsB;IAChE,OAAO,CAAC,aAAa,CAAO;IAK5B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAO;IAClC;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,CAA4C;IAE5E,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAER;gBAER,YAAY,EAAE,KAAK;IAK/B;;;;OAIG;IACH,GAAG,CAAC,QAAQ,EAAE,KAAK;IAOnB,GAAG,IAAI,KAAK;IAIZ;;;;;;;;;;;OAWG;IACH,YAAY,CAAC,CAAC,EACZ,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC,GAC5D,CAAC;IASJ;;OAEG;IACH,OAAO,CAAC,MAAM;IAId,MAAM,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,KAAK;IAIlC;;;;;;;;;;;OAWG;IACH,eAAe,CAAC,CAAC,EACf,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC,EAC7D,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC;IAWtB;;;;;;;;;;;OAWG;IACH,YAAY,CAAC,CAAC,EACZ,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC,EAC7D,GAAG,EAAE,CAAC;IAKR,OAAO,CAAC,aAAa;IAsBrB,OAAO,CAAC,wBAAwB;IAQhC,OAAO,CAAC,qBAAqB,CAW5B;IAED;;;;;;;;;OASG;IACH,cAAc,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC;CAWjD"}

package/dist/Atom.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Atom.test.d.ts.map

package/dist/Atom.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Atom.test.d.ts","sourceRoot":"","sources":["../src/Atom.test.ts"],"names":[],"mappings":""}

package/dist/PointerProxy.d.ts

@@ -1,33 +1,33 @@
-import type { Pointer } from './pointer';
-import type { Prism } from './prism/Interface';
-import type { PointerToPrismProvider } from './pointerToPrism';
-/**
- * Allows creating pointer-prisms where the pointer can be switched out.
- *
- * @remarks
- * This allows reacting not just to value changes at a certain pointer, but changes
- * to the proxied pointer too.
- */
-export default class PointerProxy<O extends {}> implements PointerToPrismProvider {
-    private readonly _currentPointerBox;
-    /**
-     * Convenience pointer pointing to the root of this PointerProxy.
-     *
-     * @remarks
-     * Allows convenient use of {@link pointerToPrism} and {@link val}.
-     */
-    readonly pointer: Pointer<O>;
-    constructor(currentPointer: Pointer<O>);
-    /**
-     * Sets the underlying pointer.
-     * @param p - The pointer to be proxied.
-     */
-    setPointer(p: Pointer<O>): void;
-    /**
-     * Returns a prism of the value at the provided sub-path of the proxied pointer.
-     *
-     * @param path - The path to create the prism at.
-     */
-    pointerToPrism<P>(pointer: Pointer<P>): Prism<P>;
-}
-//# sourceMappingURL=PointerProxy.d.ts.map
+import type { Pointer } from './pointer';
+import type { Prism } from './prism/Interface';
+import type { PointerToPrismProvider } from './pointerToPrism';
+/**
+ * Allows creating pointer-prisms where the pointer can be switched out.
+ *
+ * @remarks
+ * This allows reacting not just to value changes at a certain pointer, but changes
+ * to the proxied pointer too.
+ */
+export default class PointerProxy<O extends {}> implements PointerToPrismProvider {
+    private readonly _currentPointerBox;
+    /**
+     * Convenience pointer pointing to the root of this PointerProxy.
+     *
+     * @remarks
+     * Allows convenient use of {@link pointerToPrism} and {@link val}.
+     */
+    readonly pointer: Pointer<O>;
+    constructor(currentPointer: Pointer<O>);
+    /**
+     * Sets the underlying pointer.
+     * @param p - The pointer to be proxied.
+     */
+    setPointer(p: Pointer<O>): void;
+    /**
+     * Returns a prism of the value at the provided sub-path of the proxied pointer.
+     *
+     * @param path - The path to create the prism at.
+     */
+    pointerToPrism<P>(pointer: Pointer<P>): Prism<P>;
+}
+//# sourceMappingURL=PointerProxy.d.ts.map

package/dist/Ticker.d.ts

@@ -1,105 +1,105 @@
-type ICallback = (t: number) => void;
-/**
- * The number of ticks that can pass without any scheduled callbacks before the Ticker goes dormant. This is to prevent
- * the Ticker from staying active forever, even if there are no scheduled callbacks.
- *
- * Perhaps counting ticks vs. time is not the best way to do this. But it's a start.
- */
-export declare const EMPTY_TICKS_BEFORE_GOING_DORMANT: number;
-/**
- * The Ticker class helps schedule callbacks. Scheduled callbacks are executed per tick. Ticks can be triggered by an
- * external scheduling strategy, e.g. a raf.
- */
-export default class Ticker {
-    private _conf?;
-    private _scheduledForThisOrNextTick;
-    private _scheduledForNextTick;
-    private _timeAtCurrentTick;
-    private _ticking;
-    /**
-     * Whether the Ticker is dormant
-     */
-    private _dormant;
-    private _numberOfDormantTicks;
-    /**
-     * Whether the Ticker is dormant
-     */
-    get dormant(): boolean;
-    /**
-     * Counts up for every tick executed.
-     * Internally, this is used to measure ticks per second.
-     *
-     * This is "public" to TypeScript, because it's a tool for performance measurements.
-     * Consider this as experimental, and do not rely on it always being here in future releases.
-     */
-    __ticks: number;
-    constructor(_conf?: {
-        /**
-         * This is called when the Ticker goes dormant.
-         */
-        onDormant?: (() => void) | undefined;
-        /**
-         * This is called when the Ticker goes active.
-         */
-        onActive?: (() => void) | undefined;
-    } | undefined);
-    /**
-     * Registers for fn to be called either on this tick or the next tick.
-     *
-     * If `onThisOrNextTick()` is called while `Ticker.tick()` is running, the
-     * side effect _will_ be called within the running tick. If you don't want this
-     * behavior, you can use `onNextTick()`.
-     *
-     * Note that `fn` will be added to a `Set()`. Which means, if you call `onThisOrNextTick(fn)`
-     * with the same fn twice in a single tick, it'll only run once.
-     *
-     * @param fn - The function to be registered.
-     *
-     * @see offThisOrNextTick
-     */
-    onThisOrNextTick(fn: ICallback): void;
-    /**
-     * Registers a side effect to be called on the next tick.
-     *
-     * @param fn - The function to be registered.
-     *
-     * @see onThisOrNextTick
-     * @see offNextTick
-     */
-    onNextTick(fn: ICallback): void;
-    /**
-     * De-registers a fn to be called either on this tick or the next tick.
-     *
-     * @param fn - The function to be de-registered.
-     *
-     * @see onThisOrNextTick
-     */
-    offThisOrNextTick(fn: ICallback): void;
-    /**
-     * De-registers a fn to be called on the next tick.
-     *
-     * @param fn - The function to be de-registered.
-     *
-     * @see onNextTick
-     */
-    offNextTick(fn: ICallback): void;
-    /**
-     * The time at the start of the current tick if there is a tick in progress, otherwise defaults to
-     * `performance.now()`.
-     */
-    get time(): number;
-    private _goActive;
-    private _goDormant;
-    /**
-     * Triggers a tick which starts executing the callbacks scheduled for this tick.
-     *
-     * @param t - The time at the tick.
-     *
-     * @see onThisOrNextTick
-     * @see onNextTick
-     */
-    tick(t?: number): void;
-    private _tick;
-}
-export {};
-//# sourceMappingURL=Ticker.d.ts.map
+type ICallback = (t: number) => void;
+/**
+ * The number of ticks that can pass without any scheduled callbacks before the Ticker goes dormant. This is to prevent
+ * the Ticker from staying active forever, even if there are no scheduled callbacks.
+ *
+ * Perhaps counting ticks vs. time is not the best way to do this. But it's a start.
+ */
+export declare const EMPTY_TICKS_BEFORE_GOING_DORMANT: number;
+/**
+ * The Ticker class helps schedule callbacks. Scheduled callbacks are executed per tick. Ticks can be triggered by an
+ * external scheduling strategy, e.g. a raf.
+ */
+export default class Ticker {
+    private _conf?;
+    private _scheduledForThisOrNextTick;
+    private _scheduledForNextTick;
+    private _timeAtCurrentTick;
+    private _ticking;
+    /**
+     * Whether the Ticker is dormant
+     */
+    private _dormant;
+    private _numberOfDormantTicks;
+    /**
+     * Whether the Ticker is dormant
+     */
+    get dormant(): boolean;
+    /**
+     * Counts up for every tick executed.
+     * Internally, this is used to measure ticks per second.
+     *
+     * This is "public" to TypeScript, because it's a tool for performance measurements.
+     * Consider this as experimental, and do not rely on it always being here in future releases.
+     */
+    __ticks: number;
+    constructor(_conf?: {
+        /**
+         * This is called when the Ticker goes dormant.
+         */
+        onDormant?: (() => void) | undefined;
+        /**
+         * This is called when the Ticker goes active.
+         */
+        onActive?: (() => void) | undefined;
+    } | undefined);
+    /**
+     * Registers for fn to be called either on this tick or the next tick.
+     *
+     * If `onThisOrNextTick()` is called while `Ticker.tick()` is running, the
+     * side effect _will_ be called within the running tick. If you don't want this
+     * behavior, you can use `onNextTick()`.
+     *
+     * Note that `fn` will be added to a `Set()`. Which means, if you call `onThisOrNextTick(fn)`
+     * with the same fn twice in a single tick, it'll only run once.
+     *
+     * @param fn - The function to be registered.
+     *
+     * @see offThisOrNextTick
+     */
+    onThisOrNextTick(fn: ICallback): void;
+    /**
+     * Registers a side effect to be called on the next tick.
+     *
+     * @param fn - The function to be registered.
+     *
+     * @see onThisOrNextTick
+     * @see offNextTick
+     */
+    onNextTick(fn: ICallback): void;
+    /**
+     * De-registers a fn to be called either on this tick or the next tick.
+     *
+     * @param fn - The function to be de-registered.
+     *
+     * @see onThisOrNextTick
+     */
+    offThisOrNextTick(fn: ICallback): void;
+    /**
+     * De-registers a fn to be called on the next tick.
+     *
+     * @param fn - The function to be de-registered.
+     *
+     * @see onNextTick
+     */
+    offNextTick(fn: ICallback): void;
+    /**
+     * The time at the start of the current tick if there is a tick in progress, otherwise defaults to
+     * `performance.now()`.
+     */
+    get time(): number;
+    private _goActive;
+    private _goDormant;
+    /**
+     * Triggers a tick which starts executing the callbacks scheduled for this tick.
+     *
+     * @param t - The time at the tick.
+     *
+     * @see onThisOrNextTick
+     * @see onNextTick
+     */
+    tick(t?: number): void;
+    private _tick;
+}
+export {};
+//# sourceMappingURL=Ticker.d.ts.map

package/dist/Ticker.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Ticker.test.d.ts.map

package/dist/Ticker.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Ticker.test.d.ts","sourceRoot":"","sources":["../src/Ticker.test.ts"],"names":[],"mappings":""}

package/dist/atom.typeTest.d.ts

@@ -1,2 +1,2 @@
-export {};
-//# sourceMappingURL=atom.typeTest.d.ts.map
+export {};
+//# sourceMappingURL=atom.typeTest.d.ts.map

package/dist/dataverse.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=dataverse.test.d.ts.map

package/dist/dataverse.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataverse.test.d.ts","sourceRoot":"","sources":["../src/dataverse.test.ts"],"names":[],"mappings":""}

package/dist/index.d.ts

@@ -1,19 +1,19 @@
-/**
- * The animation-optimized FRP library powering the internals of Theatre.js.
- *
- * @packageDocumentation
- */
-export type { PointerToPrismProvider } from './pointerToPrism';
-export { default as Atom } from './Atom';
-export { val } from './val';
-export { pointerToPrism } from './pointerToPrism';
-export { isPrism } from './prism/Interface';
-export type { Prism } from './prism/Interface';
-export { default as iterateAndCountTicks } from './prism/iterateAndCountTicks';
-export { default as iterateOver } from './prism/iterateOver';
-export { default as prism } from './prism/prism';
-export { default as pointer, getPointerParts, isPointer } from './pointer';
-export type { Pointer, PointerType, PointerMeta } from './pointer';
-export { default as Ticker } from './Ticker';
-export { default as PointerProxy } from './PointerProxy';
-//# sourceMappingURL=index.d.ts.map
+/**
+ * The animation-optimized FRP library powering the internals of Theatre.js.
+ *
+ * @packageDocumentation
+ */
+export type { PointerToPrismProvider } from './pointerToPrism';
+export { default as Atom } from './Atom';
+export { val } from './val';
+export { pointerToPrism } from './pointerToPrism';
+export { isPrism } from './prism/Interface';
+export type { Prism } from './prism/Interface';
+export { default as iterateAndCountTicks } from './prism/iterateAndCountTicks';
+export { default as iterateOver } from './prism/iterateOver';
+export { default as prism } from './prism/prism';
+export { default as pointer, getPointerParts, isPointer } from './pointer';
+export type { Pointer, PointerType, PointerMeta } from './pointer';
+export { default as Ticker } from './Ticker';
+export { default as PointerProxy } from './PointerProxy';
+//# sourceMappingURL=index.d.ts.map