@pond-ts/process 0.54.0

package/dist/plan/run.js

@@ -0,0 +1,360 @@
+/**
+ * `run` — one entry point, one response. [PND-DEMOM0], [PND-PROCTERM].
+ *
+ * The request carries a plan **and** what it wants back. A renderer asks
+ * for columns; an agent asks for facts; a legend chip is a fact riding
+ * alongside columns in the same pass. Collapsing the request rather than
+ * forking the terminal is what makes that one call.
+ *
+ * Two things measured earlier are load-bearing here:
+ *
+ * - **Facts read node values directly.** Assembling a `TimeSeries` so a
+ *   reduction has a column to read cost 52× more, and 441× once facts
+ *   memoize. Assembly happens only when `columns` is asked for.
+ * - **Assembly resolves a closure.** "Needed" is not "selected with
+ *   `columns`": a reduction reads a column too, and `crossings`'s
+ *   `against` names a second one. Assembling only the column-selectors
+ *   produced a fact with *no value* rather than an error — silent, which
+ *   is worse than a throw.
+ */
+import { appendColumn } from '../column.js';
+import { ProcessError } from '../errors.js';
+import { columnsOf, explain, refToId, unitOf } from './identity.js';
+import { expandSlots } from './slots.js';
+import { specId } from './identity.js';
+import { specOf } from './types.js';
+// ── run ──────────────────────────────────────────────────────
+/**
+ * Reduces either request form to the one the resolver already handles.
+ *
+ * A slot request expands to exactly the nested plan its equivalent would
+ * have been written as, so both land on identical ids — that equality is
+ * the contract, and it is why nothing downstream of here knows slots
+ * exist ([PND-PROCSLOT]).
+ */
+function normalize(graph, request) {
+    if (!('nodes' in request)) {
+        return {
+            plan: request.plan,
+            select: request.select ?? [],
+            slotOf: new Map(),
+        };
+    }
+    const columns = graph.series.schema.slice(1).map((c) => c.name);
+    const expanded = expandSlots(request.nodes, columns);
+    // First slot wins. Two slots may legally resolve to ONE id — the
+    // registry-free builder cannot canonicalize defaults, so `shape()`
+    // and `shape({points: 40})` arrive as two slots naming the same
+    // computation. Attribution must not depend on which happened to be
+    // declared last; "the first slot to name it labels it" is the rule.
+    const slotOf = new Map();
+    for (const [slot, spec] of expanded) {
+        const id = specId(graph.registry, spec);
+        if (!slotOf.has(id))
+            slotOf.set(id, slot);
+    }
+    const select = Object.entries(request.outputs ?? {}).map(([name, sel]) => {
+        // `on` names a slot here. Anything else is left alone, so an id
+        // string still works — a follow-up can cite what the last response
+        // returned without re-deriving it.
+        const on = typeof sel.on === 'string' && expanded.has(sel.on)
+            ? expanded.get(sel.on)
+            : sel.on;
+        return { ...sel, on, name };
+    });
+    return { plan: [...expanded.values()], select, slotOf };
+}
+export function run(graph, request) {
+    const { onError = 'throw', assemble = true } = request;
+    const registry = graph.registry;
+    const skipped = [];
+    const resolved = [];
+    // Slot expansion happens before anything resolves, so its failures
+    // used to escape the error policy entirely — a mistyped input came
+    // back as a thrown 500 rather than a `skipped` reason an agent could
+    // read and retry against. Every other class of bad plan is
+    // collectable; there was no argument for this one being different.
+    let normalized;
+    try {
+        normalized = normalize(graph, request);
+    }
+    catch (e) {
+        if (onError === 'throw')
+            throw e;
+        return {
+            outputs: {},
+            facts: [],
+            explain: {},
+            skipped: [{ reason: e instanceof Error ? e.message : String(e) }],
+            nodes: [],
+        };
+    }
+    const { plan, select, slotOf } = normalized;
+    const fail = (entry) => {
+        if (onError === 'throw')
+            throw new ProcessError(entry.reason);
+        skipped.push(entry);
+    };
+    // ── resolve the plan ───────────────────────────────────────
+    for (const spec of plan) {
+        try {
+            const compiled = graph.compile(spec);
+            resolved.push({ id: compiled.id, spec });
+        }
+        catch (e) {
+            fail({
+                spec: {
+                    op: spec.op,
+                    params: { ...(spec.params ?? {}) },
+                    inputs: spec.inputs,
+                },
+                reason: e instanceof Error ? e.message : String(e),
+            });
+        }
+    }
+    const explainMap = {};
+    for (const { id, spec } of resolved)
+        explainMap[id] = explain(registry, spec);
+    // ── work out what the selection actually needs ──────────────
+    // Every id any selector mentions, including a `crossings` `against`.
+    const needed = new Map(); // id -> report in `outputs`
+    const selectors = [];
+    for (const sel of select) {
+        let id;
+        try {
+            id = refToId(registry, sel.on);
+            // An inline spec is a complete description of a computation, so
+            // resolve it whether or not the plan also lists it at top level.
+            // Requiring both was redundant bookkeeping that no schema could
+            // express — so it lived in prose, and a caller composing against
+            // the schema alone duly selected a spec it had not listed, and got
+            // a skip instead of an answer ([PND-PROCSCHEMA], M5).
+            if (typeof sel.on !== 'string' && graph.get(id) === undefined) {
+                const compiled = graph.compile(sel.on);
+                resolved.push({ id: compiled.id, spec: sel.on });
+                explainMap[id] = explain(registry, sel.on);
+            }
+        }
+        catch (e) {
+            fail({ select: sel, reason: e instanceof Error ? e.message : String(e) });
+            continue;
+        }
+        selectors.push({ sel, id });
+        // Surfacing a column-producing node means surfacing its columns.
+        // There is no longer a `columns: true` to opt into, because what a
+        // selector yields is decided by the node it points at.
+        const compiled = graph.get(id);
+        const isFoldNode = compiled?.fold === true;
+        if (!isFoldNode)
+            needed.set(id, true);
+    }
+    const outputs = {};
+    const timings = [];
+    const timed = new Set();
+    let assembled;
+    let drawn;
+    const columnCache = new Map();
+    /**
+     * Pulls a node's inputs before the node itself, so the time recorded
+     * against it is its own compute rather than an ancestor's. Without
+     * this a leaf absorbs the whole subtree's cost and the badge lies.
+     */
+    const warm = (id) => {
+        if (timed.has(id))
+            return;
+        timed.add(id);
+        const compiled = graph.get(id);
+        if (compiled === undefined)
+            return;
+        // Lineage for the whole closure, not just the plan's top level. A
+        // nested spec is a node in `nodes` and will be a node in the M4
+        // pipeline view, and both label from here — leaving it out meant a
+        // badge with a raw id under it.
+        explainMap[id] ??= explain(registry, compiled.spec);
+        // Resolved on the way down, so an edge names the id the consumer
+        // will see in `nodes` rather than a spec it would have to hash.
+        const upstream = compiled.spec.inputs.map((input) => {
+            if (typeof input === 'string')
+                return input;
+            const upId = refToId(registry, specOf(input));
+            warm(upId);
+            return upId;
+        });
+        const declared = registry.outputsOf(registry.get(compiled.spec.op));
+        const wasDirty = compiled.node.dirty;
+        const t0 = performance.now();
+        // A fold is pulled exactly like a column node — same memo, same
+        // version check. That equivalence is the point of [PND-PROCFOLD]:
+        // the badge row now covers the part callers actually read.
+        if (compiled.fold)
+            graph.factOf(compiled);
+        else
+            graph.columnOf(compiled, declared[0].id);
+        const ms = performance.now() - t0;
+        timings.push({
+            id,
+            ...(slotOf.has(id) && { slot: slotOf.get(id) }),
+            pulled: true,
+            cached: !wasDirty,
+            ms: Math.round(ms * 1000) / 1000,
+            inputs: upstream,
+        });
+    };
+    /**
+     * Records a resolved node the request never pulled, inputs first.
+     *
+     * The pipeline is the plan, not the subset one selector happened to
+     * reach. Reading `node.dirty` is free — no value is produced — so this
+     * costs nothing beyond the walk.
+     */
+    const record = (id) => {
+        if (timed.has(id))
+            return;
+        timed.add(id);
+        const compiled = graph.get(id);
+        if (compiled === undefined)
+            return;
+        explainMap[id] ??= explain(registry, compiled.spec);
+        const upstream = compiled.spec.inputs.map((input) => {
+            if (typeof input === 'string')
+                return input;
+            const upId = refToId(registry, specOf(input));
+            record(upId);
+            return upId;
+        });
+        timings.push({
+            id,
+            ...(slotOf.has(id) && { slot: slotOf.get(id) }),
+            pulled: false,
+            cached: !compiled.node.dirty,
+            ms: 0,
+            inputs: upstream,
+        });
+    };
+    const columnFor = (id, suffix) => {
+        const key = id + suffix;
+        const hit = columnCache.get(key);
+        if (hit)
+            return hit;
+        const compiled = graph.get(id);
+        if (compiled === undefined)
+            throw new ProcessError(`'${id}' is not in this plan`);
+        warm(id);
+        const col = graph.columnOf(compiled, suffix);
+        columnCache.set(key, col);
+        return col;
+    };
+    // ── resolve the surfaced columns, and assemble only if asked ───
+    if (needed.size > 0) {
+        drawn = {};
+        if (assemble)
+            assembled = graph.series;
+        for (const [id, report] of needed) {
+            const compiled = graph.get(id);
+            if (compiled === undefined)
+                continue;
+            const cols = columnsOf(registry, compiled.spec, id);
+            if (report)
+                outputs[id] = [];
+            const selections = selectors.filter((selection) => selection.id === id);
+            for (const { sel } of selections) {
+                const declared = registry.outputsOf(registry.get(compiled.spec.op));
+                // A selector naming an output the node does not declare used to
+                // filter every iteration below and surface NOTHING — no columns,
+                // no error, no `skipped` entry. Silent is the worst of the three.
+                if (sel.output !== undefined &&
+                    !declared.some((o) => o.id === sel.output)) {
+                    const have = declared.map((o) => `'${o.id}'`).join(', ');
+                    fail({
+                        select: sel,
+                        reason: `'${compiled.spec.op}' has no output '${sel.output}' (has ${have})`,
+                    });
+                    continue;
+                }
+                // Pulling a column runs op code, which can throw like anything
+                // else a request does — so it answers to the same error policy
+                // the fact loop already honours. Under 'throw' the original
+                // error propagates untouched.
+                try {
+                    declared.forEach((o, n) => {
+                        if (sel.output !== undefined && o.id !== sel.output)
+                            return;
+                        const columnName = cols[n];
+                        const col = columnFor(id, o.id);
+                        // Several selectors may surface the same node or column under
+                        // different caller names. Report every selection, but materialize
+                        // each physical column once.
+                        if (drawn[columnName] === undefined) {
+                            drawn[columnName] = col;
+                            if (assemble)
+                                assembled = appendColumn(assembled, columnName, col);
+                        }
+                        if (report) {
+                            outputs[id].push({
+                                column: columnName,
+                                unit: unitOf(registry, compiled.spec, graph.units, n),
+                                ...(sel.name !== undefined && { name: sel.name }),
+                            });
+                        }
+                    });
+                }
+                catch (e) {
+                    if (onError === 'throw')
+                        throw e;
+                    fail({
+                        select: sel,
+                        reason: e instanceof Error ? e.message : String(e),
+                    });
+                }
+            }
+        }
+    }
+    // ── facts are pulled from fold nodes, like any other value ──
+    const facts = [];
+    for (const { sel, id } of selectors) {
+        const compiled = graph.get(id);
+        if (compiled === undefined) {
+            fail({ select: sel, reason: `'${id}' is not in this plan` });
+            continue;
+        }
+        if (!compiled.fold)
+            continue;
+        try {
+            warm(id);
+            // Provenance wins. The body is spread FIRST and its reserved keys
+            // are dropped, so a custom fold cannot masquerade as another node,
+            // rename an output the caller did not, or forge a unit — `id`,
+            // `name`, `op` and `unit` always mean what the graph says.
+            const body = { ...graph.factOf(compiled) };
+            for (const key of ['id', 'name', 'op', 'unit'])
+                delete body[key];
+            facts.push({
+                ...body,
+                id,
+                ...(sel.name !== undefined && { name: sel.name }),
+                op: compiled.spec.op,
+                unit: unitOf(registry, compiled.spec, graph.units),
+            });
+        }
+        catch (e) {
+            fail({ select: sel, reason: e instanceof Error ? e.message : String(e) });
+        }
+    }
+    // Anything the plan resolved but nothing selected. After the pulls, so
+    // a node that *was* read keeps its timing rather than being shadowed.
+    for (const { id } of resolved)
+        record(id);
+    // The budget is enforced once the run has resolved, not during it:
+    // evicting a node this run is about to read would only recompile it.
+    graph.enforceBudget();
+    return {
+        ...(assembled !== undefined && { series: assembled }),
+        ...(drawn !== undefined && { columns: drawn }),
+        outputs,
+        facts,
+        explain: explainMap,
+        skipped,
+        nodes: timings,
+    };
+}
+//# sourceMappingURL=run.js.map

