@jarenjs/core 0.9.2 → 0.34.2

package/dist/types/dates/duration.d.ts

@@ -0,0 +1,83 @@
+export type DurationParts = {
+    negative: boolean;
+    years: number;
+    months: number;
+    weeks: number;
+    days: number;
+    hours: number;
+    minutes: number;
+    /**
+     * - may be fractional
+     */
+    seconds: number;
+};
+/**
+ * Decompose an ISO 8601 / RFC 3339 duration string into its parts.
+ *
+ * This is a deliberate **superset** of `isValidDuration` (rfc3339.js),
+ * which stays strict because it backs the JSON Schema `duration` format
+ * and must reject what the RFC rejects. This parser additionally accepts
+ * a leading `-` and a fractional component (`PT1.5H`), both of which ISO
+ * 8601 allows. So `parseDuration(s) !== null` does not imply
+ * `isValidDuration(s)`, and a consumer that needs RFC strictness must
+ * ask the validator, not this.
+ *
+ * Designators must appear coarse-to-fine within each half (`P1Y2M`, not
+ * `P2M1Y`), each at most once, and `W` does not mix with `Y`/`M`/`D`.
+ * Returns null for anything it cannot read, so callers branch rather
+ * than catch.
+ *
+ * @param {any} str - the duration string, e.g. `'P1Y2M3DT4H5M6S'`
+ * @returns {DurationParts | null}
+ * @example
+ * parseDuration('P1Y2M3DT4H5M6S');
+ * // { negative: false, years: 1, months: 2, weeks: 0, days: 3,
+ * //   hours: 4, minutes: 5, seconds: 6 }
+ */
+export declare function parseDuration(str: any): DurationParts | null;
+/**
+ * The fixed-width span of a duration in milliseconds — weeks, days,
+ * hours, minutes and seconds only.
+ *
+ * Returns NaN when the duration carries years or months, because those
+ * have no width without a date to stand on. That is a deliberate refusal
+ * rather than an approximation: silently calling a month 30 days is how
+ * "in 1 month" lands on the wrong day.
+ *
+ * @param {DurationParts} parts
+ * @returns {number} signed milliseconds, or NaN if not fixed-width
+ */
+export declare function durationToMs(parts: DurationParts): number;
+/**
+ * Whether a duration has a width independent of where it is applied.
+ * @param {DurationParts} parts
+ * @returns {boolean}
+ */
+export declare function isFixedDuration(parts: DurationParts): boolean;
+/**
+ * Apply a duration to a parts record, the operation that gives the
+ * calendar fields their meaning. Coarse units apply first, so
+ * `2026-01-31` plus `P1M1D` is February's clamped 28th plus a day, not
+ * March 1st plus a month.
+ *
+ * @param {object} dateParts - a parts record from `parseRFC3339Parts`
+ * @param {DurationParts} duration
+ * @param {number} [sign] - 1 to add (default), -1 to subtract
+ * @returns {object} a new parts record
+ */
+export declare function addDuration(dateParts: object, duration: DurationParts, sign?: number): object;
+/**
+ * Whole calendar months between two dates, ignoring the time of day —
+ * the building block `diff` needs for the units that are not fixed-width.
+ *
+ * "Whole" is defined by `addToParts`, so that adding the result back to
+ * `from` never overshoots `to`. That makes 2026-01-31 → 2026-02-28 **one**
+ * month, not zero, because the clamping rule already says Jan 31 plus a
+ * month IS Feb 28. Keeping the two operations inverse is worth more than
+ * matching moment here, which reports zero for the same pair.
+ *
+ * @param {object} from - a parts record
+ * @param {object} to - a parts record
+ * @returns {number} signed month count
+ */
+export declare function monthsBetween(from: object, to: object): number;

package/dist/types/dates/format.d.ts

