xstate 4.20.1 → 4.23.1

package/lib/invoke.d.ts

@@ -1,11 +1,11 @@
-export interface InvokedPromiseOptions {
-    id?: string;
-}
-export interface PromiseMachineSchema {
-    states: {
-        pending: {};
-        resolved: {};
-        rejected: {};
-    };
-}
+export interface InvokedPromiseOptions {
+    id?: string;
+}
+export interface PromiseMachineSchema {
+    states: {
+        pending: {};
+        resolved: {};
+        rejected: {};
+    };
+}
 //# sourceMappingURL=invoke.d.ts.map

package/lib/invokeUtils.d.ts

@@ -1,7 +1,7 @@
-import { EventObject, InvokeConfig, InvokeDefinition, InvokeSourceDefinition } from './types';
-export declare function toInvokeSource(src: string | InvokeSourceDefinition): InvokeSourceDefinition;
-export declare function toInvokeDefinition<TContext, TEvent extends EventObject>(invokeConfig: InvokeConfig<TContext, TEvent> & {
-    src: string | InvokeSourceDefinition;
-    id: string;
-}): InvokeDefinition<TContext, TEvent>;
+import { EventObject, InvokeConfig, InvokeDefinition, InvokeSourceDefinition } from './types';
+export declare function toInvokeSource(src: string | InvokeSourceDefinition): InvokeSourceDefinition;
+export declare function toInvokeDefinition<TContext, TEvent extends EventObject>(invokeConfig: InvokeConfig<TContext, TEvent> & {
+    src: string | InvokeSourceDefinition;
+    id: string;
+}): InvokeDefinition<TContext, TEvent>;
 //# sourceMappingURL=invokeUtils.d.ts.map

package/lib/invokeUtils.js

@@ -1,42 +1,45 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toInvokeDefinition = exports.toInvokeSource = void 0;
-var actions_1 = require("./actions");
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('./_virtual/_tslib.js');
+require('./environment.js');
+require('./utils.js');
+require('./types.js');
+var actionTypes = require('./actionTypes.js');
+
 function toInvokeSource(src) {
-    if (typeof src === 'string') {
-        var simpleSrc = { type: src };
-        simpleSrc.toString = function () { return src; }; // v4 compat - TODO: remove in v5
-        return simpleSrc;
-    }
-    return src;
+  if (typeof src === 'string') {
+    var simpleSrc = {
+      type: src
+    };
+
+    simpleSrc.toString = function () {
+      return src;
+    }; // v4 compat - TODO: remove in v5
+
+
+    return simpleSrc;
+  }
+
+  return src;
 }
-exports.toInvokeSource = toInvokeSource;
 function toInvokeDefinition(invokeConfig) {
-    return __assign(__assign({ type: actions_1.actionTypes.invoke }, invokeConfig), { toJSON: function () {
-            var onDone = invokeConfig.onDone, onError = invokeConfig.onError, invokeDef = __rest(invokeConfig, ["onDone", "onError"]);
-            return __assign(__assign({}, invokeDef), { type: actions_1.actionTypes.invoke, src: toInvokeSource(invokeConfig.src) });
-        } });
+  return _tslib.__assign(_tslib.__assign({
+    type: actionTypes.invoke
+  }, invokeConfig), {
+    toJSON: function () {
+      var onDone = invokeConfig.onDone,
+          onError = invokeConfig.onError,
+          invokeDef = _tslib.__rest(invokeConfig, ["onDone", "onError"]);
+
+      return _tslib.__assign(_tslib.__assign({}, invokeDef), {
+        type: actionTypes.invoke,
+        src: toInvokeSource(invokeConfig.src)
+      });
+    }
+  });
 }
+
 exports.toInvokeDefinition = toInvokeDefinition;
+exports.toInvokeSource = toInvokeSource;

package/lib/json.d.ts