package/dist/plan/slots.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Slots — [PND-PROCSLOT].
+ *
+ * A plan written as nested specs uses **one identity for two jobs**. A
+ * node's id is derived from its op, params and inputs, so it keys the
+ * cache correctly — and changes the moment a param does, even though the
+ * topology has not. Moving a `period` from 20 to 50 leaves a
+ * structurally identical plan in which every downstream id is different.
+ *
+ * A **slot** is the missing identity: a caller-assigned name for a
+ * position in the graph, stable across a param edit.
+ *
+ * ```jsonc
+ * {
+ *   "bb": { "op": "bollinger", "params": { "period": 20 }, "in": ["px"] },
+ *   "z":  { "op": "zscore", "params": { "period": 20 }, "in": ["px"] }
+ * }
+ * ```
+ *
+ * Slots are an **alias layer, not a replacement**. `specId` remains the
+ * cache key, because it is what makes a node found again across requests,
+ * sessions and callers — a saved view composed months ago and a fresh
+ * compose land on the same node precisely because the id is derived
+ * rather than assigned. One caller's `bb` means nothing to another's.
+ *
+ * That is why this file only **expands**: a slot graph becomes the nested
+ * `Spec` form the rest of the layer already resolves, so a slot plan and
+ * the equivalent nested plan produce identical ids by construction, and
+ * neither `compile` nor `specId` needs to know slots exist.
+ */
+import { ProcessError } from '../errors.js';
+import type { ParamValue, Spec } from './types.js';
+/** Thrown when a slot graph cannot be expanded. */
+export declare class SlotError extends ProcessError {
+}
+/** One node in a slot graph. `in` names source columns or other slots. */
+export interface SlotDef {
+    readonly op: string;
+    readonly params?: Readonly<Record<string, ParamValue>>;
+    /**
+     * Inputs, in the op's declared order. Each entry is a source column
+     * name or another slot's name — **not** an inline spec. Being unable
+     * to nest here is the point: nesting is what slots replace.
+     */
+    readonly in: readonly string[];
+}
+/** A graph keyed by caller-assigned names. */
+export type Slots = Readonly<Record<string, SlotDef>>;
+/**
+ * Expands a slot graph into the nested `Spec` form.
+ *
+ * `columns` is the bound source's column names, needed for two checks
+ * that are far cheaper here than as a failure later:
+ *
+ * - a slot may not take the name of a column, because an input string
+ *   would then be ambiguous and the column would be shadowed silently
+ *   (the alternative, a sigil like `"@bb"`, adds syntax to a format that
+ *   has none — [PND-PROCSLOT] prefers the validation);
+ * - an input naming neither a slot nor a column is a typo, and saying so
+ *   with both lists beats a downstream "column not found".
+ *
+ * @throws {SlotError} on a name collision, an unknown reference, or a cycle.
+ */
+export declare function expandSlots(slots: Slots, columns: readonly string[]): Map<string, Spec>;
+//# sourceMappingURL=slots.d.ts.map

