lightweight-charts-indicators 0.6.0 → 0.7.0

package/dist/community/adaptive-convergence-divergence.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Adaptive Convergence Divergence
+ *
+ * A MACD (or PPO) built from two adaptive moving averages instead of EMAs. Each adaptive average is
+ * ma = alpha * src + (1 - alpha) * nz(ma[1], sma(src, len)), with alpha = clamp(2 / (len + 1) * factor, 0.01, 1).
+ * The factor comes from the MA type: ACMO |cmo| / 100, ARSI |rsi - 50| / 50, FRMA the normalized range roughness
+ * (2 * range of len / 2 bars / range of len bars), VOLA the normalized volume ratio (volume / sma(volume) - 1); the
+ * last two are normalized to 0..1 by their min / max over len bars. The fast average uses the source and the fast
+ * length; the slow one uses the fast average, the slow length and half the alpha. ACD = fast - slow (PPO: in % of
+ * the slow one), signal = EMA (or Wilder's RMA) of ACD, histogram = ACD - signal. Colours follow ACD vs signal.
+ *
+ * Reference: "Adaptive Convergence Divergence" by singhxgurjit
+ * Licence: Mozilla Public License 2.0, as the original Pine script (https://mozilla.org/MPL/2.0/).
+ * Original notice: Copyright (c) 2025 Gurjit Singh. This source code is licensed under the Creative Commons
+ * Attribution-ShareAlike: https://creativecommons.org/licenses/by-sa/4.0/.
+ */
+import { type IndicatorResult, type InputConfig, type PlotConfig, type Bar, type SourceType } from 'oakscriptjs';
+export type AdaptiveConvergenceDivergenceMaType = 'ACMO' | 'ARSI' | 'FRMA' | 'VOLA';
+export interface AdaptiveConvergenceDivergenceInputs {
+    src: SourceType;
+    maType: AdaptiveConvergenceDivergenceMaType;
+    /** Fast length */
+    length: number;
+    slowLen: number;
+    signalLen: number;
+    /** PPO (percent) instead of MACD (difference) */
+    usePPO: boolean;
+    /** Wilder's RMA instead of EMA for the signal line */
+    useWilders: boolean;
+    bullishColor: string;
+    bearishColor: string;
+    fillTrans: number;
+    histTransUp: number;
+    histTransDown: number;
+}
+export declare const defaultInputs: AdaptiveConvergenceDivergenceInputs;
+export declare const inputConfig: InputConfig[];
+export declare const plotConfig: PlotConfig[];
+export declare const metadata: {
+    title: string;
+    shortTitle: string;
+    overlay: boolean;
+};
+export declare function calculate(bars: Bar[], inputs?: Partial<AdaptiveConvergenceDivergenceInputs>): IndicatorResult;
+export declare const AdaptiveConvergenceDivergence: {
+    calculate: typeof calculate;
+    metadata: {
+        title: string;
+        shortTitle: string;
+        overlay: boolean;
+    };
+    defaultInputs: AdaptiveConvergenceDivergenceInputs;
+    inputConfig: InputConfig[];
+    plotConfig: PlotConfig[];
+};
+//# sourceMappingURL=adaptive-convergence-divergence.d.ts.map

package/dist/community/adaptive-convergence-divergence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adaptive-convergence-divergence.d.ts","sourceRoot":"","sources":["../../src/community/adaptive-convergence-divergence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAsC,KAAK,eAAe,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,KAAK,GAAG,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAErJ,MAAM,MAAM,mCAAmC,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;AAEpF,MAAM,WAAW,mCAAmC;IAClD,GAAG,EAAE,UAAU,CAAC;IAChB,MAAM,EAAE,mCAAmC,CAAC;IAC5C,kBAAkB;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,iDAAiD;IACjD,MAAM,EAAE,OAAO,CAAC;IAChB,sDAAsD;IACtD,UAAU,EAAE,OAAO,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,eAAO,MAAM,aAAa,EAAE,mCAa3B,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,WAAW,EAapC,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,UAAU,EAIlC,CAAC;AAEF,eAAO,MAAM,QAAQ;;;;CAIpB,CAAC;AAUF,wBAAgB,SAAS,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,MAAM,GAAE,OAAO,CAAC,mCAAmC,CAAM,GAAG,eAAe,CA6FjH;AAED,eAAO,MAAM,6BAA6B;;;;;;;;;;CAMzC,CAAC"}

package/dist/community/adaptive-ehlers-filtered-percentile.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Adaptive Ehlers Filtered Percentile
+ *
+ * A volatility-adaptive EMA: its length goes from the maximum period (standard deviation of the price changes at or
+ * below 0.25 x its average) to the minimum period (at or above 1.75 x its average). An Ehlers nonlinear filter
+ * smooths it: the weighted mean of the last `ehlersLength` values, each weighted by its distance to the value
+ * `ehlersMomentum` bars before (SMA when all weights are 0). The bands are the filter +/- the percentile (nearest
+ * rank) of the distance between the source and the filter, times a multiplier. A close above the upper band starts a
+ * bullish regime, a close below the lower band a bearish regime; LONG / SHORT signals mark the regime changes, and the
+ * filter, the fill and the bars take the regime colour.
+ *
+ * Reference: "Adaptive Ehlers Filtered Percentile" by SchizoQuant
+ * Licence: Mozilla Public License 2.0, as the original Pine script (https://mozilla.org/MPL/2.0/).
+ * Original notice: © SchizoQuant
+ */
+import { type IndicatorResult, type InputConfig, type PlotConfig, type Bar, type SourceType } from 'oakscriptjs';
+import type { MarkerData, BarColorData } from '../types';
+export interface AdaptiveEhlersFilteredPercentileInputs {
+    /** Source of the adaptive MA */
+    maSrc: SourceType;
+    /** Minimum MA period (high volatility) */
+    maMin: number;
+    /** Maximum MA period (low volatility) */
+    maMax: number;
+    /** Volatility period */
+    volLen: number;
+    /** Ehlers filter length */
+    ehlersLength: number;
+    /** Ehlers momentum length */
+    ehlersMomentum: number;
+    /** Percentile length */
+    percentileLen: number;
+    /** Percentile level */
+    percentileLevel: number;
+    upperMult: number;
+    lowerMult: number;
+    showMA: boolean;
+    showBands: boolean;
+    showFill: boolean;
+    showSignals: boolean;
+    colorBars: boolean;
+    longColor: string;
+    shortColor: string;
+}
+export declare const defaultInputs: AdaptiveEhlersFilteredPercentileInputs;
+export declare const inputConfig: InputConfig[];
+export declare const plotConfig: PlotConfig[];
+export declare const metadata: {
+    title: string;
+    shortTitle: string;
+    overlay: boolean;
+};
+export declare function calculate(bars: Bar[], inputs?: Partial<AdaptiveEhlersFilteredPercentileInputs>): Omit<IndicatorResult, 'markers'> & {
+    markers: MarkerData[];
+    barColors: BarColorData[];
+};
+export declare const AdaptiveEhlersFilteredPercentile: {
+    calculate: typeof calculate;
+    metadata: {
+        title: string;
+        shortTitle: string;
+        overlay: boolean;
+    };
+    defaultInputs: AdaptiveEhlersFilteredPercentileInputs;
+    inputConfig: InputConfig[];
+    plotConfig: PlotConfig[];
+};
+//# sourceMappingURL=adaptive-ehlers-filtered-percentile.d.ts.map

package/dist/community/adaptive-ehlers-filtered-percentile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adaptive-ehlers-filtered-percentile.d.ts","sourceRoot":"","sources":["../../src/community/adaptive-ehlers-filtered-percentile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAsC,KAAK,eAAe,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,KAAK,GAAG,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AACrJ,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAEzD,MAAM,WAAW,sCAAsC;IACrD,gCAAgC;IAChC,KAAK,EAAE,UAAU,CAAC;IAClB,0CAA0C;IAC1C,KAAK,EAAE,MAAM,CAAC;IACd,yCAAyC;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,wBAAwB;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,2BAA2B;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB,6BAA6B;IAC7B,cAAc,EAAE,MAAM,CAAC;IACvB,wBAAwB;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,uBAAuB;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,eAAO,MAAM,aAAa,EAAE,sCAkB3B,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,WAAW,EAkBpC,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,UAAU,EAIlC,CAAC;AAEF,eAAO,MAAM,QAAQ;;;;CAIpB,CAAC;AASF,wBAAgB,SAAS,CACvB,IAAI,EAAE,GAAG,EAAE,EACX,MAAM,GAAE,OAAO,CAAC,sCAAsC,CAAM,GAC3D,IAAI,CAAC,eAAe,EAAE,SAAS,CAAC,GAAG;IAAE,OAAO,EAAE,UAAU,EAAE,CAAC;IAAC,SAAS,EAAE,YAAY,EAAE,CAAA;CAAE,CAkGzF;AAED,eAAO,MAAM,gCAAgC;;;;;;;;;;CAM5C,CAAC"}

package/dist/community/adaptive-entropy-trend.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Adaptive Entropy Trend
+ *
+ * Shannon entropy of the log returns of the last `Entropy Lookback` bars (10-bin histogram between the lowest and
+ * the highest return of the window), normalised by log2(10). An adaptive EMA of the close uses
+ * alpha = 2 / (lookback * (0.3 + 1.4 * entropy) + 1): it is faster when the returns are concentrated (trend) and
+ * slower when they are spread (noise). Bands around it: ATR(lookback) * multiplier * (0.5 + 1 - entropy), inner
+ * (fast multiplier) and outer (slow multiplier). The trend turns up when the close is above the inner upper band and
+ * down when it is below the inner lower band; the bands, fills and candles take the trend colour.
+ * Presets replace the lookback and the multipliers (Fast Response 12 / 1.4 / 2.8, Smooth Trend 40 / 2.2 / 4.5).
+ *
+ * Reference: "Adaptive Entropy Trend [QuantAlgo]" by QuantAlgo
+ * Licence: Mozilla Public License 2.0, as the original Pine script (https://mozilla.org/MPL/2.0/).
+ */
+import { type IndicatorResult, type InputConfig, type PlotConfig, type Bar } from 'oakscriptjs';
+import type { BarColorData } from '../types';
+export type AdaptiveEntropyTrendPreset = 'Default' | 'Fast Response' | 'Smooth Trend';
+export type AdaptiveEntropyTrendColorPreset = 'Classic' | 'Aqua' | 'Cosmic' | 'Cyber' | 'Neon' | 'Custom';
+export interface AdaptiveEntropyTrendInputs {
+    /** Entropy and ATR lookback */
+    lookbackLen: number;
+    /** Inner band multiplier */
+    fastMultiplier: number;
+    /** Outer band multiplier */
+    slowMultiplier: number;
+    /** Preset: replaces the lookback and the multipliers */
+    presetConfig: AdaptiveEntropyTrendPreset;
+    colorPreset: AdaptiveEntropyTrendColorPreset;
+    bullColor: string;
+    bearColor: string;
+    /** Transparency of the outer fills (inner fill: + 6) */
+    fillTransparency: number;
+    enableBarcolor: boolean;
+}
+export declare const defaultInputs: AdaptiveEntropyTrendInputs;
+export declare const inputConfig: InputConfig[];
+export declare const plotConfig: PlotConfig[];
+export declare const metadata: {
+    title: string;
+    shortTitle: string;
+    overlay: boolean;
+};
+export declare function calculate(bars: Bar[], inputs?: Partial<AdaptiveEntropyTrendInputs>): IndicatorResult & {
+    barColors: BarColorData[];
+};
+export declare const AdaptiveEntropyTrend: {
+    calculate: typeof calculate;
+    metadata: {
+        title: string;
+        shortTitle: string;
+        overlay: boolean;
+    };
+    defaultInputs: AdaptiveEntropyTrendInputs;
+    inputConfig: InputConfig[];
+    plotConfig: PlotConfig[];
+};
+//# sourceMappingURL=adaptive-entropy-trend.d.ts.map

package/dist/community/adaptive-entropy-trend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adaptive-entropy-trend.d.ts","sourceRoot":"","sources":["../../src/community/adaptive-entropy-trend.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAqB,KAAK,eAAe,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,KAAK,GAAG,EAAE,MAAM,aAAa,CAAC;AACnH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C,MAAM,MAAM,0BAA0B,GAAG,SAAS,GAAG,eAAe,GAAG,cAAc,CAAC;AACtF,MAAM,MAAM,+BAA+B,GAAG,SAAS,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE1G,MAAM,WAAW,0BAA0B;IACzC,+BAA+B;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,4BAA4B;IAC5B,cAAc,EAAE,MAAM,CAAC;IACvB,4BAA4B;IAC5B,cAAc,EAAE,MAAM,CAAC;IACvB,wDAAwD;IACxD,YAAY,EAAE,0BAA0B,CAAC;IACzC,WAAW,EAAE,+BAA+B,CAAC;IAC7C,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,wDAAwD;IACxD,gBAAgB,EAAE,MAAM,CAAC;IACzB,cAAc,EAAE,OAAO,CAAC;CACzB;AAED,eAAO,MAAM,aAAa,EAAE,0BAU3B,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,WAAW,EAUpC,CAAC;AAIF,eAAO,MAAM,UAAU,EAAE,UAAU,EAMlC,CAAC;AAEF,eAAO,MAAM,QAAQ;;;;CAIpB,CAAC;AAeF,wBAAgB,SAAS,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,MAAM,GAAE,OAAO,CAAC,0BAA0B,CAAM,GAAG,eAAe,GAAG;IAAE,SAAS,EAAE,YAAY,EAAE,CAAA;CAAE,CAiGxI;AAED,eAAO,MAAM,oBAAoB;;;;;;;;;;CAMhC,CAAC"}

package/dist/community/adaptive-friction-filter.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Adaptive Friction Filter (AFF)
+ *
+ * The friction is the SMA of the absolute bar-to-bar change of the source over the friction window, times the
+ * friction coefficient. The filter line starts at the source and stays flat while |source - line| is not above the
+ * friction; above it, the line moves by catch-up sensitivity * (source - line). The trend is up when the line rises,
+ * down when it falls, else unchanged. The line colour goes from the trend colour at transparency 50 to the full
+ * trend colour with the slope relative to the highest slope of the last 100 bars (optional neutral colour on flat
+ * bars). Bars and the background can take the line colour.
+ *
+ * Reference: "Adaptive Friction Filter (AFF) [QuantAlgo]" by QuantAlgo
+ * Licence: Mozilla Public License 2.0, as the original Pine script (https://mozilla.org/MPL/2.0/).
+ * Original notice: © QuantAlgo
+ */
+import { type IndicatorResult, type InputConfig, type PlotConfig, type Bar, type SourceType } from 'oakscriptjs';
+import type { BarColorData, BgColorData } from '../types';
+export interface AdaptiveFrictionFilterInputs {
+    /** Preset: 'Default' uses the three inputs below; the others replace them */
+    preset: 'Default' | 'Fast Response' | 'Smooth Trend';
+    /** Price source */
+    src: SourceType;
+    /** Friction coefficient (multiplier of the average absolute change) */
+    frictionMult: number;
+    /** Catch-up sensitivity (part of the gap closed per bar) */
+    catchupScalar: number;
+    /** Friction window (SMA length) */
+    lookback: number;
+    /** Colour preset; 'Custom' uses the colour inputs */
+    colorPreset: 'Classic' | 'Aqua' | 'Cosmic' | 'Cyber' | 'Neon' | 'Custom';
+    bullishColor: string;
+    bearishColor: string;
+    /** Flat filter bars take the neutral colour */
+    enableNeutral: boolean;
+    neutralColor: string;
+    /** Bar colouring */
+    showCandles: boolean;
+    barTransparency: number;
+    /** Background colouring */
+    showBgcolor: boolean;
+    bgTransparency: number;
+}
+export declare const defaultInputs: AdaptiveFrictionFilterInputs;
+export declare const inputConfig: InputConfig[];
+export declare const plotConfig: PlotConfig[];
+export declare const metadata: {
+    title: string;
+    shortTitle: string;
+    overlay: boolean;
+};
+export declare function calculate(bars: Bar[], inputs?: Partial<AdaptiveFrictionFilterInputs>): IndicatorResult & {
+    barColors: BarColorData[];
+    bgColors: BgColorData[];
+};
+export declare const AdaptiveFrictionFilter: {
+    calculate: typeof calculate;
+    metadata: {
+        title: string;
+        shortTitle: string;
+        overlay: boolean;
+    };
+    defaultInputs: AdaptiveFrictionFilterInputs;
+    inputConfig: InputConfig[];
+    plotConfig: PlotConfig[];
+};
+//# sourceMappingURL=adaptive-friction-filter.d.ts.map

package/dist/community/adaptive-friction-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adaptive-friction-filter.d.ts","sourceRoot":"","sources":["../../src/community/adaptive-friction-filter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAsC,KAAK,eAAe,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,KAAK,GAAG,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AACrJ,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE1D,MAAM,WAAW,4BAA4B;IAC3C,6EAA6E;IAC7E,MAAM,EAAE,SAAS,GAAG,eAAe,GAAG,cAAc,CAAC;IACrD,mBAAmB;IACnB,GAAG,EAAE,UAAU,CAAC;IAChB,uEAAuE;IACvE,YAAY,EAAE,MAAM,CAAC;IACrB,4DAA4D;IAC5D,aAAa,EAAE,MAAM,CAAC;IACtB,mCAAmC;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,qDAAqD;IACrD,WAAW,EAAE,SAAS,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC;IACzE,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,+CAA+C;IAC/C,aAAa,EAAE,OAAO,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,oBAAoB;IACpB,WAAW,EAAE,OAAO,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,2BAA2B;IAC3B,WAAW,EAAE,OAAO,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,eAAO,MAAM,aAAa,EAAE,4BAe3B,CAAC;AAKF,eAAO,MAAM,WAAW,EAAE,WAAW,EAepC,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,UAAU,EAGlC,CAAC;AAEF,eAAO,MAAM,QAAQ;;;;CAIpB,CAAC;AAgBF,wBAAgB,SAAS,CACvB,IAAI,EAAE,GAAG,EAAE,EACX,MAAM,GAAE,OAAO,CAAC,4BAA4B,CAAM,GACjD,eAAe,GAAG;IAAE,SAAS,EAAE,YAAY,EAAE,CAAC;IAAC,QAAQ,EAAE,WAAW,EAAE,CAAA;CAAE,CAyE1E;AAED,eAAO,MAAM,sBAAsB;;;;;;;;;;CAMlC,CAAC"}

package/dist/community/adaptive-gaussian-afr.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Adaptive Gaussian AFR
+ *
+ * A 4-pole Gaussian filter of hl2 whose length adapts to volatility: length = max(2, round(base length /
+ * max(ATR(lookback) / ATR(2 * lookback), 0.5))). A trailing range level (AFR) follows the filter at ATR * factor:
+ * while the close is above the previous level it ratchets up to max(filter - ATR * factor, previous level),
+ * otherwise it ratchets down to min(filter + ATR * factor, previous level). The level and the price candles are
+ * blue when the close is above the previous level and purple otherwise.
+ *
+ * Reference: "Adaptive Gaussian AFR" by Mattes00
+ * Licence: Mozilla Public License 2.0, as the original Pine script (https://mozilla.org/MPL/2.0/).
+ */
+import { type IndicatorResult, type InputConfig, type PlotConfig, type Bar } from 'oakscriptjs';
+import type { PlotCandleData } from '../types';
+export interface AdaptiveGaussianAFRInputs {
+    /** ATR period of the trailing range */
+    atrLen: number;
+    /** ATR factor of the trailing range */
+    atrMult: number;
+    /** Gaussian base length */
+    gLen: number;
+    /** Adaptive lookback (ATR(lookback) / ATR(2 * lookback)) */
+    lookback: number;
+}
+export declare const defaultInputs: AdaptiveGaussianAFRInputs;
+export declare const inputConfig: InputConfig[];
+export declare const plotConfig: PlotConfig[];
+export declare const metadata: {
+    title: string;
+    shortTitle: string;
+    overlay: boolean;
+};
+export declare function calculate(bars: Bar[], inputs?: Partial<AdaptiveGaussianAFRInputs>): IndicatorResult & {
+    plotCandles: Record<string, PlotCandleData[]>;
+};
+export declare const AdaptiveGaussianAFR: {
+    calculate: typeof calculate;
+    metadata: {
+        title: string;
+        shortTitle: string;
+        overlay: boolean;
+    };
+    defaultInputs: AdaptiveGaussianAFRInputs;
+    inputConfig: InputConfig[];
+    plotConfig: PlotConfig[];
+};
+//# sourceMappingURL=adaptive-gaussian-afr.d.ts.map

package/dist/community/adaptive-gaussian-afr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adaptive-gaussian-afr.d.ts","sourceRoot":"","sources":["../../src/community/adaptive-gaussian-afr.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAa,KAAK,eAAe,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,KAAK,GAAG,EAAE,MAAM,aAAa,CAAC;AAC3G,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C,MAAM,WAAW,yBAAyB;IACxC,uCAAuC;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,uCAAuC;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,2BAA2B;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,4DAA4D;IAC5D,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,eAAO,MAAM,aAAa,EAAE,yBAK3B,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,WAAW,EAKpC,CAAC;AAKF,eAAO,MAAM,UAAU,EAAE,UAAU,EAGlC,CAAC;AAEF,eAAO,MAAM,QAAQ;;;;CAIpB,CAAC;AAOF,wBAAgB,SAAS,CACvB,IAAI,EAAE,GAAG,EAAE,EACX,MAAM,GAAE,OAAO,CAAC,yBAAyB,CAAM,GAC9C,eAAe,GAAG;IAAE,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,EAAE,CAAC,CAAA;CAAE,CAyDrE;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;CAM/B,CAAC"}

package/dist/community/adaptive-heikin-ashi.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Adaptive Heikin Ashi [CHE]
+ *
+ * Heikin-Ashi candles whose open is an adaptive blend: haOpen = haOpen[1] * w + haClose[1] * (1 - w), with
+ * haClose = (open + high + low + close) / 4. The weight w = 0.5 + range * clamp((ATR / SMA(ATR) - 1) * sensitivity,
+ * -1, 1) moves around 0.5 with the ATR compared with its own average. The first open (and the open after an na
+ * weight) is (1 - w) * open + w * close. High / low include the HA open and close. Candles are green when the HA close
+ * is above the HA open, else red. The weight can be plotted as a diagnostic.
+ *
+ * Reference: "Adaptive Heikin Ashi [CHE]" by chervolino
+ * Licence: Mozilla Public License 2.0, as the original Pine script (https://mozilla.org/MPL/2.0/).
+ */
+import { type IndicatorResult, type InputConfig, type PlotConfig, type Bar } from 'oakscriptjs';
+import type { PlotCandleData } from '../types';
+export interface AdaptiveHeikinAshiInputs {
+    /** ATR length used to adapt the HA weighting */
+    atrLength: number;
+    /** Max deviation of the weight around 0.5 */
+    oscillationRange: number;
+    /** Scales the impact of the ATR oscillation */
+    adaptSensitivity: number;
+    showBorders: boolean;
+    showWicks: boolean;
+    colBullBody: string;
+    colBearBody: string;
+    colBullWick: string;
+    colBearWick: string;
+    colBullBorder: string;
+    colBearBorder: string;
+    /** Body transparency (0..100) */
+    transpBody: number;
+    /** Wick transparency (0..100) */
+    transpWick: number;
+    /** Border transparency (0..100) */
+    transpBorder: number;
+    /** Plot the adaptive weight */
+    showWeight: boolean;
+    weightColor: string;
+}
+export declare const defaultInputs: AdaptiveHeikinAshiInputs;
+export declare const inputConfig: InputConfig[];
+export declare const plotConfig: PlotConfig[];
+export declare const metadata: {
+    title: string;
+    shortTitle: string;
+    overlay: boolean;
+};
+export declare function calculate(bars: Bar[], inputs?: Partial<AdaptiveHeikinAshiInputs>): IndicatorResult & {
+    plotCandles: Record<string, PlotCandleData[]>;
+};
+export declare const AdaptiveHeikinAshi: {
+    calculate: typeof calculate;
+    metadata: {
+        title: string;
+        shortTitle: string;
+        overlay: boolean;
+    };
+    defaultInputs: AdaptiveHeikinAshiInputs;
+    inputConfig: InputConfig[];
+    plotConfig: PlotConfig[];
+};
+//# sourceMappingURL=adaptive-heikin-ashi.d.ts.map

package/dist/community/adaptive-heikin-ashi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adaptive-heikin-ashi.d.ts","sourceRoot":"","sources":["../../src/community/adaptive-heikin-ashi.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAa,KAAK,eAAe,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,KAAK,GAAG,EAAE,MAAM,aAAa,CAAC;AAC3G,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C,MAAM,WAAW,wBAAwB;IACvC,gDAAgD;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,6CAA6C;IAC7C,gBAAgB,EAAE,MAAM,CAAC;IACzB,+CAA+C;IAC/C,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE,OAAO,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,iCAAiC;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,iCAAiC;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,mCAAmC;IACnC,YAAY,EAAE,MAAM,CAAC;IACrB,+BAA+B;IAC/B,UAAU,EAAE,OAAO,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,eAAO,MAAM,aAAa,EAAE,wBAiB3B,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,WAAW,EAiBpC,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,UAAU,EAElC,CAAC;AAEF,eAAO,MAAM,QAAQ;;;;CAIpB,CAAC;AAKF,wBAAgB,SAAS,CACvB,IAAI,EAAE,GAAG,EAAE,EACX,MAAM,GAAE,OAAO,CAAC,wBAAwB,CAAM,GAC7C,eAAe,GAAG;IAAE,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,EAAE,CAAC,CAAA;CAAE,CAqDrE;AAED,eAAO,MAAM,kBAAkB;;;;;;;;;;CAM9B,CAAC"}

package/dist/community/adaptive-kinetic-ribbon.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Adaptive Kinetic Ribbon
+ *
+ * A kinetic line follows the source with an adaptive factor alpha = |velocity| / (|velocity| + volatility), where
+ * velocity = source - source[length] and volatility = stdev(source - source[1], length) * sensitivity; the line
+ * restarts at the source after a bar where it is na. A fast and a slow moving average of the kinetic line form a
+ * ribbon. Its colour shows the trend (fast above slow) and the acceleration (fast rising): bullish / bearish
+ * acceleration or deceleration. The ribbon fill and the price bars use the same colour. Presets replace the
+ * calculation inputs.
+ *
+ * Reference: "Adaptive Kinetic Ribbon [QuantAlgo]" by QuantAlgo
+ * Licence: Mozilla Public License 2.0, as the original Pine script (https://mozilla.org/MPL/2.0/).
+ */
+import { type IndicatorResult, type InputConfig, type PlotConfig, type Bar, type SourceType } from 'oakscriptjs';
+import type { BarColorData } from '../types';
+export type KineticMaType = 'SMA' | 'EMA' | 'WMA' | 'HMA' | 'VWMA' | 'RMA';
+export interface AdaptiveKineticRibbonInputs {
+    src: SourceType;
+    /** Lookback of the velocity and the volatility */
+    length: number;
+    /** Volatility sensitivity */
+    mult: number;
+    /** Ribbon moving average type */
+    maType: KineticMaType;
+    ribbonFastLength: number;
+    ribbonSlowLength: number;
+    /** 'Default' keeps the inputs above; the other presets replace them */
+    presetConfig: 'Default' | 'Fast Response' | 'Smooth Trend';
+    colorPreset: 'Classic' | 'Aqua' | 'Cosmic' | 'Cyber' | 'Neon' | 'Custom';
+    bullAccel: string;
+    bullDecel: string;
+    bearAccel: string;
+    bearDecel: string;
+    cloudTransparency: number;
+    enableBarColoring: boolean;
+    barTransparency: number;
+}
+export declare const defaultInputs: AdaptiveKineticRibbonInputs;
+export declare const inputConfig: InputConfig[];
+export declare const plotConfig: PlotConfig[];
+export declare const metadata: {
+    title: string;
+    shortTitle: string;
+    overlay: boolean;
+};
+export declare function calculate(bars: Bar[], inputs?: Partial<AdaptiveKineticRibbonInputs>): IndicatorResult & {
+    barColors: BarColorData[];
+};
+export declare const AdaptiveKineticRibbon: {
+    calculate: typeof calculate;
+    metadata: {
+        title: string;
+        shortTitle: string;
+        overlay: boolean;
+    };
+    defaultInputs: AdaptiveKineticRibbonInputs;
+    inputConfig: InputConfig[];
+    plotConfig: PlotConfig[];
+};
+//# sourceMappingURL=adaptive-kinetic-ribbon.d.ts.map

package/dist/community/adaptive-kinetic-ribbon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adaptive-kinetic-ribbon.d.ts","sourceRoot":"","sources":["../../src/community/adaptive-kinetic-ribbon.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAsC,KAAK,eAAe,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,KAAK,GAAG,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AACrJ,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C,MAAM,MAAM,aAAa,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,KAAK,CAAC;AAE3E,MAAM,WAAW,2BAA2B;IAC1C,GAAG,EAAE,UAAU,CAAC;IAChB,kDAAkD;IAClD,MAAM,EAAE,MAAM,CAAC;IACf,6BAA6B;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,iCAAiC;IACjC,MAAM,EAAE,aAAa,CAAC;IACtB,gBAAgB,EAAE,MAAM,CAAC;IACzB,gBAAgB,EAAE,MAAM,CAAC;IACzB,uEAAuE;IACvE,YAAY,EAAE,SAAS,GAAG,eAAe,GAAG,cAAc,CAAC;IAC3D,WAAW,EAAE,SAAS,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC;IACzE,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,iBAAiB,EAAE,OAAO,CAAC;IAC3B,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,eAAO,MAAM,aAAa,EAAE,2BAgB3B,CAAC;AAKF,eAAO,MAAM,WAAW,EAAE,WAAW,EAgBpC,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,UAAU,EAGlC,CAAC;AAEF,eAAO,MAAM,QAAQ;;;;CAIpB,CAAC;AAaF,wBAAgB,SAAS,CACvB,IAAI,EAAE,GAAG,EAAE,EACX,MAAM,GAAE,OAAO,CAAC,2BAA2B,CAAM,GAChD,eAAe,GAAG;IAAE,SAAS,EAAE,YAAY,EAAE,CAAA;CAAE,CAsEjD;AAED,eAAO,MAAM,qBAAqB;;;;;;;;;;CAMjC,CAAC"}

package/dist/community/adaptive-ml-trailing-stop.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Adaptive ML Trailing Stop [BOSWaves]
+ *
+ * An ATR trailing stop whose distance adapts to the Kaufman efficiency ratio (ER) of the close:
+ * distance = ATR * baseMultiplier * (1 + (1 - ER) * adaptiveStrength), wider in ranging markets. A K-nearest-
+ * neighbours model compares the last `knnFeatureLength` normalized closes with the same pattern `offset` bars back
+ * (offset up to `knnLookback`) and takes the inverse-distance weighted share of the K nearest patterns that were
+ * followed by a rise. The prediction (0 bearish .. 1 bullish), weighted by the neighbours' agreement, tightens the
+ * long stop and widens the short stop (or the opposite). Both raw stops are smoothed with the KAMA smoothing
+ * constant, then trail: the long stop only rises and the short stop only falls while the previous close stays on
+ * their side. The trend turns up when the close passes the previous short stop and down when it falls below the
+ * previous long stop. The active stop is drawn with a four-layer fill to the close, circles mark trend changes,
+ * diamonds mark touches of the stop (with a cooldown), and the candles take the trend colour.
+ *
+ * Reference: "Adaptive ML Trailing Stop [BOSWaves]" by BOSWaves
+ * Licence: Mozilla Public License 2.0, as the original Pine script (https://mozilla.org/MPL/2.0/).
+ * Original notice: © BOSWaves
+ */
+import { type IndicatorResult, type InputConfig, type PlotConfig, type Bar } from 'oakscriptjs';
+import type { MarkerData, BarColorData } from '../types';
+export interface AdaptiveMLTrailingStopInputs {
+    /** KAMA length (efficiency ratio period) */
+    kamaLength: number;
+    /** Fast period of the KAMA smoothing constant */
+    fastLength: number;
+    /** Slow period of the KAMA smoothing constant */
+    slowLength: number;
+    /** ATR period */
+    atrPeriod: number;
+    /** Base ATR multiplier */
+    baseMultiplier: number;
+    /** Adaptive strength (wider stops in ranging markets) */
+    adaptiveStrength: number;
+    /** Enable the KNN adjustment */
+    knnEnabled: boolean;
+    /** K neighbours */
+    knnK: number;
+    /** KNN lookback period (bars searched for similar patterns) */
+    knnLookback: number;
+    /** Pattern length */
+    knnFeatureLength: number;
+    /** KNN influence on the stop distance */
+    knnWeight: number;
+    /** Minimum number of bars between two diamonds */
+    diamondCooldown: number;
+    longColor: string;
+    shortColor: string;
+    showGradient: boolean;
+}
+export declare const defaultInputs: AdaptiveMLTrailingStopInputs;
+export declare const inputConfig: InputConfig[];
+export declare const plotConfig: PlotConfig[];
+export declare const metadata: {
+    title: string;
+    shortTitle: string;
+    overlay: boolean;
+};
+export declare function calculate(bars: Bar[], inputs?: Partial<AdaptiveMLTrailingStopInputs>): Omit<IndicatorResult, 'markers'> & {
+    markers: MarkerData[];
+    barColors: BarColorData[];
+};
+export declare const AdaptiveMLTrailingStop: {
+    calculate: typeof calculate;
+    metadata: {
+        title: string;
+        shortTitle: string;
+        overlay: boolean;
+    };
+    defaultInputs: AdaptiveMLTrailingStopInputs;
+    inputConfig: InputConfig[];
+    plotConfig: PlotConfig[];
+};
+//# sourceMappingURL=adaptive-ml-trailing-stop.d.ts.map

package/dist/community/adaptive-ml-trailing-stop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adaptive-ml-trailing-stop.d.ts","sourceRoot":"","sources":["../../src/community/adaptive-ml-trailing-stop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAa,KAAK,eAAe,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,KAAK,GAAG,EAAE,MAAM,aAAa,CAAC;AAC3G,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAEzD,MAAM,WAAW,4BAA4B;IAC3C,4CAA4C;IAC5C,UAAU,EAAE,MAAM,CAAC;IACnB,iDAAiD;IACjD,UAAU,EAAE,MAAM,CAAC;IACnB,iDAAiD;IACjD,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,0BAA0B;IAC1B,cAAc,EAAE,MAAM,CAAC;IACvB,yDAAyD;IACzD,gBAAgB,EAAE,MAAM,CAAC;IACzB,gCAAgC;IAChC,UAAU,EAAE,OAAO,CAAC;IACpB,mBAAmB;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,+DAA+D;IAC/D,WAAW,EAAE,MAAM,CAAC;IACpB,qBAAqB;IACrB,gBAAgB,EAAE,MAAM,CAAC;IACzB,yCAAyC;IACzC,SAAS,EAAE,MAAM,CAAC;IAClB,kDAAkD;IAClD,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,OAAO,CAAC;CACvB;AAED,eAAO,MAAM,aAAa,EAAE,4BAgB3B,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,WAAW,EAgBpC,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,UAAU,EAQlC,CAAC;AAEF,eAAO,MAAM,QAAQ;;;;CAIpB,CAAC;AA+CF,wBAAgB,SAAS,CACvB,IAAI,EAAE,GAAG,EAAE,EACX,MAAM,GAAE,OAAO,CAAC,4BAA4B,CAAM,GACjD,IAAI,CAAC,eAAe,EAAE,SAAS,CAAC,GAAG;IAAE,OAAO,EAAE,UAAU,EAAE,CAAC;IAAC,SAAS,EAAE,YAAY,EAAE,CAAA;CAAE,CA2LzF;AAED,eAAO,MAAM,sBAAsB;;;;;;;;;;CAMlC,CAAC"}

package/dist/community/adaptive-nadaraya-watson.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Adaptive Nadaraya-Watson (Non Repainting)
+ *
+ * Endpoint Gaussian kernel regression of the source over the last `lookback` + 1 bars: weights
+ * exp(-i^2 / (2 h^2)) for i = 0..lookback. With the adaptive volatility the bandwidth h is the base bandwidth times
+ * ATR(20) / SMA(ATR(20), 100), clamped to 0.5..2. Envelopes at the SMA of the absolute error (MAE) times the inner and
+ * outer multipliers. The colour is a gradient of the EMA(5) of the slope against 2 standard deviations of the slope.
+ * Signals: a rejection of the outer band (high above / low below, close back inside, against the candle direction)
+ * with a weakening move while trending; in a range the inner band, with or without the weakening check.
+ *
+ * Reference: "Adaptive Nadaraya-Watson [Metrify]" by Metrify
+ * Licence: Mozilla Public License 2.0, as the original Pine script (https://mozilla.org/MPL/2.0/).
+ * Original notice: @Metrify
+ */
+import { type IndicatorResult, type InputConfig, type PlotConfig, type Bar, type SourceType } from 'oakscriptjs';
+import type { MarkerData } from '../types';
+export interface AdaptiveNadarayaWatsonInputs {
+    /** Base bandwidth (h) */
+    hVal: number;
+    /** Lookback window of the kernel regression (and of the MAE) */
+    lookback: number;
+    /** Bandwidth adapts to volatility */
+    useVol: boolean;
+    /** Inner band multiplier */
+    multIn: number;
+    /** Outer band multiplier */
+    multOut: number;
+    /** Source price */
+    src: SourceType;
+    /** Range filter: inner band signals need a weakening move */
+    filterRng: boolean;
+    colBull: string;
+    colBear: string;
+    colNeut: string;
+}
+export declare const defaultInputs: AdaptiveNadarayaWatsonInputs;
+export declare const inputConfig: InputConfig[];
+export declare const plotConfig: PlotConfig[];
+export declare const metadata: {
+    title: string;
+    shortTitle: string;
+    overlay: boolean;
+};
+export declare function calculate(bars: Bar[], inputs?: Partial<AdaptiveNadarayaWatsonInputs>): Omit<IndicatorResult, 'markers'> & {
+    markers: MarkerData[];
+};
+export declare const AdaptiveNadarayaWatson: {
+    calculate: typeof calculate;
+    metadata: {
+        title: string;
+        shortTitle: string;
+        overlay: boolean;
+    };
+    defaultInputs: AdaptiveNadarayaWatsonInputs;
+    inputConfig: InputConfig[];
+    plotConfig: PlotConfig[];
+};
+//# sourceMappingURL=adaptive-nadaraya-watson.d.ts.map

package/dist/community/adaptive-nadaraya-watson.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adaptive-nadaraya-watson.d.ts","sourceRoot":"","sources":["../../src/community/adaptive-nadaraya-watson.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAsC,KAAK,eAAe,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,KAAK,GAAG,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AACrJ,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAE3C,MAAM,WAAW,4BAA4B;IAC3C,yBAAyB;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,gEAAgE;IAChE,QAAQ,EAAE,MAAM,CAAC;IACjB,qCAAqC;IACrC,MAAM,EAAE,OAAO,CAAC;IAChB,4BAA4B;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,4BAA4B;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,mBAAmB;IACnB,GAAG,EAAE,UAAU,CAAC;IAChB,6DAA6D;IAC7D,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,aAAa,EAAE,4BAW3B,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,WAAW,EAWpC,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,UAAU,EASlC,CAAC;AAEF,eAAO,MAAM,QAAQ;;;;CAIpB,CAAC;AAQF,wBAAgB,SAAS,CACvB,IAAI,EAAE,GAAG,EAAE,EACX,MAAM,GAAE,OAAO,CAAC,4BAA4B,CAAM,GACjD,IAAI,CAAC,eAAe,EAAE,SAAS,CAAC,GAAG;IAAE,OAAO,EAAE,UAAU,EAAE,CAAA;CAAE,CA8H9D;AAED,eAAO,MAAM,sBAAsB;;;;;;;;;;CAMlC,CAAC"}