pinets 0.2.1 → 0.5.0

package/dist/types/namespaces/ta/methods/pvi.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Positive Volume Index (PVI)
+ *
+ * Formula:
+ * If close or close[1] is 0, pvi = pvi[1]
+ * Else if volume > volume[1], pvi = pvi[1] + ((close - close[1]) / close[1]) * pvi[1]
+ * Else pvi = pvi[1]
+ * Initial value is 1.0
+ */
+export declare function pvi(context: any): (_callId?: string) => any;

package/dist/types/namespaces/ta/methods/pvt.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Price-Volume Trend (PVT)
+ *
+ * The PVT function calculates the Price-Volume Trend, which is a cumulative
+ * total of volume adjusted by the percentage change in price.
+ *
+ * Formula:
+ * PVT = Previous PVT + ((Current Close - Previous Close) / Previous Close) * Volume
+ *
+ * @returns The PVT series
+ */
+export declare function pvt(context: any): (_callId?: string) => any;

package/dist/types/namespaces/ta/methods/range.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Range
+ *
+ * Returns the difference between the highest and lowest values of a series over a given length.
+ * Formula: ta.highest(source, length) - ta.lowest(source, length)
+ */
+export declare function range(context: any): (source: any, _length: any, _callId?: string) => any;

package/dist/types/namespaces/ta/methods/rising.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Rising Detection
+ *
+ * Tests if the source series is now rising for length bars long.
+ * Returns true if the series has been consecutively rising for length bars.
+ *
+ * Formula:
+ * For length=2: source[0] > source[1] AND source[1] > source[2]
+ * For length=n: source[i] > source[i+1] for all i from 0 to n-1
+ *
+ * @param source - Series of values to process
+ * @param length - Number of bars to check (lookback period)
+ * @returns true if consecutively rising for length bars, false otherwise
+ */
+export declare function rising(context: any): (source: any, _length: any, _callId?: string) => boolean;

package/dist/types/namespaces/ta/methods/rma.d.ts

@@ -0,0 +1 @@
+export declare function rma(context: any): (source: any, _period: any, _callId?: string) => any;

package/dist/types/namespaces/ta/methods/roc.d.ts

@@ -0,0 +1 @@
+export declare function roc(context: any): (source: any, _length: any, _callId?: string) => any;

package/dist/types/namespaces/ta/methods/rsi.d.ts

@@ -0,0 +1 @@
+export declare function rsi(context: any): (source: any, _period: any, _callId?: string) => any;

package/dist/types/namespaces/ta/methods/sar.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Parabolic SAR (Stop and Reverse)
+ *
+ * Parabolic SAR is a method devised by J. Welles Wilder, Jr., to find potential reversals
+ * in the market price direction.
+ *
+ * @param start - Start acceleration factor
+ * @param inc - Increment acceleration factor
+ * @param max - Maximum acceleration factor
+ * @returns Parabolic SAR value
+ */
+export declare function sar(context: any): (_start: any, _inc: any, _max: any, _callId?: string) => any;

package/dist/types/namespaces/ta/methods/sma.d.ts

@@ -0,0 +1 @@
+export declare function sma(context: any): (source: any, _period: any, _callId?: string) => any;

package/dist/types/namespaces/ta/methods/stdev.d.ts

@@ -0,0 +1 @@
+export declare function stdev(context: any): (source: any, _length: any, _bias?: any, _callId?: string) => any;

package/dist/types/namespaces/ta/methods/stoch.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Stochastic Oscillator (STOCH)
+ *
+ * The Stochastic Oscillator is a momentum indicator that shows the location of the close
+ * relative to the high-low range over a set number of periods.
+ *
+ * Formula:
+ * STOCH = 100 * (close - lowest(low, length)) / (highest(high, length) - lowest(low, length))
+ *
+ * @param source - Source series (typically close price)
+ * @param high - Series of high prices
+ * @param low - Series of low prices
+ * @param length - Number of bars back (lookback period)
+ * @returns Stochastic value (0-100)
+ *
+ * @remarks
+ * - NaN values in the source series are ignored
+ * - Returns NaN during initialization period (when not enough data)
+ * - Returns NaN if highest equals lowest (to avoid division by zero)
+ */
+export declare function stoch(context: any): (source: any, high: any, low: any, _length: any, _callId?: string) => any;

