@pond-ts/process 0.54.0

package/dist/port.js

@@ -0,0 +1,222 @@
+/**
+ * Typed ports and the wiring between them.
+ *
+ * An `Outlet<T>` is a node's typed output; an `Inlet<T>` is a typed
+ * input. Because both are generic in the value type and the connect
+ * signatures require a matching `T`, wiring a `string` output into a
+ * `number` input is a compile error rather than a runtime surprise.
+ *
+ * Ports also carry the evaluation state. Each outlet holds the cached
+ * value plus a **version stamp** that increments only when a recomputed
+ * value actually differs (per the port's `equals`). Nodes record the
+ * input versions they last computed against, which is what lets a node
+ * that was marked dirty skip recomputation when nothing upstream really
+ * changed. See `node.ts` for the pull algorithm that uses this.
+ */
+import { CycleError, MissingOutputError, UnconnectedInputError, } from './errors.js';
+/** A node's typed output port. */
+export class Outlet {
+    name;
+    /** The node this output belongs to. */
+    node;
+    #value;
+    #hasValue = false;
+    #version = 0;
+    #equals;
+    #downstream = new Set();
+    /** @internal Constructed by `Node`; not part of the public surface. */
+    constructor(node, name, equals) {
+        this.node = node;
+        this.name = name;
+        this.#equals = equals ?? Object.is;
+    }
+    /**
+     * Evaluates this outlet and returns its value.
+     *
+     * Pull-based: the owning node recomputes only if it is dirty *and* an
+     * upstream version actually changed. A clean node returns the cached
+     * value without touching the rest of the graph.
+     */
+    get() {
+        this.node.ensureFresh();
+        if (!this.#hasValue) {
+            throw new MissingOutputError(`Node '${this.node.kind}' produced no value for output '${this.name}'`);
+        }
+        return this.#value;
+    }
+    /**
+     * Returns the cached value without evaluating anything, or `undefined`
+     * if this outlet has never produced one. Use it to inspect graph state
+     * (a debug view, a node inspector) without forcing computation.
+     */
+    peek() {
+        return this.#value;
+    }
+    /**
+     * How many times this outlet's value has actually changed. Downstream
+     * nodes compare against this to decide whether a dirty mark was a real
+     * change or a false alarm. `0` means nothing has been produced yet.
+     */
+    get version() {
+        return this.#version;
+    }
+    /** The inlets this outlet feeds. */
+    get connections() {
+        return [...this.#downstream];
+    }
+    /**
+     * Wires this output into `inlet`.
+     *
+     * @throws {CycleError} if the edge would close a cycle.
+     */
+    connect(inlet) {
+        link(this, inlet);
+        return this;
+    }
+    /** Removes the edge to `inlet`, if present. */
+    disconnect(inlet) {
+        if (this.#downstream.has(inlet))
+            unlink(inlet);
+        return this;
+    }
+    /** @internal Stores a computed value, bumping the version iff it changed. */
+    produce(value) {
+        if (this.#hasValue && this.#equals(this.#value, value))
+            return;
+        this.#value = value;
+        this.#hasValue = true;
+        this.#version += 1;
+    }
+    /** @internal */
+    invalidateDownstream() {
+        for (const inlet of this.#downstream)
+            inlet.node.markDirty();
+    }
+    /** @internal */
+    addDownstream(inlet) {
+        this.#downstream.add(inlet);
+    }
+    /** @internal */
+    removeDownstream(inlet) {
+        this.#downstream.delete(inlet);
+    }
+}
+/** A node's typed input port. */
+export class Inlet {
+    name;
+    /** The node this input belongs to. */
+    node;
+    #source;
+    #defaultValue;
+    #hasDefault;
+    /** @internal Constructed by `Node`; not part of the public surface. */
+    constructor(node, name, defaultValue) {
+        this.node = node;
+        this.name = name;
+        this.#defaultValue = defaultValue;
+        this.#hasDefault = defaultValue !== undefined;
+    }
+    /**
+     * Wires `outlet` into this input, replacing any existing connection.
+     *
+     * @throws {CycleError} if the edge would close a cycle.
+     */
+    connect(outlet) {
+        link(outlet, this);
+        return this;
+    }
+    /** Removes the incoming edge, if any. Falls back to the default value. */
+    disconnect() {
+        unlink(this);
+        return this;
+    }
+    /** Whether an outlet is wired into this input. */
+    get connected() {
+        return this.#source !== undefined;
+    }
+    /** The outlet feeding this input, or `undefined` if unconnected. */
+    get source() {
+        return this.#source;
+    }
+    /**
+     * Pulls the upstream value, evaluating it if stale.
+     *
+     * @throws {UnconnectedInputError} if unconnected and no default was declared.
+     */
+    get() {
+        if (this.#source !== undefined)
+            return this.#source.get();
+        if (this.#hasDefault)
+            return this.#defaultValue;
+        throw new UnconnectedInputError(`Input '${this.name}' of node '${this.node.kind}' is not connected and has no default value`);
+    }
+    /**
+     * The version of the upstream outlet, or `0` when unconnected. Nodes
+     * record this to detect real changes.
+     *
+     * @internal
+     */
+    sourceVersion() {
+        return this.#source?.version ?? 0;
+    }
+    /** @internal */
+    setSource(outlet) {
+        this.#source = outlet;
+    }
+}
+/**
+ * Creates the edge `outlet -> inlet`, replacing whatever the inlet was
+ * connected to. Both `Outlet.connect` and `Inlet.connect` route here, so
+ * the two directions can't drift apart.
+ */
+function link(outlet, inlet) {
+    if (inlet.source === outlet)
+        return;
+    if (wouldCycle(outlet.node, inlet.node)) {
+        throw new CycleError(`Connecting '${outlet.node.kind}.${outlet.name}' to '${inlet.node.kind}.${inlet.name}' would create a cycle`);
+    }
+    unlink(inlet);
+    inlet.setSource(outlet);
+    outlet.addDownstream(inlet);
+    // `invalidate()`, not `markDirty()`: version stamps are per-outlet but
+    // recorded per-inlet-name, so rewiring an inlet to a *different*
+    // outlet that happens to sit at the same version number would look
+    // like "nothing changed" and serve a stale cached value. A structural
+    // change forces the recompute; the equality check in `produce()` still
+    // stops the cascade there if the new value matches the old.
+    inlet.node.invalidate();
+}
+/** Removes the edge feeding `inlet`, if any. */
+function unlink(inlet) {
+    const current = inlet.source;
+    if (current === undefined)
+        return;
+    current.removeDownstream(inlet);
+    inlet.setSource(undefined);
+    inlet.node.invalidate();
+}
+/**
+ * Whether `consumer` is reachable by walking upstream from `producer` —
+ * i.e. whether feeding `producer`'s output into `consumer` would close a
+ * loop. Runs at connect time, so the graph is acyclic by construction
+ * and evaluation never has to guard against infinite recursion.
+ */
+function wouldCycle(producer, consumer) {
+    const seen = new Set();
+    const stack = [producer];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (current === consumer)
+            return true;
+        if (seen.has(current))
+            continue;
+        seen.add(current);
+        for (const inlet of current.inletList()) {
+            const upstream = inlet.source;
+            if (upstream !== undefined)
+                stack.push(upstream.node);
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=port.js.map

package/dist/source.d.ts

@@ -0,0 +1,161 @@
+/**
+ * Entry points into a graph: nodes with no inputs whose value comes from
+ * outside.
+ */
+import { TimeSeries } from 'pond-ts';
+import type { EventForSchema, SeriesSchema } from 'pond-ts';
+import { ProcessError } from './errors.js';
+import { Node } from './node.js';
+import type { PortSpec } from './types.js';
+/**
+ * Spec map for a node that declares no inputs.
+ *
+ * `never` rather than `PortSpec<never>`: `PortSpec` is invariant in its
+ * value type, so `PortSpec<never>` does not satisfy the `PortSpec<any>`
+ * element constraint, while bare `never` is assignable to anything.
+ */
+export type NoInputs = Readonly<Record<string, never>>;
+/** Thrown when a source is pulled before a value has been set. */
+export declare class UnsetSourceError extends ProcessError {
+}
+/**
+ * A graph input whose value is pushed in from outside via {@link set}.
+ *
+ * Setting an equal value (per the port's `equals`) does not bump the
+ * output version, so downstream nodes revalidate and then skip their own
+ * work — no cascade.
+ */
+export declare class SourceNode<T> extends Node<NoInputs, {
+    readonly value: PortSpec<T>;
+}> {
+    #private;
+    constructor(options: {
+        readonly kind?: string;
+        readonly initial?: T;
+        readonly equals?: (a: T, b: T) => boolean;
+    });
+    /** The current value, or `undefined` if none has been set. */
+    get value(): T | undefined;
+    /** Replaces the value and invalidates everything downstream. */
+    set(value: T): this;
+}
+/**
+ * Creates a settable graph input.
+ *
+ * ```ts
+ * const raw = source<TimeSeries<Schema>>();
+ * raw.set(series);
+ * ```
+ */
+export declare function source<T>(options?: {
+    readonly kind?: string;
+    readonly initial?: T;
+    readonly equals?: (a: T, b: T) => boolean;
+}): SourceNode<T>;
+/**
+ * What {@link fromLive} needs from a pond live source: enough to
+ * materialize a snapshot, and a way to hear that one is due.
+ *
+ * Looser than core's `LiveSource<S>` in exactly one place — the
+ * `'event'` listener's parameter is `any`. That is not laziness: this
+ * package never reads the event, it only needs the notification, and
+ * core's incremental operators type that listener differently.
+ * `LiveAggregation.on('event', …)` hands back a widened `ClosedEvent`
+ * rather than a schema-narrowed `EventForSchema<Out>`, so it does not
+ * satisfy `LiveSource<Out>` structurally. Requiring the exact interface
+ * would reject precisely the sources worth binding (see {@link fromLive}).
+ *
+ * `LiveSeries`, `LiveView`, `LiveAggregation`, `LiveRollingAggregation`,
+ * and `LiveFusedRolling` all match this.
+ */
+export interface GraphSource<S extends SeriesSchema> {
+    readonly name: string;
+    readonly schema: S;
+    readonly length: number;
+    at(index: number): EventForSchema<S> | undefined;
+    on(type: 'event', fn: (event: any) => void): () => void;
+}
+/**
+ * A live source that can snapshot itself to the batch layer in one call.
+ * `LiveSeries` and `LiveView` match; the incremental operators do not.
+ */
+export interface SnapshotSource<S extends SeriesSchema> extends GraphSource<S> {
+    toTimeSeries(name?: string): TimeSeries<S>;
+}
+/**
+ * A graph input backed by a pond live source. Snapshots lazily; call
+ * {@link dispose} to unsubscribe.
+ */
+export declare class LiveSourceNode<S extends SeriesSchema> extends Node<NoInputs, {
+    readonly value: PortSpec<TimeSeries<S>>;
+}> {
+    #private;
+    constructor(live: GraphSource<S>, options: {
+        readonly kind?: string;
+    });
+    /** Stops listening. The node keeps its last snapshot. */
+    dispose(): void;
+    /** Whether this node is still subscribed. */
+    get subscribed(): boolean;
+}
+/**
+ * Binds a pond live source into a graph.
+ *
+ * Incoming events **invalidate** the node; they do not snapshot. The
+ * `toTimeSeries()` call happens when something pulls, so a burst of
+ * events costs one dirty mark each (O(1) after the first, since dirty
+ * propagation cuts off at already-dirty nodes) and exactly one snapshot
+ * at the next pull — not one snapshot per event.
+ *
+ * That keeps the graph on the right side of pond's split: incremental
+ * per-event computation stays in the live layer, and the graph composes
+ * whole-value batch transforms over snapshots.
+ *
+ * ```ts
+ * const feed = fromLive(liveSeries);
+ * const hourly = derive({ s: feed.out.value }, ({ s }) =>
+ *   s.aggregate(Sequence.every('1h'), { cpu: 'avg' }),
+ * );
+ * // ... events arrive ...
+ * hourly.out.value.get(); // one snapshot, one aggregate
+ * feed.dispose();
+ * ```
+ *
+ * ## Bind the aggregation, not the buffer
+ *
+ * The graph has no partial invalidation: a dirty node recomputes from a
+ * whole snapshot, so the pipeline above re-aggregates every retained
+ * event on every pull even though only the tail moved. Push the windowed
+ * work down into the live layer instead, and bind *its* output:
+ *
+ * ```ts
+ * const feed = fromLive(liveSeries.aggregate(Sequence.every('1h'), { cpu: 'avg' }));
+ * const peak = derive({ s: feed.out.value }, ({ s }) => s.column('cpu').max());
+ * ```
+ *
+ * `LiveAggregation` keeps its buckets current per event, so a pull
+ * materializes bucket count rather than event count. Measured at 200k
+ * events through a 50k-event buffer, pulling every 1k events: **9.05 ms
+ * per pull re-aggregating the buffer, 0.04 ms per pull off the live
+ * aggregation — 235x.** The gap widens with buffer size, because the
+ * first is O(retained events) and the second is O(buckets).
+ *
+ * **This is a semantic change, not just a faster path.** A live
+ * aggregation exposes *closed* buckets. Data is the clock, so the
+ * newest bucket stays invisible until an event crosses its end, while
+ * re-aggregating the raw buffer includes that partial tail bucket
+ * immediately. Two hours of minute data ending at 1h59m reads as one
+ * row through the aggregation and two through the buffer. If the
+ * current, still-filling bucket has to be on screen, keep
+ * re-aggregating the buffer and pay for it — or drive emission with a
+ * `Trigger` so buckets close on a schedule you control.
+ *
+ * This is why `fromLive` takes a {@link GraphSource} rather than a
+ * {@link SnapshotSource}: the incremental operators are precisely the
+ * ones without a `toTimeSeries()` method, and excluding them would rule
+ * out the only answer to the cost above.
+ */
+export declare function fromLive<S extends SeriesSchema>(live: GraphSource<S>, options?: {
+    readonly kind?: string;
+}): LiveSourceNode<S>;
+//# sourceMappingURL=source.d.ts.map

package/dist/source.js

@@ -0,0 +1,182 @@
+/**
+ * Entry points into a graph: nodes with no inputs whose value comes from
+ * outside.
+ */
+import { TimeSeries } from 'pond-ts';
+import { ProcessError } from './errors.js';
+import { Node } from './node.js';
+/** Thrown when a source is pulled before a value has been set. */
+export class UnsetSourceError extends ProcessError {
+}
+/**
+ * A graph input whose value is pushed in from outside via {@link set}.
+ *
+ * Setting an equal value (per the port's `equals`) does not bump the
+ * output version, so downstream nodes revalidate and then skip their own
+ * work — no cascade.
+ */
+export class SourceNode extends Node {
+    #state;
+    constructor(options) {
+        // The state cell is created before `super()` so `compute` can close
+        // over it — a derived constructor cannot touch `this` until the
+        // base constructor returns.
+        const state = {
+            value: options.initial,
+            hasValue: options.initial !== undefined,
+        };
+        const valuePort = options.equals
+            ? { equals: options.equals }
+            : {};
+        super({
+            kind: options.kind ?? 'source',
+            inputs: {},
+            outputs: { value: valuePort },
+            compute: () => {
+                if (!state.hasValue) {
+                    throw new UnsetSourceError('Source has no value — call set() before pulling from it');
+                }
+                return { value: state.value };
+            },
+        });
+        this.#state = state;
+    }
+    /** The current value, or `undefined` if none has been set. */
+    get value() {
+        return this.#state.value;
+    }
+    /** Replaces the value and invalidates everything downstream. */
+    set(value) {
+        this.#state.value = value;
+        this.#state.hasValue = true;
+        this.invalidate();
+        return this;
+    }
+}
+/**
+ * Creates a settable graph input.
+ *
+ * ```ts
+ * const raw = source<TimeSeries<Schema>>();
+ * raw.set(series);
+ * ```
+ */
+export function source(options = {}) {
+    return new SourceNode(options);
+}
+/** Whether a live source can snapshot itself. */
+function canSnapshot(live) {
+    return typeof live.toTimeSeries === 'function';
+}
+/**
+ * Snapshots any live source to the batch layer.
+ *
+ * Prefers the source's own `toTimeSeries()`, which reads columns. The
+ * `at()` fallback walks events, which pond's design notes call a bug in
+ * a bulk path — and it would be, against a raw buffer. It only runs for
+ * sources that have no snapshot method, and those are the *aggregation*
+ * outputs, whose length is bucket count rather than event count. Walking
+ * 24 hourly buckets is not the same act as walking 200k events.
+ */
+function snapshot(live) {
+    if (canSnapshot(live))
+        return live.toTimeSeries();
+    const events = [];
+    for (let index = 0; index < live.length; index += 1) {
+        const event = live.at(index);
+        if (event !== undefined)
+            events.push(event);
+    }
+    return TimeSeries.fromEvents(events, {
+        name: live.name,
+        schema: live.schema,
+    });
+}
+/**
+ * A graph input backed by a pond live source. Snapshots lazily; call
+ * {@link dispose} to unsubscribe.
+ */
+export class LiveSourceNode extends Node {
+    #unsubscribe;
+    constructor(live, options) {
+        super({
+            kind: options.kind ?? 'liveSource',
+            inputs: {},
+            outputs: { value: {} },
+            compute: () => ({ value: snapshot(live) }),
+        });
+        this.#unsubscribe = live.on('event', () => {
+            this.invalidate();
+        });
+    }
+    /** Stops listening. The node keeps its last snapshot. */
+    dispose() {
+        this.#unsubscribe?.();
+        this.#unsubscribe = undefined;
+    }
+    /** Whether this node is still subscribed. */
+    get subscribed() {
+        return this.#unsubscribe !== undefined;
+    }
+}
+/**
+ * Binds a pond live source into a graph.
+ *
+ * Incoming events **invalidate** the node; they do not snapshot. The
+ * `toTimeSeries()` call happens when something pulls, so a burst of
+ * events costs one dirty mark each (O(1) after the first, since dirty
+ * propagation cuts off at already-dirty nodes) and exactly one snapshot
+ * at the next pull — not one snapshot per event.
+ *
+ * That keeps the graph on the right side of pond's split: incremental
+ * per-event computation stays in the live layer, and the graph composes
+ * whole-value batch transforms over snapshots.
+ *
+ * ```ts
+ * const feed = fromLive(liveSeries);
+ * const hourly = derive({ s: feed.out.value }, ({ s }) =>
+ *   s.aggregate(Sequence.every('1h'), { cpu: 'avg' }),
+ * );
+ * // ... events arrive ...
+ * hourly.out.value.get(); // one snapshot, one aggregate
+ * feed.dispose();
+ * ```
+ *
+ * ## Bind the aggregation, not the buffer
+ *
+ * The graph has no partial invalidation: a dirty node recomputes from a
+ * whole snapshot, so the pipeline above re-aggregates every retained
+ * event on every pull even though only the tail moved. Push the windowed
+ * work down into the live layer instead, and bind *its* output:
+ *
+ * ```ts
+ * const feed = fromLive(liveSeries.aggregate(Sequence.every('1h'), { cpu: 'avg' }));
+ * const peak = derive({ s: feed.out.value }, ({ s }) => s.column('cpu').max());
+ * ```
+ *
+ * `LiveAggregation` keeps its buckets current per event, so a pull
+ * materializes bucket count rather than event count. Measured at 200k
+ * events through a 50k-event buffer, pulling every 1k events: **9.05 ms
+ * per pull re-aggregating the buffer, 0.04 ms per pull off the live
+ * aggregation — 235x.** The gap widens with buffer size, because the
+ * first is O(retained events) and the second is O(buckets).
+ *
+ * **This is a semantic change, not just a faster path.** A live
+ * aggregation exposes *closed* buckets. Data is the clock, so the
+ * newest bucket stays invisible until an event crosses its end, while
+ * re-aggregating the raw buffer includes that partial tail bucket
+ * immediately. Two hours of minute data ending at 1h59m reads as one
+ * row through the aggregation and two through the buffer. If the
+ * current, still-filling bucket has to be on screen, keep
+ * re-aggregating the buffer and pay for it — or drive emission with a
+ * `Trigger` so buckets close on a schedule you control.
+ *
+ * This is why `fromLive` takes a {@link GraphSource} rather than a
+ * {@link SnapshotSource}: the incremental operators are precisely the
+ * ones without a `toTimeSeries()` method, and excluding them would rule
+ * out the only answer to the cost above.
+ */
+export function fromLive(live, options = {}) {
+    return new LiveSourceNode(live, options);
+}
+//# sourceMappingURL=source.js.map

package/dist/types.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Port declarations and the type-level plumbing that turns them into
+ * typed inlet / outlet maps on a node.
+ *
+ * A `PortSpec<T>` is a compile-time declaration: it carries the port's
+ * value type and, optionally, the equality used to decide whether a
+ * recomputed value counts as *changed* (see `Outlet` version stamping
+ * in `port.ts`). At runtime a spec is a plain object — usually empty.
+ */
+/**
+ * Declares one port's value type.
+ *
+ * `valueType` is a phantom marker: never set at runtime, present only so
+ * `T` is inferable from a spec (`PortSpec<infer T>`). Together with the
+ * `equals` parameter position it also makes `PortSpec` invariant in `T`,
+ * so a `PortSpec<string>` is not silently accepted where a
+ * `PortSpec<number>` is required.
+ */
+export interface PortSpec<T> {
+    /**
+     * Decides whether a newly computed value differs from the cached one.
+     * Returning `true` suppresses the version bump, so every downstream
+     * node skips recomputation even though it was marked dirty.
+     *
+     * It also **keeps the previously cached value** — the newly computed
+     * one is discarded. That is what makes the cutoff work (downstream
+     * `Object.is` checks still see the same reference), but it means a
+     * loose `equals` loses data: an `equals` comparing only an `id` field
+     * will keep serving the old object after the rest of it changed.
+     * Compare everything a consumer can observe.
+     *
+     * Defaults to `Object.is`. For immutable pond values (`TimeSeries`,
+     * `Event`) identity is the right test — a transform that genuinely
+     * changed something returns a new instance. Supply a structural
+     * comparison when a node produces scalars or small records, where
+     * "same number as last time" is common and downstream work is not
+     * free.
+     */
+    readonly equals?: (a: T, b: T) => boolean;
+    /**
+     * Value used when the inlet is left unconnected. Without it, pulling
+     * through an unconnected inlet throws `UnconnectedInputError`.
+     *
+     * Outputs ignore this field.
+     */
+    readonly defaultValue?: T;
+    /** Phantom type marker. Never present at runtime. */
+    readonly valueType?: T;
+}
+/**
+ * A named set of port declarations, as passed to {@link defineNode}.
+ *
+ * `PortSpec<any>` is deliberate: `PortSpec` is invariant in its value
+ * type, so a bounded element type (`unknown`, `never`) would reject
+ * every concrete spec. The constraint exists to pin the *shape*; the
+ * per-port types are recovered by inference through {@link PortValues}.
+ */
+export type PortSpecMap = Readonly<Record<string, PortSpec<any>>>;
+/** Extracts the value type carried by a {@link PortSpec}. */
+export type PortValue<P> = P extends PortSpec<infer T> ? T : never;
+/** Maps a spec map to the plain value record `compute` receives / returns. */
+export type PortValues<M> = {
+    [K in keyof M]: PortValue<M[K]>;
+};
+/**
+ * Declares a port of type `T`.
+ *
+ * ```ts
+ * inputs: { series: port<TimeSeries<Schema>>() },
+ * outputs: { mean: port<number>({ equals: (a, b) => a === b }) },
+ * ```
+ */
+export declare function port<T>(options?: {
+    readonly equals?: (a: T, b: T) => boolean;
+    readonly defaultValue?: T;
+}): PortSpec<T>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1,26 @@
+/**
+ * Port declarations and the type-level plumbing that turns them into
+ * typed inlet / outlet maps on a node.
+ *
+ * A `PortSpec<T>` is a compile-time declaration: it carries the port's
+ * value type and, optionally, the equality used to decide whether a
+ * recomputed value counts as *changed* (see `Outlet` version stamping
+ * in `port.ts`). At runtime a spec is a plain object — usually empty.
+ */
+/**
+ * Declares a port of type `T`.
+ *
+ * ```ts
+ * inputs: { series: port<TimeSeries<Schema>>() },
+ * outputs: { mean: port<number>({ equals: (a, b) => a === b }) },
+ * ```
+ */
+export function port(options = {}) {
+    const spec = {};
+    if (options.equals !== undefined)
+        spec.equals = options.equals;
+    if (options.defaultValue !== undefined)
+        spec.defaultValue = options.defaultValue;
+    return spec;
+}
+//# sourceMappingURL=types.js.map