@@ -1,31 +1,31 @@
-import { StateNode, ActionObject, Guard, InvokeDefinition } from './';
-interface JSONFunction {
-    $function: string;
-}
-export declare function stringifyFunction(fn: Function): JSONFunction;
-interface TransitionConfig {
-    target: string[];
-    source: string;
-    actions: Array<ActionObject<any, any>>;
-    cond: Guard<any, any> | undefined;
-    eventType: string;
-}
-interface StateNodeConfig {
-    type: StateNode['type'];
-    id: string;
-    key: string;
-    initial?: string;
-    entry: Array<ActionObject<any, any>>;
-    exit: Array<ActionObject<any, any>>;
-    on: {
-        [key: string]: TransitionConfig[];
-    };
-    invoke: Array<InvokeDefinition<any, any>>;
-    states: Record<string, StateNodeConfig>;
-}
-export declare function machineToJSON(stateNode: StateNode): StateNodeConfig;
-export declare function stringify(machine: StateNode): string;
-export declare function parse(machineString: string): StateNodeConfig;
-export declare function jsonify<T extends Record<string, any>>(value: T): T;
-export {};
+import { StateNode, ActionObject, Guard, InvokeDefinition } from './';
+interface JSONFunction {
+    $function: string;
+}
+export declare function stringifyFunction(fn: Function): JSONFunction;
+interface TransitionConfig {
+    target: string[];
+    source: string;
+    actions: Array<ActionObject<any, any>>;
+    cond: Guard<any, any> | undefined;
+    eventType: string;
+}
+interface StateNodeConfig {
+    type: StateNode['type'];
+    id: string;
+    key: string;
+    initial?: string;
+    entry: Array<ActionObject<any, any>>;
+    exit: Array<ActionObject<any, any>>;
+    on: {
+        [key: string]: TransitionConfig[];
+    };
+    invoke: Array<InvokeDefinition<any, any>>;
+    states: Record<string, StateNodeConfig>;
+}
+export declare function machineToJSON(stateNode: StateNode): StateNodeConfig;
+export declare function stringify(machine: StateNode): string;
+export declare function parse(machineString: string): StateNodeConfig;
+export declare function jsonify<T extends Record<string, any>>(value: T): T;
+export {};
 //# sourceMappingURL=json.d.ts.map

package/lib/mapState.d.ts

@@ -1,4 +1,4 @@
-export declare function mapState(stateMap: {
-    [stateId: string]: any;
-}, stateId: string): any;
+export declare function mapState(stateMap: {
+    [stateId: string]: any;
+}, stateId: string): any;
 //# sourceMappingURL=mapState.d.ts.map

package/lib/mapState.js

@@ -1,37 +1,36 @@
-"use strict";
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapState = void 0;
-var utils_1 = require("./utils");
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('./_virtual/_tslib.js');
+var utils = require('./utils.js');
+
 function mapState(stateMap, stateId) {
-    var e_1, _a;
-    var foundStateId;
-    try {
-        for (var _b = __values(utils_1.keys(stateMap)), _c = _b.next(); !_c.done; _c = _b.next()) {
-            var mappedStateId = _c.value;
-            if (utils_1.matchesState(mappedStateId, stateId) &&
-                (!foundStateId || stateId.length > foundStateId.length)) {
-                foundStateId = mappedStateId;
-            }
-        }
+  var e_1, _a;
+
+  var foundStateId;
+
+  try {
+    for (var _b = _tslib.__values(utils.keys(stateMap)), _c = _b.next(); !_c.done; _c = _b.next()) {
+      var mappedStateId = _c.value;
+
+      if (utils.matchesState(mappedStateId, stateId) && (!foundStateId || stateId.length > foundStateId.length)) {
+        foundStateId = mappedStateId;
+      }
     }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-        }
-        finally { if (e_1) throw e_1.error; }
+  } catch (e_1_1) {
+    e_1 = {
+      error: e_1_1
+    };
+  } finally {
+    try {
+      if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+    } finally {
+      if (e_1) throw e_1.error;
     }
-    return stateMap[foundStateId];
+  }
+
+  return stateMap[foundStateId];
 }
+
 exports.mapState = mapState;

package/lib/match.d.ts

@@ -1,9 +1,9 @@
-import { State } from './State';
-import { StateValue, EventObject } from './types';
-export declare type ValueFromStateGetter<T, TContext, TEvent extends EventObject> = (state: State<TContext, TEvent>) => T;
-export declare type StatePatternTuple<T, TContext, TEvent extends EventObject> = [
-    StateValue,
-    ValueFromStateGetter<T, TContext, TEvent>
-];
-export declare function matchState<T, TContext, TEvent extends EventObject>(state: State<TContext, TEvent> | StateValue, patterns: Array<StatePatternTuple<T, TContext, TEvent>>, defaultValue: ValueFromStateGetter<T, TContext, TEvent>): T;
+import { State } from './State';
+import { StateValue, EventObject } from './types';
+export declare type ValueFromStateGetter<T, TContext, TEvent extends EventObject> = (state: State<TContext, TEvent>) => T;
+export declare type StatePatternTuple<T, TContext, TEvent extends EventObject> = [
+    StateValue,
+    ValueFromStateGetter<T, TContext, TEvent>
+];
+export declare function matchState<T, TContext, TEvent extends EventObject>(state: State<TContext, TEvent> | StateValue, patterns: Array<StatePatternTuple<T, TContext, TEvent>>, defaultValue: ValueFromStateGetter<T, TContext, TEvent>): T;
 //# sourceMappingURL=match.d.ts.map