package/dist/types/namespaces/ta/methods/supertrend.d.ts

@@ -0,0 +1,24 @@
+/**
+ * SuperTrend Indicator
+ *
+ * The Supertrend is a trend following indicator based on ATR.
+ *
+ * Pine Script Formula:
+ * src = hl2
+ * atr = ta.atr(atrPeriod)
+ * upperBand = src + factor * atr
+ * lowerBand = src - factor * atr
+ * prevLowerBand = nz(lowerBand[1])
+ * prevUpperBand = nz(upperBand[1])
+ *
+ * lowerBand := lowerBand > prevLowerBand or close[1] < prevLowerBand ? lowerBand : prevLowerBand
+ * upperBand := upperBand < prevUpperBand or close[1] > prevUpperBand ? upperBand : prevUpperBand
+ *
+ * direction: 1 (down/bearish), -1 (up/bullish)
+ * superTrend := direction == -1 ? lowerBand : upperBand
+ *
+ * @param factor - The multiplier by which the ATR will get multiplied
+ * @param atrPeriod - Length of ATR
+ * @returns Tuple [supertrend, direction] where direction is 1 (down) or -1 (up)
+ */
+export declare function supertrend(context: any): (_factor: any, _atrPeriod: any, _callId?: string) => any[][];

package/dist/types/namespaces/ta/methods/swma.d.ts

@@ -0,0 +1,14 @@
+/**
+ * SWMA - Symmetrically Weighted Moving Average
+ *
+ * Pine Script's ta.swma() uses a fixed period of 4 bars with symmetric weights.
+ * The weights are applied symmetrically: the current and 3 previous bars.
+ *
+ * Weights for 4-bar period: [1, 2, 2, 1]
+ * Formula: SWMA = (price[3]*1 + price[2]*2 + price[1]*2 + price[0]*1) / 6
+ *
+ * @param source - The data source (typically close price)
+ *
+ * Note: Unlike other moving averages, SWMA has a fixed period of 4 in Pine Script
+ */
+export declare function swma(context: any): (source: any, _callId?: string) => any;

package/dist/types/namespaces/ta/methods/tr.d.ts

@@ -0,0 +1 @@
+export declare function tr(context: any): (handle_na?: boolean, _callId?: string) => number;

package/dist/types/namespaces/ta/methods/tsi.d.ts

@@ -0,0 +1,17 @@
+/**
+ * True Strength Index (TSI)
+ *
+ * True strength index uses moving averages of the underlying momentum of a financial instrument.
+ *
+ * Formula:
+ * pc = change(source)                    // Price change
+ * double_smoothed_pc = ema(ema(pc, long_length), short_length)
+ * double_smoothed_abs_pc = ema(ema(abs(pc), long_length), short_length)
+ * tsi = double_smoothed_pc / double_smoothed_abs_pc
+ *
+ * @param source - Source series (typically close)
+ * @param shortLength - Short EMA length
+ * @param longLength - Long EMA length
+ * @returns TSI value in range [-1, 1]
+ */
+export declare function tsi(context: any): (source: any, _shortLength: any, _longLength: any, _callId?: string) => any;

package/dist/types/namespaces/ta/methods/valuewhen.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Value When
+ *
+ * Returns the value of the source series on the bar where the condition was true on the nth most recent occurrence.
+ */
+export declare function valuewhen(context: any): (condition: any, source: any, _occurrence: any, _callId?: string) => any;

package/dist/types/namespaces/ta/methods/variance.d.ts

@@ -0,0 +1 @@
+export declare function variance(context: any): (source: any, _length: any, _callId?: string) => any;

package/dist/types/namespaces/ta/methods/vwap.d.ts

@@ -0,0 +1,14 @@
+/**
+ * VWAP - Volume Weighted Average Price
+ *
+ * VWAP calculates the average price weighted by volume for a trading session.
+ * It resets at the start of each new session (typically daily).
+ *
+ * Formula: VWAP = Σ(Price × Volume) / Σ(Volume)
+ *
+ * @param source - The price source (typically close, hlc3, or ohlc4)
+ *
+ * Note: This implementation resets VWAP at the start of each trading session
+ * based on detecting new trading days (when openTime changes to a new day).
+ */
+export declare function vwap(context: any): (source: any, _callId?: string) => any;

