openalgo-script 0.1.0-alpha.1 → 0.4.0

package/dist/core/stdlib/values/lookback.js

@@ -0,0 +1,134 @@
+import { newState } from './region.js';
+import { NONE, isLength, isPresent, result } from './value.js';
+/**
+ * A lookback of `len` bars, held in a region under `key`.
+ *
+ * A length outside its contract yields a lookback that never fills, so every
+ * function built on it returns absence rather than a number computed from a
+ * nonsense length. See `isLength` for why that is absence and not a diagnostic.
+ */
+export function ring(record, key, len) {
+    const size = len !== null && isLength(len) ? len : 0;
+    const bars = `${key}:q`;
+    const nextKey = `${key}:n`;
+    const seenKey = `${key}:s`;
+    const held = record[bars];
+    let items;
+    if (Array.isArray(held) && held.length === size) {
+        items = held;
+    }
+    else {
+        items = new Array(size).fill(NONE);
+        record[bars] = items;
+        record[nextKey] = 0;
+        record[seenKey] = 0;
+    }
+    const count = (name) => {
+        const value = record[name];
+        return typeof value === 'number' ? value : 0;
+    };
+    const index = (back) => {
+        const from = count(nextKey) - 1 - back;
+        return ((from % size) + size) % size;
+    };
+    const lookback = {
+        push(value) {
+            if (size === 0)
+                return;
+            items[count(nextKey)] = value;
+            const next = count(nextKey) + 1;
+            record[nextKey] = next === size ? 0 : next;
+            if (count(seenKey) < size)
+                record[seenKey] = count(seenKey) + 1;
+        },
+        filled() {
+            return size > 0 && count(seenKey) === size;
+        },
+        at(back) {
+            if (size === 0 || back < 0 || back >= size)
+                return NONE;
+            const value = items[index(back)];
+            return typeof value === 'number' ? value : NONE;
+        },
+        presentCount() {
+            let counted = 0;
+            for (let back = size - 1; back >= 0; back -= 1) {
+                if (isPresent(lookback.at(back)))
+                    counted += 1;
+            }
+            return counted;
+        },
+        complete() {
+            return lookback.filled() && lookback.presentCount() === size;
+        },
+        sum() {
+            if (!lookback.complete())
+                return NONE;
+            let total = 0;
+            // Oldest first: `back` counts down to the bar just pushed.
+            for (let back = size - 1; back >= 0; back -= 1) {
+                total += lookback.at(back);
+            }
+            return result(total);
+        },
+        sumPresent() {
+            if (!lookback.filled())
+                return NONE;
+            let total = 0;
+            for (let back = size - 1; back >= 0; back -= 1) {
+                const value = lookback.at(back);
+                if (isPresent(value))
+                    total += value;
+            }
+            return result(total);
+        },
+        mean() {
+            const total = lookback.sum();
+            return isPresent(total) ? result(total / size) : NONE;
+        },
+    };
+    return lookback;
+}
+/** A lookback of `len` bars in a region of its own, for a caller that has none. */
+export function makeLookback(len) {
+    return ring(newState(), 'q', len);
+}
+/**
+ * Seeded smoothing: the mean of the first complete lookback, then one step per
+ * bar.
+ *
+ * The seed lookback is complete only when it holds `len` present values, so an
+ * average taken over another study's output starts counting at that study's
+ * first value rather than at bar 0. That is what makes the warmups of
+ * `stdlib.md` compose, and it is why `ema(sma(close, 10), 10)` is absent until
+ * bar 18 rather than bar 9.
+ *
+ * A hole in the input freezes the recurrence: an absent bar after seeding
+ * produces an absent bar out and leaves the running value untouched, so the
+ * next present bar continues from where the last one left off. The alternatives
+ * are worse: consuming absence as zero would drag the average toward nothing,
+ * and re-seeding would let one missing bar restart a two hundred bar average.
+ */
+export function smoothed(record, key, len, value, step) {
+    const seed = ring(record, `${key}~`, len);
+    const runningKey = `${key}:r`;
+    const startedKey = `${key}:o`;
+    if (record[startedKey] !== true) {
+        seed.push(value);
+        const mean = seed.mean();
+        if (!isPresent(mean))
+            return NONE;
+        record[startedKey] = true;
+        record[runningKey] = mean;
+        return result(mean);
+    }
+    if (!isPresent(value))
+        return NONE;
+    const previous = record[runningKey];
+    if (typeof previous !== 'number')
+        return NONE;
+    const next = step(previous, value);
+    record[runningKey] = next;
+    return result(next);
+}
+//# sourceMappingURL=lookback.js.map