@@ -0,0 +1,59 @@
+export type DateNames = {
+    /**
+     * - 12 wide month names, January first
+     */
+    months?: string[];
+    /**
+     * - 12 abbreviated month names
+     */
+    monthsShort?: string[];
+    /**
+     * - 7 wide weekday names, Sunday first
+     */
+    weekdays?: string[];
+    /**
+     * - 7 abbreviated weekday names
+     */
+    weekdaysShort?: string[];
+    /**
+     * - the AM and PM markers
+     */
+    meridiem?: [string, string];
+};
+/**
+ * Compile an LDML date pattern into a formatter.
+ *
+ * The returned function takes a parts record (`parseRFC3339Parts`) and
+ * returns a string. It closes over nothing mutable and is reusable.
+ *
+ * @param {string} pattern - an LDML pattern, e.g. `"yyyy-MM-dd'T'HH:mm:ssXXX"`
+ * @param {DateNames} [names] - locale names, required only if the
+ *   pattern uses `MMM`/`MMMM`/`EEE`/`EEEE`/`a`
+ * @returns {(parts: object) => string} the compiled formatter
+ * @throws {TypeError} on an unterminated quote, or a name token with no
+ *   provider for it
+ * @example
+ * const iso = compileDateFormat("yyyy-MM-dd'T'HH:mm:ssXXX");
+ * iso(parseRFC3339Parts('2026-07-27T14:30:05+02:00'));
+ * // '2026-07-27T14:30:05+02:00'
+ */
+export declare function compileDateFormat(pattern: string, names?: DateNames): (parts: object) => string;
+/**
+ * Render a parts record back to RFC 3339, the inverse of
+ * `parseRFC3339Parts`. The value keeps the shape it had: a record with
+ * no time half comes back a `full-date`, one with no date half a
+ * `full-time`, and the offset is the record's own rather than UTC.
+ *
+ * The round trip preserves the *value*, not necessarily the spelling: a
+ * fractional second is emitted only when non-zero and without trailing
+ * zeros, so `…:05.250Z` comes back `…:05.25Z`. The parts record holds
+ * the fraction as a number, so the original digit count is not
+ * recoverable — a consumer that must reproduce the input byte for byte
+ * (JOSL, which round-trips TOML) has to keep the literal text itself.
+ *
+ * @param {object} parts - a parts record
+ * @returns {string} an RFC 3339 string
+ * @example
+ * formatRFC3339Parts(parseRFC3339Parts('2026-07-27')); // '2026-07-27'
+ */
+export declare function formatRFC3339Parts(parts: object): string;

package/dist/types/dates/index.d.ts

@@ -0,0 +1,4 @@
+export * from './rfc3339.js';
+export * from './civil.js';
+export * from './format.js';
+export * from './duration.js';

package/dist/types/{dates.d.ts → dates/rfc3339.d.ts}

@@ -1,14 +1,13 @@
+import { isLeapYear } from './civil.js';
+export { isLeapYear };
 export declare const CONST_TICKS_SECOND = 1000;
 export declare const CONST_TICKS_HOUR: number;
 export declare const CONST_TICKS_DAY: number;
 export declare const CONST_TIME_INSERTDATE = "1970-01-01T";
 export declare const CONST_DATE_APPENDTIME = "T00:00:00Z";
 export declare const CONST_RFC3339_DAYS: readonly number[];
-export declare const CONST_RFC3339_REGEX_ISDATE: RegExp;
-export declare const CONST_RFC3339_REGEX_ISTIME: RegExp;
 export declare function isDateType(data: any): boolean;
 export declare function isDateishType(data: any): boolean;
-export declare function isLeapYear(year: any): boolean;
 export declare function isDateOnlyInRange(year?: number, month?: number, day?: number): boolean;
 export declare function isDateOnlyRFC3339(str: any): boolean;
 export declare function isTimeOnlyInRange(hrs?: number, min?: number, sec?: number, tzh?: number, tzm?: number, tzSign?: number): boolean;
@@ -17,6 +16,59 @@ export declare function isDateTimeRFC3339(str: any): boolean;
 export declare function getDateTypeOfDateOnlyRFC3339(str: any, def?: undefined): Date | undefined;
 export declare function getDateTypeOfTimeOnlyRFC3339(str: any, def?: undefined): Date | undefined;
 export declare function getDateTypeOfDateTimeRFC3339(str: any, def?: undefined): Date | undefined;