package/dist/types/namespaces/ta/methods/vwma.d.ts

@@ -0,0 +1 @@
+export declare function vwma(context: any): (source: any, _period: any, _callId?: string) => any;

package/dist/types/namespaces/ta/methods/wad.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Williams Accumulation/Distribution (WAD)
+ *
+ * Formula:
+ * trueHigh = math.max(high, close[1])
+ * trueLow = math.min(low, close[1])
+ * mom = ta.change(close)
+ * gain = (mom > 0) ? close - trueLow : (mom < 0) ? close - trueHigh : 0
+ * ta.cum(gain)
+ */
+export declare function wad(context: any): (_callId?: string) => any;

package/dist/types/namespaces/ta/methods/wma.d.ts

@@ -0,0 +1 @@
+export declare function wma(context: any): (source: any, _period: any, _callId?: string) => any;

package/dist/types/namespaces/ta/methods/wpr.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Williams %R (WPR)
+ *
+ * The oscillator shows the current closing price in relation to the high and low
+ * of the past 'length' bars.
+ *
+ * Formula:
+ * %R = (Highest High - Close) / (Highest High - Lowest Low) * -100
+ *
+ * Note: Williams %R produces values between -100 and 0
+ * - Values near -100 indicate oversold conditions
+ * - Values near 0 indicate overbought conditions
+ *
+ * @param length - Number of bars (lookback period)
+ * @returns Williams %R value (-100 to 0)
+ */
+export declare function wpr(context: any): (_length: any, _callId?: string) => any;

package/dist/types/namespaces/ta/methods/wvad.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Williams Variable Accumulation/Distribution (WVAD)
+ *
+ * Formula:
+ * (close - open) / (high - low) * volume
+ */
+export declare function wvad(context: any): (_callId?: string) => any;

package/dist/types/namespaces/ta/ta.index.d.ts