package/dist/core/stdlib/values/lookback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lookback.js","sourceRoot":"","sources":["../../../../src/core/stdlib/values/lookback.ts"],"names":[],"mappings":"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"}

package/dist/core/stdlib/values/region.d.ts

@@ -0,0 +1,55 @@
+/**
+ * What a stateful function remembers between bars, and why it is a record
+ * rather than a closure.
+ *
+ * A closure is the obvious way to hold a running average and it is the wrong
+ * way here. `compiled-program.md` 2.11 requires a state region to be
+ * **snapshottable by a mechanical copy**: an engine copies and restores one
+ * without knowing which function owns it, because the rollback and replay rules
+ * of section 6 apply to every region at once. Nothing can copy a closure
+ * without knowing what is inside it, and rebuilding one by replaying its inputs
+ * is what 6.2 refuses in as many words: an engine does not re-seed an average
+ * from history, it puts back the record it copied.
+ *
+ * So a region is a flat record of numbers, booleans, strings and fixed length
+ * queues, and `copyState` is the mechanical copy. Every function in this
+ * library is written against one, and the tail form in `tail.ts` is the same
+ * step over a region nobody else can reach. That is what lets the one
+ * implementation serve both a library call folded over a series and an engine
+ * advancing a chart one bar at a time.
+ *
+ * Several functions share one region by taking different key prefixes, which is
+ * how a study built from three others keeps one flat record rather than a tree
+ * of them.
+ */
+/** One field of a state region. A queue is the one compound form 2.11 allows. */
+export type StateField = number | boolean | string | null;
+/** What a single key holds. */
+export type StateSlot = StateField | StateField[];
+/** A state region: a flat record, copyable without knowing what owns it. */
+export type StateRecord = Record<string, StateSlot | undefined>;
+/** A region with nothing in it yet, which is what bar 0 finds. */
+export declare function newState(): StateRecord;
+/** The mechanical copy 2.11 asks for: one level, with queues cloned. */
+export declare function copyState(record: StateRecord): StateRecord;
+/** A number held in a region, with a default for the bar it is first read on. */
+export declare function slot(record: StateRecord, key: string, fallback: number): number;
+/** A condition held in a region, false until something sets it. */
+export declare function flag(record: StateRecord, key: string): boolean;
+/**
+ * A queue held in a region, created on the bar it is first read on.
+ *
+ * The caller keeps it bounded. A queue that grew with the dataset would not be
+ * copyable in the sense 2.11 requires.
+ */
+export declare function queue(record: StateRecord, key: string): StateField[];
+/**
+ * A number held in a region that may honestly have none yet.
+ *
+ * `slot` answers with a fallback, which is what a running total wants. A study
+ * that remembers the previous bar's high wants the other answer: absence until
+ * a present value has been put there, so the bar after a hole is treated as the
+ * bar after a hole rather than as one following a zero.
+ */
+export declare function held(record: StateRecord, key: string): number | null;
+//# sourceMappingURL=region.d.ts.map

package/dist/core/stdlib/values/region.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"region.d.ts","sourceRoot":"","sources":["../../../../src/core/stdlib/values/region.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,iFAAiF;AACjF,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,IAAI,CAAC;AAE1D,+BAA+B;AAC/B,MAAM,MAAM,SAAS,GAAG,UAAU,GAAG,UAAU,EAAE,CAAC;AAElD,4EAA4E;AAC5E,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,GAAG,SAAS,CAAC,CAAC;AAEhE,kEAAkE;AAClE,wBAAgB,QAAQ,IAAI,WAAW,CAEtC;AAED,wEAAwE;AACxE,wBAAgB,SAAS,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW,CAO1D;AAED,iFAAiF;AACjF,wBAAgB,IAAI,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAG/E;AAED,mEAAmE;AACnE,wBAAgB,IAAI,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAE9D;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,GAAG,UAAU,EAAE,CAMpE;AAED;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGpE"}