package/dist/plan/slots.js

@@ -0,0 +1,114 @@
+/**
+ * Slots — [PND-PROCSLOT].
+ *
+ * A plan written as nested specs uses **one identity for two jobs**. A
+ * node's id is derived from its op, params and inputs, so it keys the
+ * cache correctly — and changes the moment a param does, even though the
+ * topology has not. Moving a `period` from 20 to 50 leaves a
+ * structurally identical plan in which every downstream id is different.
+ *
+ * A **slot** is the missing identity: a caller-assigned name for a
+ * position in the graph, stable across a param edit.
+ *
+ * ```jsonc
+ * {
+ *   "bb": { "op": "bollinger", "params": { "period": 20 }, "in": ["px"] },
+ *   "z":  { "op": "zscore", "params": { "period": 20 }, "in": ["px"] }
+ * }
+ * ```
+ *
+ * Slots are an **alias layer, not a replacement**. `specId` remains the
+ * cache key, because it is what makes a node found again across requests,
+ * sessions and callers — a saved view composed months ago and a fresh
+ * compose land on the same node precisely because the id is derived
+ * rather than assigned. One caller's `bb` means nothing to another's.
+ *
+ * That is why this file only **expands**: a slot graph becomes the nested
+ * `Spec` form the rest of the layer already resolves, so a slot plan and
+ * the equivalent nested plan produce identical ids by construction, and
+ * neither `compile` nor `specId` needs to know slots exist.
+ */
+import { ProcessError } from '../errors.js';
+/** Thrown when a slot graph cannot be expanded. */
+export class SlotError extends ProcessError {
+}
+/**
+ * Expands a slot graph into the nested `Spec` form.
+ *
+ * `columns` is the bound source's column names, needed for two checks
+ * that are far cheaper here than as a failure later:
+ *
+ * - a slot may not take the name of a column, because an input string
+ *   would then be ambiguous and the column would be shadowed silently
+ *   (the alternative, a sigil like `"@bb"`, adds syntax to a format that
+ *   has none — [PND-PROCSLOT] prefers the validation);
+ * - an input naming neither a slot nor a column is a typo, and saying so
+ *   with both lists beats a downstream "column not found".
+ *
+ * @throws {SlotError} on a name collision, an unknown reference, or a cycle.
+ */
+export function expandSlots(slots, columns) {
+    const names = Object.keys(slots);
+    const columnSet = new Set(columns);
+    for (const name of names) {
+        if (columnSet.has(name)) {
+            throw new SlotError(`slot '${name}' collides with a source column of the same name — rename the slot, or an input naming '${name}' would be ambiguous`);
+        }
+    }
+    const done = new Map();
+    // Insertion-ordered, so the cycle message reads as a path rather than
+    // an unordered set of names.
+    const visiting = [];
+    const expand = (name) => {
+        const cached = done.get(name);
+        if (cached !== undefined)
+            return cached;
+        const at = visiting.indexOf(name);
+        if (at !== -1) {
+            throw new SlotError(`slot cycle: ${[...visiting.slice(at), name].join(' → ')}`);
+        }
+        const def = slots[name];
+        visiting.push(name);
+        const inputs = def.in.map((ref) => {
+            if (Object.hasOwn(slots, ref))
+                return expand(ref);
+            if (columnSet.has(ref))
+                return ref;
+            // `bb#Lower` — one named output of a multi-output slot. A suffix
+            // rather than a nested object because `in` is a list of strings
+            // and keeping it that way is what makes the slot schema flat, with
+            // no recursive `$ref` to make portable ([PND-PROCSLOT]).
+            const hash = ref.lastIndexOf('#');
+            if (hash > 0) {
+                const upstream = ref.slice(0, hash);
+                if (Object.hasOwn(slots, upstream)) {
+                    return { from: expand(upstream), output: ref.slice(hash + 1) };
+                }
+            }
+            // Name the `#` spelling when the reference looks like an attempt
+            // at one. A model reaching for a band's upper line writes
+            // `bb.Upper` on the first try — reasonably — and a list of valid
+            // slots does not tell it what it got wrong.
+            const guess = /^(.+)[.:/](.+)$/.exec(ref);
+            const hint = guess !== null && Object.hasOwn(slots, guess[1])
+                ? ` — to read one output of slot '${guess[1]}', write '${guess[1]}#${guess[2]}'`
+                : '';
+            throw new SlotError(`slot '${name}' names '${ref}', which is neither a slot nor a column${hint} — slots are ${quoted(names)}; columns are ${quoted(columns)}`);
+        });
+        visiting.pop();
+        const spec = {
+            op: def.op,
+            ...(def.params !== undefined && { params: def.params }),
+            inputs,
+        };
+        done.set(name, spec);
+        return spec;
+    };
+    for (const name of names)
+        expand(name);
+    return done;
+}
+function quoted(values) {
+    return values.length === 0 ? 'none' : values.map((v) => `'${v}'`).join(', ');
+}
+//# sourceMappingURL=slots.js.map