@@ -0,0 +1,199 @@
+import { accdist } from './methods/accdist';
+import { alma } from './methods/alma';
+import { atr } from './methods/atr';
+import { barssince } from './methods/barssince';
+import { bb } from './methods/bb';
+import { bbw } from './methods/bbw';
+import { cci } from './methods/cci';
+import { change } from './methods/change';
+import { cmo } from './methods/cmo';
+import { cog } from './methods/cog';
+import { correlation } from './methods/correlation';
+import { cross } from './methods/cross';
+import { crossover } from './methods/crossover';
+import { crossunder } from './methods/crossunder';
+import { cum } from './methods/cum';
+import { dev } from './methods/dev';
+import { dmi } from './methods/dmi';
+import { ema } from './methods/ema';
+import { falling } from './methods/falling';
+import { highest } from './methods/highest';
+import { highestbars } from './methods/highestbars';
+import { hma } from './methods/hma';
+import { iii } from './methods/iii';
+import { kc } from './methods/kc';
+import { kcw } from './methods/kcw';
+import { linreg } from './methods/linreg';
+import { lowest } from './methods/lowest';
+import { lowestbars } from './methods/lowestbars';
+import { macd } from './methods/macd';
+import { median } from './methods/median';
+import { mfi } from './methods/mfi';
+import { mode } from './methods/mode';
+import { mom } from './methods/mom';
+import { nvi } from './methods/nvi';
+import { obv } from './methods/obv';
+import { param } from './methods/param';
+import { percentile_linear_interpolation } from './methods/percentile_linear_interpolation';
+import { percentile_nearest_rank } from './methods/percentile_nearest_rank';
+import { percentrank } from './methods/percentrank';
+import { pivothigh } from './methods/pivothigh';
+import { pivotlow } from './methods/pivotlow';
+import { pvi } from './methods/pvi';
+import { pvt } from './methods/pvt';
+import { range } from './methods/range';
+import { rising } from './methods/rising';
+import { rma } from './methods/rma';
+import { roc } from './methods/roc';
+import { rsi } from './methods/rsi';
+import { sar } from './methods/sar';
+import { sma } from './methods/sma';
+import { stdev } from './methods/stdev';
+import { stoch } from './methods/stoch';
+import { supertrend } from './methods/supertrend';
+import { swma } from './methods/swma';
+import { tr } from './methods/tr';
+import { tsi } from './methods/tsi';
+import { valuewhen } from './methods/valuewhen';
+import { variance } from './methods/variance';
+import { vwap } from './methods/vwap';
+import { vwma } from './methods/vwma';
+import { wad } from './methods/wad';
+import { wma } from './methods/wma';
+import { wpr } from './methods/wpr';
+import { wvad } from './methods/wvad';
+declare const methods: {
+    accdist: typeof accdist;
+    alma: typeof alma;
+    atr: typeof atr;
+    barssince: typeof barssince;
+    bb: typeof bb;
+    bbw: typeof bbw;
+    cci: typeof cci;
+    change: typeof change;
+    cmo: typeof cmo;
+    cog: typeof cog;
+    correlation: typeof correlation;
+    cross: typeof cross;
+    crossover: typeof crossover;
+    crossunder: typeof crossunder;
+    cum: typeof cum;
+    dev: typeof dev;
+    dmi: typeof dmi;
+    ema: typeof ema;
+    falling: typeof falling;
+    highest: typeof highest;
+    highestbars: typeof highestbars;
+    hma: typeof hma;
+    iii: typeof iii;
+    kc: typeof kc;
+    kcw: typeof kcw;
+    linreg: typeof linreg;
+    lowest: typeof lowest;
+    lowestbars: typeof lowestbars;
+    macd: typeof macd;
+    median: typeof median;
+    mfi: typeof mfi;
+    mode: typeof mode;
+    mom: typeof mom;
+    nvi: typeof nvi;
+    obv: typeof obv;
+    param: typeof param;
+    percentile_linear_interpolation: typeof percentile_linear_interpolation;
+    percentile_nearest_rank: typeof percentile_nearest_rank;
+    percentrank: typeof percentrank;
+    pivothigh: typeof pivothigh;
+    pivotlow: typeof pivotlow;
+    pvi: typeof pvi;
+    pvt: typeof pvt;
+    range: typeof range;
+    rising: typeof rising;
+    rma: typeof rma;
+    roc: typeof roc;
+    rsi: typeof rsi;
+    sar: typeof sar;
+    sma: typeof sma;
+    stdev: typeof stdev;
+    stoch: typeof stoch;
+    supertrend: typeof supertrend;
+    swma: typeof swma;
+    tr: typeof tr;
+    tsi: typeof tsi;
+    valuewhen: typeof valuewhen;
+    variance: typeof variance;
+    vwap: typeof vwap;
+    vwma: typeof vwma;
+    wad: typeof wad;
+    wma: typeof wma;
+    wpr: typeof wpr;
+    wvad: typeof wvad;
+};
+export declare class TechnicalAnalysis {
+    private context;
+    accdist: ReturnType<typeof methods.accdist>;
+    alma: ReturnType<typeof methods.alma>;
+    atr: ReturnType<typeof methods.atr>;
+    barssince: ReturnType<typeof methods.barssince>;
+    bb: ReturnType<typeof methods.bb>;
+    bbw: ReturnType<typeof methods.bbw>;
+    cci: ReturnType<typeof methods.cci>;
+    change: ReturnType<typeof methods.change>;
+    cmo: ReturnType<typeof methods.cmo>;
+    cog: ReturnType<typeof methods.cog>;
+    correlation: ReturnType<typeof methods.correlation>;
+    cross: ReturnType<typeof methods.cross>;
+    crossover: ReturnType<typeof methods.crossover>;
+    crossunder: ReturnType<typeof methods.crossunder>;
+    cum: ReturnType<typeof methods.cum>;
+    dev: ReturnType<typeof methods.dev>;
+    dmi: ReturnType<typeof methods.dmi>;
+    ema: ReturnType<typeof methods.ema>;
+    falling: ReturnType<typeof methods.falling>;
+    highest: ReturnType<typeof methods.highest>;
+    highestbars: ReturnType<typeof methods.highestbars>;
+    hma: ReturnType<typeof methods.hma>;
+    iii: ReturnType<typeof methods.iii>;
+    kc: ReturnType<typeof methods.kc>;
+    kcw: ReturnType<typeof methods.kcw>;
+    linreg: ReturnType<typeof methods.linreg>;
+    lowest: ReturnType<typeof methods.lowest>;
+    lowestbars: ReturnType<typeof methods.lowestbars>;
+    macd: ReturnType<typeof methods.macd>;
+    median: ReturnType<typeof methods.median>;
+    mfi: ReturnType<typeof methods.mfi>;
+    mode: ReturnType<typeof methods.mode>;
+    mom: ReturnType<typeof methods.mom>;
+    nvi: ReturnType<typeof methods.nvi>;
+    obv: ReturnType<typeof methods.obv>;
+    param: ReturnType<typeof methods.param>;
+    percentile_linear_interpolation: ReturnType<typeof methods.percentile_linear_interpolation>;
+    percentile_nearest_rank: ReturnType<typeof methods.percentile_nearest_rank>;
+    percentrank: ReturnType<typeof methods.percentrank>;
+    pivothigh: ReturnType<typeof methods.pivothigh>;
+    pivotlow: ReturnType<typeof methods.pivotlow>;
+    pvi: ReturnType<typeof methods.pvi>;
+    pvt: ReturnType<typeof methods.pvt>;
+    range: ReturnType<typeof methods.range>;
+    rising: ReturnType<typeof methods.rising>;
+    rma: ReturnType<typeof methods.rma>;
+    roc: ReturnType<typeof methods.roc>;
+    rsi: ReturnType<typeof methods.rsi>;
+    sar: ReturnType<typeof methods.sar>;
+    sma: ReturnType<typeof methods.sma>;
+    stdev: ReturnType<typeof methods.stdev>;
+    stoch: ReturnType<typeof methods.stoch>;
+    supertrend: ReturnType<typeof methods.supertrend>;
+    swma: ReturnType<typeof methods.swma>;
+    tr: ReturnType<typeof methods.tr>;
+    tsi: ReturnType<typeof methods.tsi>;
+    valuewhen: ReturnType<typeof methods.valuewhen>;
+    variance: ReturnType<typeof methods.variance>;
+    vwap: ReturnType<typeof methods.vwap>;
+    vwma: ReturnType<typeof methods.vwma>;
+    wad: ReturnType<typeof methods.wad>;
+    wma: ReturnType<typeof methods.wma>;
+    wpr: ReturnType<typeof methods.wpr>;
+    wvad: ReturnType<typeof methods.wvad>;
+    constructor(context: any);
+}
+export default TechnicalAnalysis;