package/dist/core/stdlib/values/region.js

@@ -0,0 +1,73 @@
+/**
+ * What a stateful function remembers between bars, and why it is a record
+ * rather than a closure.
+ *
+ * A closure is the obvious way to hold a running average and it is the wrong
+ * way here. `compiled-program.md` 2.11 requires a state region to be
+ * **snapshottable by a mechanical copy**: an engine copies and restores one
+ * without knowing which function owns it, because the rollback and replay rules
+ * of section 6 apply to every region at once. Nothing can copy a closure
+ * without knowing what is inside it, and rebuilding one by replaying its inputs
+ * is what 6.2 refuses in as many words: an engine does not re-seed an average
+ * from history, it puts back the record it copied.
+ *
+ * So a region is a flat record of numbers, booleans, strings and fixed length
+ * queues, and `copyState` is the mechanical copy. Every function in this
+ * library is written against one, and the tail form in `tail.ts` is the same
+ * step over a region nobody else can reach. That is what lets the one
+ * implementation serve both a library call folded over a series and an engine
+ * advancing a chart one bar at a time.
+ *
+ * Several functions share one region by taking different key prefixes, which is
+ * how a study built from three others keeps one flat record rather than a tree
+ * of them.
+ */
+/** A region with nothing in it yet, which is what bar 0 finds. */
+export function newState() {
+    return {};
+}
+/** The mechanical copy 2.11 asks for: one level, with queues cloned. */
+export function copyState(record) {
+    const out = {};
+    for (const key of Object.keys(record)) {
+        const value = record[key];
+        out[key] = Array.isArray(value) ? [...value] : value;
+    }
+    return out;
+}
+/** A number held in a region, with a default for the bar it is first read on. */
+export function slot(record, key, fallback) {
+    const value = record[key];
+    return typeof value === 'number' ? value : fallback;
+}
+/** A condition held in a region, false until something sets it. */
+export function flag(record, key) {
+    return record[key] === true;
+}
+/**
+ * A queue held in a region, created on the bar it is first read on.
+ *
+ * The caller keeps it bounded. A queue that grew with the dataset would not be
+ * copyable in the sense 2.11 requires.
+ */
+export function queue(record, key) {
+    const held = record[key];
+    if (Array.isArray(held))
+        return held;
+    const made = [];
+    record[key] = made;
+    return made;
+}
+/**
+ * A number held in a region that may honestly have none yet.
+ *
+ * `slot` answers with a fallback, which is what a running total wants. A study
+ * that remembers the previous bar's high wants the other answer: absence until
+ * a present value has been put there, so the bar after a hole is treated as the
+ * bar after a hole rather than as one following a zero.
+ */
+export function held(record, key) {
+    const value = record[key];
+    return typeof value === 'number' ? value : null;
+}
+//# sourceMappingURL=region.js.map

package/dist/core/stdlib/values/region.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"region.js","sourceRoot":"","sources":["../../../../src/core/stdlib/values/region.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAWH,kEAAkE;AAClE,MAAM,UAAU,QAAQ;IACtB,OAAO,EAAE,CAAC;AACZ,CAAC;AAED,wEAAwE;AACxE,MAAM,UAAU,SAAS,CAAC,MAAmB;IAC3C,MAAM,GAAG,GAAgB,EAAE,CAAC;IAC5B,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;QACtC,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;QAC1B,GAAG,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IACvD,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,iFAAiF;AACjF,MAAM,UAAU,IAAI,CAAC,MAAmB,EAAE,GAAW,EAAE,QAAgB;IACrE,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;IAC1B,OAAO,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC;AACtD,CAAC;AAED,mEAAmE;AACnE,MAAM,UAAU,IAAI,CAAC,MAAmB,EAAE,GAAW;IACnD,OAAO,MAAM,CAAC,GAAG,CAAC,KAAK,IAAI,CAAC;AAC9B,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,KAAK,CAAC,MAAmB,EAAE,GAAW;IACpD,MAAM,IAAI,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;IACzB,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IACrC,MAAM,IAAI,GAAiB,EAAE,CAAC;IAC9B,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;IACnB,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,IAAI,CAAC,MAAmB,EAAE,GAAW;IACnD,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;IAC1B,OAAO,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;AAClD,CAAC"}