package/dist/plan/source.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Opaque, asynchronous data sources.
+ *
+ * A request carries only `{ source, params }`. The loader stays on the host,
+ * where credentials, URLs, retries and cache policy belong. The canonical
+ * source id chooses a long-lived bound graph; `revision` decides whether that
+ * graph's source value must be invalidated.
+ */
+import { ProcessError } from '../errors.js';
+import type { SeriesSchema, TimeSeries } from 'pond-ts';
+import type { ParamValue } from './types.js';
+export type SourceParams = Readonly<Record<string, ParamValue>>;
+/** JSON-safe source identity carried by a request. */
+export interface SourceRef<Name extends string = string, Params extends SourceParams = SourceParams> {
+    readonly source: Name;
+    readonly params: Params;
+}
+export interface LoadedSource {
+    readonly value: TimeSeries<SeriesSchema>;
+    /**
+     * Version of the remote value: an ETag, cursor, object version, or another
+     * stable token. Equal revisions deliberately preserve every graph cache.
+     */
+    readonly revision: string;
+}
+export interface SourceLoadContext {
+    readonly previous?: LoadedSource;
+}
+export interface SourceDef<Name extends string = string, Params extends SourceParams = SourceParams> {
+    readonly name: Name;
+    readonly load: (params: Params, context: SourceLoadContext) => Promise<LoadedSource>;
+    ref(params: Params): SourceRef<Name, Params>;
+}
+/** Defines a typed source token and its host-side loader. */
+export declare function defineSource<const Name extends string, const Params extends SourceParams>(definition: {
+    readonly name: Name;
+    readonly load: SourceDef<Name, Params>['load'];
+}): SourceDef<Name, Params>;
+export declare class UnknownSourceError extends ProcessError {
+}
+export declare class SourceRegistry {
+    #private;
+    define<const Name extends string, const Params extends SourceParams>(source: SourceDef<Name, Params>): this;
+    load(ref: SourceRef, previous?: LoadedSource): Promise<LoadedSource>;
+}
+export declare function createSourceRegistry(): SourceRegistry;
+/** Canonical, order-independent identity for one source invocation. */
+export declare function sourceId(ref: SourceRef): string;
+//# sourceMappingURL=source.d.ts.map