package/dist/types/namespaces/ta/utils/pivothigh.d.ts

@@ -0,0 +1 @@
+export declare function pivothigh(source: number[], leftbars: number, rightbars: number): number[];

package/dist/types/namespaces/ta/utils/pivotlow.d.ts

@@ -0,0 +1 @@
+export declare function pivotlow(source: number[], leftbars: number, rightbars: number): number[];

package/dist/types/transpiler/analysis/AnalysisPass.d.ts

@@ -0,0 +1,5 @@
+import ScopeManager from './ScopeManager';
+export declare function transformNestedArrowFunctions(ast: any): void;
+export declare function preProcessContextBoundVars(ast: any, scopeManager: ScopeManager): void;
+export declare function transformArrowFunctionParams(node: any, scopeManager: ScopeManager, isRootFunction?: boolean): void;
+export declare function runAnalysisPass(ast: any, scopeManager: ScopeManager): string | undefined;

package/dist/types/transpiler/analysis/ScopeManager.d.ts

@@ -0,0 +1,47 @@
+export declare class ScopeManager {
+    private scopes;
+    private scopeTypes;
+    private scopeCounts;
+    private contextBoundVars;
+    private arrayPatternElements;
+    private rootParams;
+    private localSeriesVars;
+    private varKinds;
+    private loopVars;
+    private loopVarNames;
+    private paramIdCounter;
+    private cacheIdCounter;
+    private tempVarCounter;
+    private taCallIdCounter;
+    private hoistingStack;
+    private suppressHoisting;
+    get nextParamIdArg(): any;
+    get nextCacheIdArg(): any;
+    getNextTACallId(): any;
+    constructor();
+    pushScope(type: string): void;
+    popScope(): void;
+    getCurrentScopeType(): string;
+    getCurrentScopeCount(): number;
+    addLocalSeriesVar(name: string): void;
+    isLocalSeriesVar(name: string): boolean;
+    addContextBoundVar(name: string, isRootParam?: boolean): void;
+    removeContextBoundVar(name: any): void;
+    addArrayPatternElement(name: string): void;
+    isContextBound(name: string): boolean;
+    isArrayPatternElement(name: string): boolean;
+    isRootParam(name: string): boolean;
+    addLoopVariable(originalName: string, transformedName: string): void;
+    getLoopVariableName(name: string): string | undefined;
+    isLoopVariable(name: string): boolean;
+    addVariable(name: string, kind: string): string;
+    getVariable(name: string): [string, string];
+    generateTempVar(): string;
+    enterHoistingScope(): void;
+    exitHoistingScope(): any[];
+    addHoistedStatement(stmt: any): void;
+    setSuppressHoisting(suppress: boolean): void;
+    shouldSuppressHoisting(): boolean;
+    generateParamId(): string;
+}
+export default ScopeManager;

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