package/lib/match.js

@@ -1,52 +1,38 @@
-"use strict";
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.matchState = void 0;
-var State_1 = require("./State");
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('./_virtual/_tslib.js');
+var State = require('./State.js');
+
 function matchState(state, patterns, defaultValue) {
-    var e_1, _a;
-    var resolvedState = State_1.State.from(state, state instanceof State_1.State ? state.context : undefined);
-    try {
-        for (var patterns_1 = __values(patterns), patterns_1_1 = patterns_1.next(); !patterns_1_1.done; patterns_1_1 = patterns_1.next()) {
-            var _b = __read(patterns_1_1.value, 2), stateValue = _b[0], getValue = _b[1];
-            if (resolvedState.matches(stateValue)) {
-                return getValue(resolvedState);
-            }
-        }
+  var e_1, _a;
+
+  var resolvedState = State.State.from(state, state instanceof State.State ? state.context : undefined);
+
+  try {
+    for (var patterns_1 = _tslib.__values(patterns), patterns_1_1 = patterns_1.next(); !patterns_1_1.done; patterns_1_1 = patterns_1.next()) {
+      var _b = _tslib.__read(patterns_1_1.value, 2),
+          stateValue = _b[0],
+          getValue = _b[1];
+
+      if (resolvedState.matches(stateValue)) {
+        return getValue(resolvedState);
+      }
     }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (patterns_1_1 && !patterns_1_1.done && (_a = patterns_1.return)) _a.call(patterns_1);
-        }
-        finally { if (e_1) throw e_1.error; }
+  } catch (e_1_1) {
+    e_1 = {
+      error: e_1_1
+    };
+  } finally {
+    try {
+      if (patterns_1_1 && !patterns_1_1.done && (_a = patterns_1.return)) _a.call(patterns_1);
+    } finally {
+      if (e_1) throw e_1.error;
     }
-    return defaultValue(resolvedState);
+  }
+
+  return defaultValue(resolvedState);
 }
+
 exports.matchState = matchState;

package/lib/model.d.ts

@@ -1,39 +1,5 @@
-import type { AssignAction, Assigner, PropertyAssigner, ExtractEvent, EventObject } from './types';
-declare type AnyFunction = (...args: any[]) => any;
-declare type Cast<A1 extends any, A2 extends any> = A1 extends A2 ? A1 : A2;
-declare type Compute<A extends any> = {
-    [K in keyof A]: A[K];
-} & unknown;
-declare type Prop<T, K> = K extends keyof T ? T[K] : never;
-export interface Model<TContext, TEvent extends EventObject, TModelCreators = void> {
-    initialContext: TContext;
-    assign: <TEventType extends TEvent['type'] = TEvent['type']>(assigner: Assigner<TContext, ExtractEvent<TEvent, TEventType>> | PropertyAssigner<TContext, ExtractEvent<TEvent, TEventType>>, eventType?: TEventType) => AssignAction<TContext, ExtractEvent<TEvent, TEventType>>;
-    events: Prop<TModelCreators, 'events'>;
-    reset: () => AssignAction<TContext, any>;
-}
-export declare type ModelContextFrom<TModel extends Model<any, any, any>> = TModel extends Model<infer TContext, any, any> ? TContext : never;
-export declare type ModelEventsFrom<TModel extends Model<any, any, any>> = TModel extends Model<any, infer TEvent, any> ? TEvent : never;
-declare type EventCreator<Self extends AnyFunction, Return = ReturnType<Self>> = Return extends object ? Return extends {
-    type: any;
-} ? "An event creator can't return an object with a type property" : Self : 'An event creator must return an object';
-declare type EventCreators<Self> = {
-    [K in keyof Self]: Self[K] extends AnyFunction ? EventCreator<Self[K]> : 'An event creator must be a function';
-};
-declare type ModelCreators<Self> = {
-    events: EventCreators<Prop<Self, 'events'>>;
-};
-declare type FinalEventCreators<Self> = {
-    [K in keyof Self]: Self[K] extends AnyFunction ? (...args: Parameters<Self[K]>) => Compute<ReturnType<Self[K]> & {
-        type: K;
-    }> : never;
-};
-declare type FinalModelCreators<Self> = {
-    events: FinalEventCreators<Prop<Self, 'events'>>;
-};
-declare type EventFromEventCreators<EventCreators> = {
-    [K in keyof EventCreators]: EventCreators[K] extends AnyFunction ? ReturnType<EventCreators[K]> : never;
-}[keyof EventCreators];
-export declare function createModel<TContext, TEvent extends EventObject>(initialContext: TContext): Model<TContext, TEvent, void>;
-export declare function createModel<TContext, TModelCreators extends ModelCreators<TModelCreators>, TFinalModelCreators = FinalModelCreators<TModelCreators>>(initialContext: TContext, creators: TModelCreators): Model<TContext, Cast<EventFromEventCreators<Prop<TFinalModelCreators, 'events'>>, EventObject>, TFinalModelCreators>;
-export {};
+import type { EventObject } from './types';
+import { Cast, EventFromEventCreators, FinalModelCreators, Model, ModelCreators, Prop } from './model.types';
+export declare function createModel<TContext, TEvent extends EventObject>(initialContext: TContext): Model<TContext, TEvent, void>;
+export declare function createModel<TContext, TModelCreators extends ModelCreators<TModelCreators>, TFinalModelCreators = FinalModelCreators<TModelCreators>>(initialContext: TContext, creators: TModelCreators): Model<TContext, Cast<EventFromEventCreators<Prop<TFinalModelCreators, 'events'>>, EventObject>, TFinalModelCreators>;
 //# sourceMappingURL=model.d.ts.map