+export declare function getEpochOfDateOnlyRFC3339(str: any, def?: undefined): number | undefined;
+export declare function getEpochOfTimeOnlyRFC3339(str: any, def?: undefined): number | undefined;
+export declare function getEpochOfDateTimeRFC3339(str: any, def?: undefined): number | undefined;
+/**
+ * Decompose an RFC 3339 date, time, or date-time string into its lexical
+ * components, without allocating a `Date` and without shifting anything
+ * to UTC — the components are the ones the string spells out, which is
+ * what a query grouping by year or month asks for.
+ *
+ * A missing half reads as -1: a full-date has no `hours`, a full-time no
+ * `year`. `offset` is minutes east of UTC, `null` only for a bare
+ * full-date (which RFC 3339 leaves offset-less).
+ *
+ * @param {any} str - The value to decompose
+ * @returns {{ year: number, month: number, day: number, hours: number,
+ *   minutes: number, seconds: number, offset: number | null } | null}
+ *   the components, or null when str is not an RFC 3339 value
+ * @example
+ * parseRFC3339Parts('2026-07-27T14:30:05.5+02:00');
+ * // { year: 2026, month: 7, day: 27, hours: 14, minutes: 30,
+ * //   seconds: 5.5, offset: 120 }
+ */
+export declare function parseRFC3339Parts(str: any): {
+    year: number;
+    month: number;
+    day: number;
+    hours: number;
+    minutes: number;
+    seconds: number;
+    offset: number | null;
+} | null;
+/**
+ * Milliseconds since 1970-01-01T00:00:00Z for RFC 3339 components that
+ * carry a date. Components without a date (a full-time) return NaN, as
+ * do out-of-range instants.
+ *
+ * A bare full-date has no offset and is read as UTC midnight. Note JS
+ * has no leap seconds: a `:60` second rolls into the following minute.
+ *
+ * @param {{ year: number, month: number, day: number, hours: number,
+ *   minutes: number, seconds: number, offset: number | null }} parts -
+ *   components from {@link parseRFC3339Parts}
+ * @returns {number} milliseconds since the epoch, or NaN
+ */
+export declare function epochOfRFC3339Parts(parts: {
+    year: number;
+    month: number;
+    day: number;
+    hours: number;
+    minutes: number;
+    seconds: number;
+    offset: number | null;
+}): number;
 /**
  * Validates a duration string per RFC 3339.
  * Duration format: P[n]Y[n]M[n]DT[n]H[n]M[n]S or P[n]W
@@ -77,3 +129,5 @@ export declare function getDateTypeOfISODateTime(str: string, def?: any): Date |
  * @returns {Date|undefined} - The parsed Date or default value
  */
 export declare function getDateTypeOfISOTime(str: string, def?: any): Date | undefined;
+export declare function getEpochOfISODateTime(str: any, def?: undefined): number | undefined;
+export declare function getEpochOfISOTime(str: any, def?: undefined): number | undefined;

package/dist/types/errors.d.ts