@@ -1 +1,4 @@
-export declare function transpile(fn: string | Function): Function;
+export declare function transpile(fn: string | Function, options?: {
+    debug: boolean;
+    ln?: boolean;
+}): Function;

package/dist/types/transpiler/transformers/ExpressionTransformer.d.ts

@@ -0,0 +1,7 @@
+import ScopeManager from '../analysis/ScopeManager';
+export declare function transformArrayIndex(node: any, scopeManager: ScopeManager): void;
+export declare function addArrayAccess(node: any, scopeManager: ScopeManager): void;
+export declare function transformIdentifier(node: any, scopeManager: ScopeManager): void;
+export declare function transformMemberExpression(memberNode: any, originalParamName: string, scopeManager: ScopeManager): void;
+export declare function transformFunctionArgument(arg: any, namespace: string, scopeManager: ScopeManager): any;
+export declare function transformCallExpression(node: any, scopeManager: ScopeManager, namespace?: string): void;

package/dist/types/transpiler/transformers/InjectionTransformer.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Injects implicit imports for missing context variables (data and pine namespaces)
+ * This ensures that users don't have to manually destructure context.data or context.pine
+ * @param ast The AST to transform
+ */
+export declare function injectImplicitImports(ast: any): void;

package/dist/types/transpiler/transformers/MainTransformer.d.ts

@@ -0,0 +1,6 @@
+import ScopeManager from '../analysis/ScopeManager';
+export declare function transformEqualityChecks(ast: any): void;
+export declare function runTransformationPass(ast: any, scopeManager: ScopeManager, originalParamName: string, options?: {
+    debug: boolean;
+    ln?: boolean;
+}, sourceLines?: string[]): void;

package/dist/types/transpiler/transformers/NormalizationTransformer.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Normalizes imports from context.data and context.pine to prevent renaming of native symbols.
+ * This ensures that symbols like 'close' or 'na' are always named 'close' and 'na' in the local scope,
+ * satisfying the transpiler's expectation for exact naming of context-bound variables.
+ *
+ * Transforms:
+ * const { close: close2 } = context.data;
+ * to
+ * const { close } = context.data;
+ *
+ * And renames all usages of 'close2' to 'close' within the scope.
+ *
+ * @param ast The AST to transform
+ */
+export declare function normalizeNativeImports(ast: any): void;

package/dist/types/transpiler/transformers/StatementTransformer.d.ts

@@ -0,0 +1,9 @@
+import ScopeManager from '../analysis/ScopeManager';
+export declare function transformAssignmentExpression(node: any, scopeManager: ScopeManager): void;
+export declare function transformVariableDeclaration(varNode: any, scopeManager: ScopeManager): void;
+export declare function transformForStatement(node: any, scopeManager: ScopeManager, c: any): void;
+export declare function transformWhileStatement(node: any, scopeManager: ScopeManager, c: any): void;
+export declare function transformExpression(node: any, scopeManager: ScopeManager): void;
+export declare function transformIfStatement(node: any, scopeManager: ScopeManager, c: any): void;
+export declare function transformReturnStatement(node: any, scopeManager: ScopeManager): void;
+export declare function transformFunctionDeclaration(node: any, scopeManager: ScopeManager, c: any): void;

package/dist/types/transpiler/transformers/WrapperTransformer.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Wraps unwrapped code in a context arrow function.
+ * If the code is already wrapped in a function, returns it as-is.
+ * Otherwise, wraps it in: (context) => { ... }
+ *
+ * @param code The input code string
+ * @returns The wrapped code string
+ */
+export declare function wrapInContextFunction(code: string): string;