package/lib/model.js

@@ -34,6 +34,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createModel = void 0;
 var actions_1 = require("./actions");
+var Machine_1 = require("./Machine");
 var utils_1 = require("./utils");
 function createModel(initialContext, creators) {
     var eventCreators = creators === null || creators === void 0 ? void 0 : creators.events;
@@ -49,7 +50,10 @@ function createModel(initialContext, creators) {
                 return (__assign(__assign({}, fn.apply(void 0, __spreadArray([], __read(args)))), { type: eventType }));
             }; })
             : undefined),
-        reset: function () { return actions_1.assign(initialContext); }
+        reset: function () { return actions_1.assign(initialContext); },
+        createMachine: function (config, implementations) {
+            return Machine_1.createMachine('context' in config ? config : __assign(__assign({}, config), { context: initialContext }), implementations);
+        }
     };
     return model;
 }

package/lib/model.types.d.ts

@@ -0,0 +1,37 @@
+import { EventObject, Assigner, ExtractEvent, PropertyAssigner, AssignAction, MachineConfig, MachineOptions, StateMachine } from './types';
+export declare type AnyFunction = (...args: any[]) => any;
+export declare type Cast<A1 extends any, A2 extends any> = A1 extends A2 ? A1 : A2;
+export declare type Compute<A extends any> = {
+    [K in keyof A]: A[K];
+} & unknown;
+export declare type Prop<T, K> = K extends keyof T ? T[K] : never;
+export interface Model<TContext, TEvent extends EventObject, TModelCreators = void> {
+    initialContext: TContext;
+    assign: <TEventType extends TEvent['type'] = TEvent['type']>(assigner: Assigner<TContext, ExtractEvent<TEvent, TEventType>> | PropertyAssigner<TContext, ExtractEvent<TEvent, TEventType>>, eventType?: TEventType) => AssignAction<TContext, ExtractEvent<TEvent, TEventType>>;
+    events: Prop<TModelCreators, 'events'>;
+    reset: () => AssignAction<TContext, any>;
+    createMachine: (config: MachineConfig<TContext, any, TEvent>, implementations?: Partial<MachineOptions<TContext, TEvent>>) => StateMachine<TContext, any, TEvent>;
+}
+export declare type ModelContextFrom<TModel extends Model<any, any, any>> = TModel extends Model<infer TContext, any, any> ? TContext : never;
+export declare type ModelEventsFrom<TModel extends Model<any, any, any>> = TModel extends Model<any, infer TEvent, any> ? TEvent : never;
+export declare type EventCreator<Self extends AnyFunction, Return = ReturnType<Self>> = Return extends object ? Return extends {
+    type: any;
+} ? "An event creator can't return an object with a type property" : Self : 'An event creator must return an object';
+export declare type EventCreators<Self> = {
+    [K in keyof Self]: Self[K] extends AnyFunction ? EventCreator<Self[K]> : 'An event creator must be a function';
+};
+export declare type ModelCreators<Self> = {
+    events: EventCreators<Prop<Self, 'events'>>;
+};
+export declare type FinalEventCreators<Self> = {
+    [K in keyof Self]: Self[K] extends AnyFunction ? (...args: Parameters<Self[K]>) => Compute<ReturnType<Self[K]> & {
+        type: K;
+    }> : never;
+};
+export declare type FinalModelCreators<Self> = {
+    events: FinalEventCreators<Prop<Self, 'events'>>;
+};
+export declare type EventFromEventCreators<EventCreators> = {
+    [K in keyof EventCreators]: EventCreators[K] extends AnyFunction ? ReturnType<EventCreators[K]> : never;
+}[keyof EventCreators];
+//# sourceMappingURL=model.types.d.ts.map