@@ -0,0 +1,77 @@
+/**
+ * @file The suite's one coded-error contract. Every engine error that
+ * carries a stable diagnosis code derives from {@link CodedError}; the
+ * canonical form is the structured triple `{ code, reason, docPath |
+ * dataPath }`, and `message` is COMPOSED from it for the channels that
+ * have no structured reader (an uncaught throw, a console, a CI
+ * transcript, a model reading `{ error: err.message }`).
+ *
+ * The rendering decision, fixed here so every package agrees:
+ *
+ *   `${code}: ${reason}`                      — no location
+ *   `${code}: ${reason} at ${docPath}`        — a document location
+ *   `${code}: ${reason} in data ${dataPath}`  — a data location
+ *   `${code}: ${reason} at ${d} in data ${p}` — both
+ *
+ * `docPath` points into the offending *document* (a query, a stylesheet,
+ * an app document); `dataPath` points into the offending *data* the
+ * document was applied to. They are different facts and stay separately
+ * readable and separately identifiable — `at` always means document,
+ * `in data` always means data. A root pointer (`''`) is a real location
+ * and renders as `at ''`; absence is `undefined` and renders nothing.
+ * Absence must never be normalized to `''` — the AI repair loop's
+ * `docPath ?? instancePath ?? ''` fallback chain relies on `undefined`
+ * to fall through, and `''` is a legitimate root pointer.
+ *
+ * Cause presence uses the `hasOwn` form: the constructor takes an
+ * options bag, and `Object.hasOwn(options, 'cause')` decides whether an
+ * own `cause` is installed — so a host that threw `undefined` (passed as
+ * `{ cause: undefined }`) stays distinguishable from "no cause" (no
+ * options, or an options bag without the key). Positional-adapter
+ * subclasses that translate an optional trailing `cause` parameter MUST
+ * map an `undefined` argument to "no cause", never to
+ * `{ cause: undefined }`.
+ *
+ * Deliberately OUTSIDE this contract: `ValidationError`
+ * (keyword-keyed, locale-rendered, has its own `toJSON`), the
+ * `LabeledSyntaxError` family (`source`/`position` over a source
+ * string), and josl's line/column family (`line`/`column`/`hint`).
+ * Different shapes for different consumers — do not "finish the job" by
+ * folding them in.
+ *
+ * Localization: `@jarenjs/locales` keys its catalogs by JSON Schema
+ * KEYWORD (`form/minLength`, …), not by error code — coded errors are
+ * localizable by nothing today. Stated so nobody assumes otherwise; a
+ * code-keyed catalog would be a new locales feature, not a property of
+ * this base.
+ */
+/**
+ * Base class for every coded error in the suite. Subclasses are thin
+ * per-package adapters that fix the public `name` (passed as a string
+ * literal because bundles are minified and a mangled class name must
+ * not leak into `error.name`) and translate their historical positional
+ * signatures into the location/options form.
+ */
+export declare class CodedError extends Error {
+    code: string;
+    reason: string;
+    docPath: string | undefined;
+    dataPath: string | undefined;
+    /**
+     * @param {string} name - The public class name for `error.name`
+     * @param {string} code - Stable diagnosis code
+     * @param {string} reason - The bare reason; `message` is composed from
+     *   `code`, `reason` and the location and must not be pre-composed
+     * @param {string | { docPath?: string, dataPath?: string }} [location]
+     *   - A string is a `docPath`; the object form carries either or both
+     * @param {{ cause?: unknown }} [options] - `cause` is installed as an
+     *   own property exactly when the key is present (`hasOwn` form),
+     *   preserving "host threw `undefined`" as distinct from "no cause"
+     */
+    constructor(name: string, code: string, reason: string, location?: string | {
+        docPath?: string;
+        dataPath?: string;
+    }, options?: {
+        cause?: unknown;
+    });
+}

package/dist/types/finance/amortization.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @file Loan amortization. Given a principal, a periodic
+ * rate and a term, produce the period-by-period split of each payment
+ * into interest and principal with the running balance.
+ */
+export type AmortRow = {
+    /**
+     * 1-based period index
+     */
+    period: number;
+    /**
+     * total payment this period
+     */
+    payment: number;
+    /**
+     * interest portion
+     */
+    interest: number;
+    /**
+     * principal portion
+     */
+    principal: number;
+    /**
+     * remaining balance after this payment
+     */
+    balance: number;
+};
+/**
+ * @typedef {object} AmortRow
+ * @property {number} period 1-based period index
+ * @property {number} payment total payment this period
+ * @property {number} interest interest portion
+ * @property {number} principal principal portion
+ * @property {number} balance remaining balance after this payment
+ */
+/**
+ * Build a full amortization schedule. The payment is derived from the
+ * standard annuity formula unless an explicit `payment` is supplied
+ * (e.g. a rounded real-world instalment); the final period absorbs any
+ * rounding residue so the balance lands exactly on zero.
+ *
+ * @param {number} principal loan amount (positive)
+ * @param {number} rate periodic interest rate
+ * @param {number} nper number of periods
+ * @param {{ payment?: number, type?: number }} [opts]
+ * @returns {AmortRow[]}
+ */
+export declare function amortizationSchedule(principal: number, rate: number, nper: number, opts?: {
+    payment?: number;
+    type?: number;
+}): AmortRow[];