package/dist/core/stdlib/values/tail.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The tail path, and why the whole-series form is defined in terms of it.
+ *
+ * A live chart recomputes on every tick. A study that rescans its whole history
+ * to produce one more bar makes a terminal slow in proportion to how much
+ * history the trader has loaded, and nobody notices until the day somebody
+ * scrolls back five years.
+ *
+ * So every function here is written once, as a tail: a small piece of state
+ * plus a step that takes this bar's input and returns this bar's output. The
+ * whole-series form is that step folded over the series and nothing else.
+ *
+ * That is not a convenience. `compiled-program.md` section 8.3 requires the two
+ * to agree to the last bit, and the only way to be sure of that is to have one
+ * implementation rather than two that are meant to match. A second batch
+ * implementation, however carefully written, is a second accumulation order
+ * waiting to drift.
+ *
+ * The state lives in a region (`region.ts`) rather than in the closure's own
+ * variables, so the same step an engine advances over a live chart is the step
+ * this folds over a series. `tailOf` is the whole of the tail form: a region
+ * nobody else can reach, and the step applied to it.
+ */
+import type { StateRecord } from './region.js';
+/**
+ * One bar in, one bar out, with everything the function remembers held inside.
+ *
+ * A tail is stateful and single use: it is fed bars in order, from bar 0, and
+ * each call advances it by one bar.
+ */
+export interface Tail<In, Out> {
+    /** Advance by one bar and return that bar's output. */
+    next(input: In): Out;
+}
+/** A tail's step applied to a whole series, oldest bar first. */
+export declare function fold<In, Out>(tail: Tail<In, Out>, inputs: readonly In[]): Out[];
+/**
+ * A tail from a step: a private region, advanced one bar per call.
+ *
+ * The region is the same shape an engine hands a stateful call, so the function
+ * underneath does not know which of the two is driving it.
+ */
+export declare function tailOf<In, Out>(step: (state: StateRecord, input: In) => Out): Tail<In, Out>;
+//# sourceMappingURL=tail.d.ts.map

package/dist/core/stdlib/values/tail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tail.d.ts","sourceRoot":"","sources":["../../../../src/core/stdlib/values/tail.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C;;;;;GAKG;AACH,MAAM,WAAW,IAAI,CAAC,EAAE,EAAE,GAAG;IAC3B,uDAAuD;IACvD,IAAI,CAAC,KAAK,EAAE,EAAE,GAAG,GAAG,CAAC;CACtB;AAED,iEAAiE;AACjE,wBAAgB,IAAI,CAAC,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,GAAG,GAAG,EAAE,CAI/E;AAED;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,EAAE,KAAK,GAAG,GAAG,IAAI,CAAC,EAAE,EAAE,GAAG,CAAC,CAO3F"}

package/dist/core/stdlib/values/tail.js

@@ -0,0 +1,23 @@
+import { newState } from './region.js';
+/** A tail's step applied to a whole series, oldest bar first. */
+export function fold(tail, inputs) {
+    const out = [];
+    for (const input of inputs)
+        out.push(tail.next(input));
+    return out;
+}
+/**
+ * A tail from a step: a private region, advanced one bar per call.
+ *
+ * The region is the same shape an engine hands a stateful call, so the function
+ * underneath does not know which of the two is driving it.
+ */
+export function tailOf(step) {
+    const state = newState();
+    return {
+        next(input) {
+            return step(state, input);
+        },
+    };
+}
+//# sourceMappingURL=tail.js.map

package/dist/core/stdlib/values/tail.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tail.js","sourceRoot":"","sources":["../../../../src/core/stdlib/values/tail.ts"],"names":[],"mappings":"AAwBA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAavC,iEAAiE;AACjE,MAAM,UAAU,IAAI,CAAU,IAAmB,EAAE,MAAqB;IACtE,MAAM,GAAG,GAAU,EAAE,CAAC;IACtB,KAAK,MAAM,KAAK,IAAI,MAAM;QAAE,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IACvD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,MAAM,CAAU,IAA4C;IAC1E,MAAM,KAAK,GAAG,QAAQ,EAAE,CAAC;IACzB,OAAO;QACL,IAAI,CAAC,KAAS;YACZ,OAAO,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QAC5B,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/core/stdlib/values/value.d.ts