package/lib/model.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/patterns.d.ts

@@ -1,14 +1,14 @@
-import { AtomicStateNodeConfig, StatesConfig, Event, EventObject, StateSchema } from './types';
-export declare function toggle<TEventType extends string = string>(onState: string, offState: string, eventType: TEventType): Record<string, AtomicStateNodeConfig<any, {
-    type: TEventType;
-}>>;
-interface SequencePatternOptions<TEvent extends EventObject> {
-    nextEvent: Event<TEvent> | undefined;
-    prevEvent: Event<TEvent> | undefined;
-}
-export declare function sequence<TStateSchema extends StateSchema, TEvent extends EventObject>(items: Array<keyof TStateSchema['states']>, options?: Partial<SequencePatternOptions<TEvent>>): {
-    initial: keyof TStateSchema['states'];
-    states: StatesConfig<any, TStateSchema, TEvent>;
-};
-export {};
+import { AtomicStateNodeConfig, StatesConfig, Event, EventObject, StateSchema } from './types';
+export declare function toggle<TEventType extends string = string>(onState: string, offState: string, eventType: TEventType): Record<string, AtomicStateNodeConfig<any, {
+    type: TEventType;
+}>>;
+interface SequencePatternOptions<TEvent extends EventObject> {
+    nextEvent: Event<TEvent> | undefined;
+    prevEvent: Event<TEvent> | undefined;
+}
+export declare function sequence<TStateSchema extends StateSchema, TEvent extends EventObject>(items: Array<keyof TStateSchema['states']>, options?: Partial<SequencePatternOptions<TEvent>>): {
+    initial: keyof TStateSchema['states'];
+    states: StatesConfig<any, TStateSchema, TEvent>;
+};
+export {};
 //# sourceMappingURL=patterns.d.ts.map

package/lib/registry.d.ts

@@ -1,9 +1,9 @@
-import { Actor } from './Actor';
-export interface Registry {
-    bookId(): string;
-    register(id: string, actor: Actor): string;
-    get(id: string): Actor | undefined;
-    free(id: string): void;
-}
-export declare const registry: Registry;
+import { Actor } from './Actor';
+export interface Registry {
+    bookId(): string;
+    register(id: string, actor: Actor): string;
+    get(id: string): Actor | undefined;
+    free(id: string): void;
+}
+export declare const registry: Registry;
 //# sourceMappingURL=registry.d.ts.map

package/lib/registry.js

@@ -1,20 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registry = void 0;
-var children = new Map();
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var children = /*#__PURE__*/new Map();
 var sessionIdIndex = 0;
-exports.registry = {
-    bookId: function () {
-        return "x:" + sessionIdIndex++;
-    },
-    register: function (id, actor) {
-        children.set(id, actor);
-        return id;
-    },
-    get: function (id) {
-        return children.get(id);
-    },
-    free: function (id) {
-        children.delete(id);
-    }
+var registry = {
+  bookId: function () {
+    return "x:" + sessionIdIndex++;
+  },
+  register: function (id, actor) {
+    children.set(id, actor);
+    return id;
+  },
+  get: function (id) {
+    return children.get(id);
+  },
+  free: function (id) {
+    children.delete(id);
+  }
 };
+
+exports.registry = registry;

package/lib/scheduler.d.ts

@@ -1,17 +1,17 @@
-interface SchedulerOptions {
-    deferEvents: boolean;
-}
-export declare class Scheduler {
-    private processingEvent;
-    private queue;
-    private initialized;
-    private options;
-    constructor(options?: Partial<SchedulerOptions>);
-    initialize(callback?: () => void): void;
-    schedule(task: () => void): void;
-    clear(): void;
-    private flushEvents;
-    private process;
-}
-export {};
+interface SchedulerOptions {
+    deferEvents: boolean;
+}
+export declare class Scheduler {
+    private processingEvent;
+    private queue;
+    private initialized;
+    private options;
+    constructor(options?: Partial<SchedulerOptions>);
+    initialize(callback?: () => void): void;
+    schedule(task: () => void): void;
+    clear(): void;
+    private flushEvents;
+    private process;
+}
+export {};
 //# sourceMappingURL=scheduler.d.ts.map