package/dist/plan/source.js

@@ -0,0 +1,54 @@
+/**
+ * Opaque, asynchronous data sources.
+ *
+ * A request carries only `{ source, params }`. The loader stays on the host,
+ * where credentials, URLs, retries and cache policy belong. The canonical
+ * source id chooses a long-lived bound graph; `revision` decides whether that
+ * graph's source value must be invalidated.
+ */
+import { ProcessError } from '../errors.js';
+/** Defines a typed source token and its host-side loader. */
+export function defineSource(definition) {
+    return {
+        ...definition,
+        ref: (params) => ({ source: definition.name, params }),
+    };
+}
+export class UnknownSourceError extends ProcessError {
+}
+export class SourceRegistry {
+    #sources = new Map();
+    define(source) {
+        this.#sources.set(source.name, {
+            name: source.name,
+            ref: (params) => ({ source: source.name, params }),
+            load: (params, context) => source.load(params, context),
+        });
+        return this;
+    }
+    async load(ref, previous) {
+        const source = this.#sources.get(ref.source);
+        if (source === undefined) {
+            const have = [...this.#sources.keys()].map((k) => `'${k}'`).join(', ');
+            throw new UnknownSourceError(`unknown source '${ref.source}'${have ? ` — have ${have}` : ''}`);
+        }
+        return source.load(ref.params, {
+            ...(previous !== undefined && { previous }),
+        });
+    }
+}
+export function createSourceRegistry() {
+    return new SourceRegistry();
+}
+/** Canonical, order-independent identity for one source invocation. */
+export function sourceId(ref) {
+    const params = Object.keys(ref.params)
+        .sort()
+        .map((key) => {
+        const value = ref.params[key];
+        return `${encodeURIComponent(key)}=${encodeURIComponent(`${typeof value}:${JSON.stringify(value)}`)}`;
+    })
+        .join('&');
+    return `source:${encodeURIComponent(ref.source)}${params ? `?${params}` : ''}`;
+}
+//# sourceMappingURL=source.js.map