@@ -0,0 +1,64 @@
+/**
+ * The absent value, and the two rules every result in this library obeys.
+ *
+ * Absence is a value of its own and is never a number. A warmup bar is absent,
+ * and anything computed from an absent value is absent. Returning zero instead
+ * would draw a line along the axis that looks exactly like data, and a reader
+ * has no way to tell the two apart.
+ *
+ * Not-a-number is not used as the sentinel, for the reason `compiled-program.md`
+ * section 3.4 gives: it would propagate through arithmetic by accident, which
+ * is the right answer for some operators and the wrong one for others, and it
+ * would turn an absence test into a floating point comparison.
+ */
+/** A number, or absence. */
+export type Value = number | null;
+/** A series is one value per bar, oldest first. */
+export type Series = readonly Value[];
+/**
+ * A condition, one per bar: true, false, or absent.
+ *
+ * Absence is its own answer here too. A comparison against a warmup bar is
+ * absent rather than false, and the functions that consume a condition say
+ * which of the two they treat it as.
+ */
+export type Flag = boolean | null;
+/** A series of conditions, one per bar, oldest first. */
+export type Flags = readonly Flag[];
+/** Absence, written `none` in a script. */
+export declare const NONE: Value;
+/** True when the value is present, narrowing it to a number. */
+export declare function isPresent(value: Value): value is number;
+/**
+ * A computed number, made safe to return.
+ *
+ * Two rules from `compiled-program.md` section 3.1, applied at every value this
+ * library hands back:
+ *
+ * - A result with no finite real value is absent, not an infinity and not a
+ *   not-a-number. `log(0)` and a division by zero inside a ratio study are the
+ *   everyday cases.
+ * - Negative zero is normalised to positive zero, so nothing downstream can
+ *   observe the sign of a zero and two engines cannot differ over it.
+ */
+export declare function result(x: number): Value;
+/**
+ * Element `index` of a series, or absence when the index falls off either end.
+ *
+ * Reading before the start of the dataset is absent rather than an error, which
+ * is what makes `history` and every lookback function fall out of one rule
+ * instead of a special case each.
+ */
+export declare function at(values: Series, index: number): Value;
+/**
+ * Whether a length argument is inside its contract: a whole number of one or
+ * more, per `stdlib.md` section 2.5.
+ *
+ * This library raises nothing. A length outside the contract is OS3004 at
+ * compile time when it is a literal and OS4003 at run time when it is computed,
+ * and both are raised before a call reaches here. The functions below use this
+ * only as a backstop, and a backstop returns absence rather than a guess: a
+ * wrong number drawn on a chart is worse than a gap.
+ */
+export declare function isLength(length: number): boolean;
+//# sourceMappingURL=value.d.ts.map

package/dist/core/stdlib/values/value.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"value.d.ts","sourceRoot":"","sources":["../../../../src/core/stdlib/values/value.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,4BAA4B;AAC5B,MAAM,MAAM,KAAK,GAAG,MAAM,GAAG,IAAI,CAAC;AAElC,mDAAmD;AACnD,MAAM,MAAM,MAAM,GAAG,SAAS,KAAK,EAAE,CAAC;AAEtC;;;;;;GAMG;AACH,MAAM,MAAM,IAAI,GAAG,OAAO,GAAG,IAAI,CAAC;AAElC,yDAAyD;AACzD,MAAM,MAAM,KAAK,GAAG,SAAS,IAAI,EAAE,CAAC;AAEpC,2CAA2C;AAC3C,eAAO,MAAM,IAAI,EAAE,KAAY,CAAC;AAEhC,gEAAgE;AAChE,wBAAgB,SAAS,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,IAAI,MAAM,CAEvD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,KAAK,CAGvC;AAED;;;;;;GAMG;AACH,wBAAgB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,CAGvD;AAED;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEhD"}