package/dist/types/finance/bond.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @file Bond math: price, yield-to-maturity, Macaulay and
+ * modified duration, and convexity. Basic day-count only (level coupons,
+ * whole periods to maturity); exotic conventions are out of scope.
+ *
+ * Rates and the coupon rate are annual; `freq` coupons are paid per year.
+ */
+/**
+ * Clean price of a coupon bond.
+ * @param {number} face par/redemption value
+ * @param {number} couponRate annual coupon rate
+ * @param {number} ytm annual yield to maturity
+ * @param {number} years years to maturity
+ * @param {number} [freq] coupons per year
+ * @returns {number}
+ */
+export declare function bondPrice(face: number, couponRate: number, ytm: number, years: number, freq?: number): number;
+/**
+ * Yield to maturity from a market price (iterative).
+ * @param {number} price @param {number} face @param {number} couponRate
+ * @param {number} years @param {number} [freq]
+ * @returns {number}
+ */
+export declare function bondYTM(price: number, face: number, couponRate: number, years: number, freq?: number): number;
+/**
+ * Macaulay duration (in years).
+ * @param {number} face @param {number} couponRate @param {number} ytm
+ * @param {number} years @param {number} [freq]
+ * @returns {number}
+ */
+export declare function macaulayDuration(face: number, couponRate: number, ytm: number, years: number, freq?: number): number;
+/**
+ * Modified duration.
+ * @param {number} face @param {number} couponRate @param {number} ytm
+ * @param {number} years @param {number} [freq]
+ * @returns {number}
+ */
+export declare function modifiedDuration(face: number, couponRate: number, ytm: number, years: number, freq?: number): number;
+/**
+ * Convexity (in years²).
+ * @param {number} face @param {number} couponRate @param {number} ytm
+ * @param {number} years @param {number} [freq]
+ * @returns {number}
+ */
+export declare function convexity(face: number, couponRate: number, ytm: number, years: number, freq?: number): number;

package/dist/types/finance/cashflow.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @file Cash-flow analysis: NPV, IRR, MIRR and their
+ * date-indexed variants XNPV/XIRR. Built on `math/solve`. Cash flows are
+ * arrays with element `t` occurring at period `t` (index 0 = now).
+ */
+/**
+ * Net present value of a period-indexed cash-flow series.
+ * @param {number} rate discount rate per period
+ * @param {number[]} cashflows cashflows[t] at period t (index 0 = t0)
+ * @returns {number}
+ */
+export declare function npv(rate: number, cashflows: number[]): number;
+/**
+ * Internal rate of return: the rate for which `npv` is zero. Newton with
+ * a bisection fallback; returns `NaN` if no rate is found.
+ * @param {number[]} cashflows
+ * @param {number} [guess]
+ * @returns {number}
+ */
+export declare function irr(cashflows: number[], guess?: number): number;
+/**
+ * Modified internal rate of return.
+ * @param {number[]} cashflows
+ * @param {number} financeRate rate paid on negative flows
+ * @param {number} reinvestRate rate earned on positive flows
+ * @returns {number}
+ */
+export declare function mirr(cashflows: number[], financeRate: number, reinvestRate: number): number;
+/**
+ * Date-indexed NPV. `dates` may be `Date`s or ms timestamps.
+ * @param {number} rate annual discount rate
+ * @param {number[]} cashflows
+ * @param {Array<Date|number>} dates
+ * @returns {number}
+ */
+export declare function xnpv(rate: number, cashflows: number[], dates: Array<Date | number>): number;
+/**
+ * Date-indexed IRR.
+ * @param {number[]} cashflows
+ * @param {Array<Date|number>} dates
+ * @param {number} [guess]
+ * @returns {number}
+ */
+export declare function xirr(cashflows: number[], dates: Array<Date | number>, guess?: number): number;

package/dist/types/finance/depreciation.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @file Depreciation schedules: straight-line,
+ * declining-balance (double-declining when factor = 2) and
+ * sum-of-years-digits. Each returns an array of per-period depreciation
+ * amounts of length `life`.
+ */
+/**
+ * Straight-line depreciation: equal charge each period.
+ * @param {number} cost @param {number} salvage @param {number} life periods
+ * @returns {number[]}
+ */
+export declare function straightLine(cost: number, salvage: number, life: number): number[];
+/**
+ * Declining-balance depreciation. `factor` = 2 is double-declining. Never
+ * depreciates below salvage; the final periods absorb the remainder.
+ * @param {number} cost @param {number} salvage @param {number} life
+ * @param {number} [factor]
+ * @returns {number[]}
+ */
+export declare function decliningBalance(cost: number, salvage: number, life: number, factor?: number): number[];
+/**
+ * Sum-of-years-digits depreciation.
+ * @param {number} cost @param {number} salvage @param {number} life
+ * @returns {number[]}
+ */
+export declare function sumOfYearsDigits(cost: number, salvage: number, life: number): number[];