package/dist/types/transpiler/utils/ASTFactory.d.ts

@@ -0,0 +1,20 @@
+export declare const CONTEXT_NAME = "$";
+export declare const ASTFactory: {
+    createIdentifier(name: string): any;
+    createLiteral(value: any): any;
+    createMemberExpression(object: any, property: any, computed?: boolean): any;
+    createContextIdentifier(): any;
+    createContextVariableReference(kind: string, name: string): any;
+    createContextVariableAccess0(kind: string, name: string): any;
+    createArrayAccess(object: any, index: any): any;
+    createCallExpression(callee: any, args: any[]): any;
+    createAssignmentExpression(left: any, right: any, operator?: string): any;
+    createExpressionStatement(expression: any): any;
+    createInitCall(targetVarRef: any, value: any, lookbehind?: any): any;
+    createInitVarCall(targetVarRef: any, value: any): any;
+    createGetCall(source: any, index: any): any;
+    createSetCall(target: any, value: any): any;
+    createMathEqCall(left: any, right: any): any;
+    createWrapperFunction(body: any): any;
+    createVariableDeclaration(name: string, init: any): any;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "pinets",
-    "version": "0.2.1",
+    "version": "0.5.0",
     "description": "",
     "main": "dist/pinets.dev.es.js",
     "types": "dist/types/index.d.ts",
@@ -10,11 +10,19 @@
     "type": "module",
     "scripts": {
         "test": "cross-env TEST_ENV=true vitest --reporter verbose",
-        "build:dev:all": "npm run build:dev:browser && npm run build:dev:cjs && npm run build:dev:es && tsc --emitDeclarationOnly --declaration --outDir dist/types -p tsconfig.dts.json",
+        "test:coverage": "cross-env TEST_ENV=true vitest run --coverage",
+        "test:coverage:badge": "cross-env TEST_ENV=true vitest run --coverage --exclude tests/_local/**",
+        "badge": "npm run test:coverage:badge && node scripts/generate-coverage-badge.js",
+        "generate:ta-index": "node scripts/generate-ta-index.js",
+        "generate:math-index": "node scripts/generate-math-index.js",
+        "generate:array-index": "node scripts/generate-array-index.js",
+        "generate:input-index": "node scripts/generate-input-index.js",
+        "generate:request-index": "node scripts/generate-request-index.js",
+        "build:dev:all": "npm run generate:ta-index && npm run generate:math-index && npm run generate:array-index && npm run generate:input-index && npm run generate:request-index && npm run build:dev:browser && npm run build:dev:cjs && npm run build:dev:es && tsc --emitDeclarationOnly --declaration --outDir dist/types -p tsconfig.dts.json",
         "build:dev:cjs": "cross-env BUILD=dev FORMAT=cjs rollup -c ./rollup.config.js",
         "build:dev:browser": "cross-env BUILD=dev FORMAT=browser rollup -c ./rollup.config.js",
         "build:dev:es": "cross-env BUILD=dev rollup -c ./rollup.config.js",
-        "build:prod:all": "npm run build:prod:browser && npm run build:prod:cjs && npm run build:prod:es && tsc --emitDeclarationOnly --declaration --outDir dist/types -p tsconfig.dts.json",
+        "build:prod:all": "npm run generate:ta-index && npm run generate:math-index && npm run generate:array-index && npm run generate:input-index && npm run generate:request-index && npm run build:prod:browser && npm run build:prod:cjs && npm run build:prod:es && tsc --emitDeclarationOnly --declaration --outDir dist/types -p tsconfig.dts.json",
         "build:prod:cjs": "cross-env BUILD=prod FORMAT=cjs rollup -c ./rollup.config.js",
         "build:prod:browser": "cross-env BUILD=prod FORMAT=browser rollup -c ./rollup.config.js",
         "build:prod:es": "cross-env BUILD=prod rollup -c ./rollup.config.js",
@@ -32,6 +40,7 @@
         "@rollup/plugin-json": "^6.1.0",
         "@rollup/plugin-node-resolve": "^16.0.0",
         "@vitest/coverage-v8": "^2.0.0",
+        "badgen": "^3.2.3",
         "cross-env": "^7.0.3",
         "knip": "^5.43.6",
         "rollup": "^2.79.2",