package/dist/core/stdlib/values/value.js

@@ -0,0 +1,61 @@
+/**
+ * The absent value, and the two rules every result in this library obeys.
+ *
+ * Absence is a value of its own and is never a number. A warmup bar is absent,
+ * and anything computed from an absent value is absent. Returning zero instead
+ * would draw a line along the axis that looks exactly like data, and a reader
+ * has no way to tell the two apart.
+ *
+ * Not-a-number is not used as the sentinel, for the reason `compiled-program.md`
+ * section 3.4 gives: it would propagate through arithmetic by accident, which
+ * is the right answer for some operators and the wrong one for others, and it
+ * would turn an absence test into a floating point comparison.
+ */
+/** Absence, written `none` in a script. */
+export const NONE = null;
+/** True when the value is present, narrowing it to a number. */
+export function isPresent(value) {
+    return value !== null;
+}
+/**
+ * A computed number, made safe to return.
+ *
+ * Two rules from `compiled-program.md` section 3.1, applied at every value this
+ * library hands back:
+ *
+ * - A result with no finite real value is absent, not an infinity and not a
+ *   not-a-number. `log(0)` and a division by zero inside a ratio study are the
+ *   everyday cases.
+ * - Negative zero is normalised to positive zero, so nothing downstream can
+ *   observe the sign of a zero and two engines cannot differ over it.
+ */
+export function result(x) {
+    if (!Number.isFinite(x))
+        return NONE;
+    return x === 0 ? 0 : x;
+}
+/**
+ * Element `index` of a series, or absence when the index falls off either end.
+ *
+ * Reading before the start of the dataset is absent rather than an error, which
+ * is what makes `history` and every lookback function fall out of one rule
+ * instead of a special case each.
+ */
+export function at(values, index) {
+    const value = values[index];
+    return value === undefined ? NONE : value;
+}
+/**
+ * Whether a length argument is inside its contract: a whole number of one or
+ * more, per `stdlib.md` section 2.5.
+ *
+ * This library raises nothing. A length outside the contract is OS3004 at
+ * compile time when it is a literal and OS4003 at run time when it is computed,
+ * and both are raised before a call reaches here. The functions below use this
+ * only as a backstop, and a backstop returns absence rather than a guess: a
+ * wrong number drawn on a chart is worse than a gap.
+ */
+export function isLength(length) {
+    return Number.isInteger(length) && length >= 1;
+}
+//# sourceMappingURL=value.js.map

package/dist/core/stdlib/values/value.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"value.js","sourceRoot":"","sources":["../../../../src/core/stdlib/values/value.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAoBH,2CAA2C;AAC3C,MAAM,CAAC,MAAM,IAAI,GAAU,IAAI,CAAC;AAEhC,gEAAgE;AAChE,MAAM,UAAU,SAAS,CAAC,KAAY;IACpC,OAAO,KAAK,KAAK,IAAI,CAAC;AACxB,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,MAAM,CAAC,CAAS;IAC9B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IACrC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACzB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,EAAE,CAAC,MAAc,EAAE,KAAa;IAC9C,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAC5B,OAAO,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC;AAC5C,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,QAAQ,CAAC,MAAc;IACrC,OAAO,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,MAAM,IAAI,CAAC,CAAC;AACjD,CAAC"}