package/dist/types/finance/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @file `@jarenjs/core/finance` — the finance & trading formula library.
+ * Pure, zero runtime dependencies (imports only `@jarenjs/core/math`).
+ * Every export is a plain function over numbers/number-arrays, reusable
+ * by any package: a calculator, a trading dashboard or a backtester. The
+ * math lives here; orchestration (which variable to solve, forms, display)
+ * lives in the consumer.
+ */
+export { pmt, pv, fv, nper, rate } from './tvm.js';
+export { npv, irr, mirr, xnpv, xirr } from './cashflow.js';
+export { amortizationSchedule } from './amortization.js';
+export { simpleInterest, compoundAmount, compoundInterest, nominalToEffective, effectiveToNominal, continuousCompound, } from './interest.js';
+export { straightLine, decliningBalance, sumOfYearsDigits } from './depreciation.js';
+export { bondPrice, bondYTM, macaulayDuration, modifiedDuration, convexity, } from './bond.js';
+export { sma, ema, wma, macd, rsi, bollinger, stochastic, atr, roc, } from './indicators.js';
+export { cagr, holdingPeriodReturn, returnsOf, volatility, sharpe, maxDrawdown, } from './returns.js';

package/dist/types/finance/indicators.d.ts

@@ -0,0 +1,76 @@
+/**
+ * @file Technical / trading indicators over a price or OHLC
+ * series. Every function returns an array **aligned** to the input (same
+ * length), with `null` in warm-up positions where the indicator is not
+ * yet defined. Single-pass where the math allows; `Float64Array` inputs
+ * are accepted (array-like reads only).
+ */
+/**
+ * Simple moving average.
+ * @param {ArrayLike<number>} values @param {number} period
+ * @returns {Array<number|null>}
+ */
+export declare function sma(values: ArrayLike<number>, period: number): Array<number | null>;
+/**
+ * Exponential moving average (SMA-seeded).
+ * @param {ArrayLike<number>} values @param {number} period
+ * @returns {Array<number|null>}
+ */
+export declare function ema(values: ArrayLike<number>, period: number): Array<number | null>;
+/**
+ * Weighted moving average (linear weights 1..period).
+ * @param {ArrayLike<number>} values @param {number} period
+ * @returns {Array<number|null>}
+ */
+export declare function wma(values: ArrayLike<number>, period: number): Array<number | null>;
+/**
+ * MACD: line = EMA(fast) − EMA(slow), signal = EMA(line, signalPeriod),
+ * histogram = line − signal. Each is an aligned array.
+ * @param {ArrayLike<number>} values
+ * @param {number} [fast] @param {number} [slow] @param {number} [signalPeriod]
+ * @returns {{ macd: Array<number|null>, signal: Array<number|null>, histogram: Array<number|null> }}
+ */
+export declare function macd(values: ArrayLike<number>, fast?: number, slow?: number, signalPeriod?: number): {
+    macd: Array<number | null>;
+    signal: Array<number | null>;
+    histogram: Array<number | null>;
+};
+/**
+ * Relative Strength Index (Wilder's smoothing).
+ * @param {ArrayLike<number>} values @param {number} [period]
+ * @returns {Array<number|null>}
+ */
+export declare function rsi(values: ArrayLike<number>, period?: number): Array<number | null>;
+/**
+ * Bollinger Bands (population standard deviation).
+ * @param {ArrayLike<number>} values @param {number} [period] @param {number} [k]
+ * @returns {{ middle: Array<number|null>, upper: Array<number|null>, lower: Array<number|null> }}
+ */
+export declare function bollinger(values: ArrayLike<number>, period?: number, k?: number): {
+    middle: Array<number | null>;
+    upper: Array<number | null>;
+    lower: Array<number | null>;
+};
+/**
+ * Stochastic oscillator (%K and its %D moving average).
+ * @param {ArrayLike<number>} high @param {ArrayLike<number>} low @param {ArrayLike<number>} close
+ * @param {number} [kPeriod] @param {number} [dPeriod]
+ * @returns {{ k: Array<number|null>, d: Array<number|null> }}
+ */
+export declare function stochastic(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, kPeriod?: number, dPeriod?: number): {
+    k: Array<number | null>;
+    d: Array<number | null>;
+};
+/**
+ * Average True Range (Wilder's smoothing).
+ * @param {ArrayLike<number>} high @param {ArrayLike<number>} low @param {ArrayLike<number>} close
+ * @param {number} [period]
+ * @returns {Array<number|null>}
+ */
+export declare function atr(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, period?: number): Array<number | null>;
+/**
+ * Rate of change (percent) over `period`.
+ * @param {ArrayLike<number>} values @param {number} [period]
+ * @returns {Array<number|null>}
+ */
+export declare function roc(values: ArrayLike<number>, period?: number): Array<number | null>;