package/dist/core/stdlib/volatility/bands.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The channel studies: `bollinger`, its two readings, `keltner` and `donchian`.
+ *
+ * Each returns an array holding this bar's outputs, in the order its entry in
+ * `stdlib.md` documents. **The array itself is never absent and never changes
+ * length**, per section 2.3: each element carries its own warmup and is absent
+ * until it is reached. An array that grew as warmup completed would make an
+ * index an out-of-range error at the left edge of a chart and nowhere else.
+ */
+import type { Bar, Series, StateRecord, Tail, Value } from '../values/index.js';
+import type { MaType } from '../averages/index.js';
+import type { Gap } from './range.js';
+/** `bollinger(src, len, mult)`: `[basis, upper, lower]`, all from bar `len - 1`. */
+export declare function bollingerStep(state: StateRecord, key: string, value: Value, len: number | null, mult: number | null): Value[];
+/** `bollinger(src, len, mult)` as a tail. */
+export declare function bollingerTail(len?: number, mult?: number): Tail<Value, Value[]>;
+/** `bollinger(src, len, mult)` over a whole series. */
+export declare function bollinger(src: Series, len?: number, mult?: number): Value[][];
+/** `bbWidth(src, len, mult)`: band width over the basis, from bar `len - 1`. */
+export declare function bbWidthStep(state: StateRecord, key: string, value: Value, len: number | null, mult: number | null): Value;
+/** `bbWidth(src, len, mult)` as a tail. */
+export declare function bbWidthTail(len?: number, mult?: number): Tail<Value, Value>;
+/** `bbWidth(src, len, mult)` over a whole series. */
+export declare function bbWidth(src: Series, len?: number, mult?: number): Value[];
+/** `bbPercent(src, len, mult)`: where price sits between the bands, from bar `len - 1`. */
+export declare function bbPercentStep(state: StateRecord, key: string, value: Value, len: number | null, mult: number | null): Value;
+/** `bbPercent(src, len, mult)` as a tail. */
+export declare function bbPercentTail(len?: number, mult?: number): Tail<Value, Value>;
+/** `bbPercent(src, len, mult)` over a whole series. */
+export declare function bbPercent(src: Series, len?: number, mult?: number): Value[];
+/**
+ * `keltner(len, mult, atrLen, maType)`: `[basis, upper, lower]`, all from bar
+ * `max(len, atrLen) - 1`.
+ *
+ * The same picture as `bollinger` built from average true range instead of
+ * deviation, so the rails widen on how far the instrument travels rather than
+ * on how dispersed its closes were.
+ */
+export declare function keltnerStep(state: StateRecord, key: string, gap: Gap, close: Value, volume: Value, len: number | null, mult: number | null, atrLen: number | null, maType: MaType | null): Value[];
+/** `keltner(len, mult, atrLen, maType)` as a tail. */
+export declare function keltnerTail(len?: number, mult?: number, atrLen?: number, maType?: MaType): Tail<Bar, Value[]>;
+/** `keltner(len, mult, atrLen, maType)` over a run of bars. */
+export declare function keltner(bars: readonly Bar[], len?: number, mult?: number, atrLen?: number, maType?: MaType): Value[][];
+/** `donchian(len)`: `[upper, basis, lower]`, all from bar `len - 1`. */
+export declare function donchianStep(state: StateRecord, key: string, high: Value, low: Value, len: number | null): Value[];
+/** `donchian(len)` as a tail. */
+export declare function donchianTail(len?: number): Tail<Bar, Value[]>;
+/** `donchian(len)` over a run of bars. */
+export declare function donchian(bars: readonly Bar[], len?: number): Value[][];
+//# sourceMappingURL=bands.d.ts.map

package/dist/core/stdlib/volatility/bands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bands.d.ts","sourceRoot":"","sources":["../../../../src/core/stdlib/volatility/bands.ts"],"names":[],"mappings":"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"}

package/dist/core/stdlib/volatility/bands.js

@@ -0,0 +1,101 @@
+import { NONE, at, fold, isPresent, result, tailOf } from '../values/index.js';
+import { maStep, smaStep } from '../averages/index.js';
+import { extremeStep } from '../series/index.js';
+import { stdevStep } from './deviation.js';
+import { atrStep, gapOf } from './range.js';
+/** `bollinger(src, len, mult)`: `[basis, upper, lower]`, all from bar `len - 1`. */
+export function bollingerStep(state, key, value, len, mult) {
+    const middle = smaStep(state, `${key}q`, value, len);
+    const deviation = stdevStep(state, `${key}d`, value, len, false);
+    if (!isPresent(middle) || !isPresent(deviation) || mult === null)
+        return [middle, NONE, NONE];
+    return [middle, result(middle + mult * deviation), result(middle - mult * deviation)];
+}
+/** `bollinger(src, len, mult)` as a tail. */
+export function bollingerTail(len = 20, mult = 2) {
+    return tailOf((state, value) => bollingerStep(state, '', value, len, mult));
+}
+/** `bollinger(src, len, mult)` over a whole series. */
+export function bollinger(src, len = 20, mult = 2) {
+    return fold(bollingerTail(len, mult), src);
+}
+/** `bbWidth(src, len, mult)`: band width over the basis, from bar `len - 1`. */
+export function bbWidthStep(state, key, value, len, mult) {
+    const trio = bollingerStep(state, key, value, len, mult);
+    const basis = at(trio, 0);
+    const upper = at(trio, 1);
+    const lower = at(trio, 2);
+    if (!isPresent(basis) || !isPresent(upper) || !isPresent(lower))
+        return NONE;
+    if (basis === 0)
+        return NONE;
+    return result((upper - lower) / basis);
+}
+/** `bbWidth(src, len, mult)` as a tail. */
+export function bbWidthTail(len = 20, mult = 2) {
+    return tailOf((state, value) => bbWidthStep(state, '', value, len, mult));
+}
+/** `bbWidth(src, len, mult)` over a whole series. */
+export function bbWidth(src, len = 20, mult = 2) {
+    return fold(bbWidthTail(len, mult), src);
+}
+/** `bbPercent(src, len, mult)`: where price sits between the bands, from bar `len - 1`. */
+export function bbPercentStep(state, key, value, len, mult) {
+    const trio = bollingerStep(state, key, value, len, mult);
+    const upper = at(trio, 1);
+    const lower = at(trio, 2);
+    if (!isPresent(value) || !isPresent(upper) || !isPresent(lower))
+        return NONE;
+    const span = upper - lower;
+    if (span === 0)
+        return NONE;
+    return result((value - lower) / span);
+}
+/** `bbPercent(src, len, mult)` as a tail. */
+export function bbPercentTail(len = 20, mult = 2) {
+    return tailOf((state, value) => bbPercentStep(state, '', value, len, mult));
+}
+/** `bbPercent(src, len, mult)` over a whole series. */
+export function bbPercent(src, len = 20, mult = 2) {
+    return fold(bbPercentTail(len, mult), src);
+}
+/**
+ * `keltner(len, mult, atrLen, maType)`: `[basis, upper, lower]`, all from bar
+ * `max(len, atrLen) - 1`.
+ *
+ * The same picture as `bollinger` built from average true range instead of
+ * deviation, so the rails widen on how far the instrument travels rather than
+ * on how dispersed its closes were.
+ */
+export function keltnerStep(state, key, gap, close, volume, len, mult, atrLen, maType) {
+    const middle = maStep(state, `${key}m`, { src: close, volume }, len, maType);
+    const width = atrStep(state, `${key}r`, gap, atrLen);
+    if (!isPresent(middle) || !isPresent(width) || mult === null)
+        return [middle, NONE, NONE];
+    return [middle, result(middle + mult * width), result(middle - mult * width)];
+}
+/** `keltner(len, mult, atrLen, maType)` as a tail. */
+export function keltnerTail(len = 20, mult = 2, atrLen = 10, maType = 'ema') {
+    return tailOf((state, bar) => keltnerStep(state, '', gapOf(state, 'g', bar), bar.close, bar.volume, len, mult, atrLen, maType));
+}
+/** `keltner(len, mult, atrLen, maType)` over a run of bars. */
+export function keltner(bars, len = 20, mult = 2, atrLen = 10, maType = 'ema') {
+    return fold(keltnerTail(len, mult, atrLen, maType), bars);
+}
+/** `donchian(len)`: `[upper, basis, lower]`, all from bar `len - 1`. */
+export function donchianStep(state, key, high, low, len) {
+    const upper = extremeStep(state, `${key}h`, high, len, true, false);
+    const lower = extremeStep(state, `${key}l`, low, len, false, false);
+    if (!isPresent(upper) || !isPresent(lower))
+        return [upper, NONE, lower];
+    return [upper, result((upper + lower) / 2), lower];
+}
+/** `donchian(len)` as a tail. */
+export function donchianTail(len = 20) {
+    return tailOf((state, bar) => donchianStep(state, '', bar.high, bar.low, len));
+}
+/** `donchian(len)` over a run of bars. */
+export function donchian(bars, len = 20) {
+    return fold(donchianTail(len), bars);
+}
+//# sourceMappingURL=bands.js.map