package/dist/types/finance/interest.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @file Interest math: simple and compound interest, nominal
+ * ↔ effective rate conversion, and continuous compounding. All pure.
+ */
+/**
+ * Simple interest accrued (not the total).
+ * @param {number} principal @param {number} rate per period @param {number} time periods
+ * @returns {number}
+ */
+export declare function simpleInterest(principal: number, rate: number, time: number): number;
+/**
+ * Compound amount (principal + interest) after `time` years compounded
+ * `periodsPerYear` times per year.
+ * @param {number} principal @param {number} annualRate @param {number} time years
+ * @param {number} [periodsPerYear]
+ * @returns {number}
+ */
+export declare function compoundAmount(principal: number, annualRate: number, time: number, periodsPerYear?: number): number;
+/**
+ * Compound interest earned (amount − principal).
+ * @param {number} principal @param {number} annualRate @param {number} time
+ * @param {number} [periodsPerYear]
+ * @returns {number}
+ */
+export declare function compoundInterest(principal: number, annualRate: number, time: number, periodsPerYear?: number): number;
+/**
+ * Effective annual rate (APY/EAR) from a nominal annual rate compounded
+ * `periodsPerYear` times.
+ * @param {number} nominal @param {number} periodsPerYear
+ * @returns {number}
+ */
+export declare function nominalToEffective(nominal: number, periodsPerYear: number): number;
+/**
+ * Nominal annual rate from an effective annual rate.
+ * @param {number} effective @param {number} periodsPerYear
+ * @returns {number}
+ */
+export declare function effectiveToNominal(effective: number, periodsPerYear: number): number;
+/**
+ * Continuously-compounded amount: `P·e^(rt)`.
+ * @param {number} principal @param {number} annualRate @param {number} time
+ * @returns {number}
+ */
+export declare function continuousCompound(principal: number, annualRate: number, time: number): number;

package/dist/types/finance/returns.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @file Return & risk statistics: CAGR, holding-period
+ * return, volatility, Sharpe ratio and maximum drawdown. Pure.
+ */
+/**
+ * Compound annual growth rate.
+ * @param {number} begin @param {number} end @param {number} years
+ * @returns {number}
+ */
+export declare function cagr(begin: number, end: number, years: number): number;
+/**
+ * Holding-period return, including any income.
+ * @param {number} begin @param {number} end @param {number} [income]
+ * @returns {number}
+ */
+export declare function holdingPeriodReturn(begin: number, end: number, income?: number): number;
+/**
+ * Convert a price series to a per-step simple-return series.
+ * @param {ArrayLike<number>} prices
+ * @returns {number[]}
+ */
+export declare function returnsOf(prices: ArrayLike<number>): number[];
+/**
+ * Volatility: the (sample) standard deviation of a return series.
+ * @param {ArrayLike<number>} returns
+ * @param {boolean} [population] use population (÷N) instead of sample (÷N−1)
+ * @returns {number}
+ */
+export declare function volatility(returns: ArrayLike<number>, population?: boolean): number;
+/**
+ * Sharpe ratio: mean excess return over its volatility.
+ * @param {ArrayLike<number>} returns
+ * @param {number} [riskFree] per-step risk-free rate
+ * @returns {number}
+ */
+export declare function sharpe(returns: ArrayLike<number>, riskFree?: number): number;
+/**
+ * Maximum drawdown of an equity curve: the largest peak-to-trough drop as
+ * a positive fraction (0.2 = a 20% drawdown).
+ * @param {ArrayLike<number>} values
+ * @returns {number}
+ */
+export declare function maxDrawdown(values: ArrayLike<number>): number;