oakscriptjs 0.8.2 → 0.9.1

package/dist/cjs/color/index.d.ts

@@ -0,0 +1,286 @@
+/**
+ * Color namespace
+ * Mirrors PineScript's color.* functions for color creation and manipulation.
+ *
+ * @remarks
+ * All color functions in this namespace follow PineScript v6 API specifications.
+ * Colors are represented as RGB or RGBA strings.
+ * Transparency values range from 0 (fully opaque) to 100 (fully transparent).
+ *
+ * @version 6
+ */
+import type { color, int, float, simple_int, simple_float } from '../types/index.js';
+/**
+ * Creates a color from RGB values with optional transparency.
+ *
+ * @param red - Red component (0-255, values are clamped)
+ * @param green - Green component (0-255, values are clamped)
+ * @param blue - Blue component (0-255, values are clamped)
+ * @param transp - Optional transparency (0-100). 0 = opaque, 100 = fully transparent
+ * @returns Color string in rgb() or rgba() format
+ *
+ * @remarks
+ * - RGB values are automatically clamped to the 0-255 range
+ * - Transparency of 0 or omitted results in rgb() format
+ * - Transparency > 0 results in rgba() format
+ * - Transparency is converted to alpha channel (0-1 range)
+ *
+ * PineScript rules:
+ * - an `na` channel is 0; a fractional channel is truncated (127.6 is 127)
+ * - the transparency is clamped to 0..100 (140 is fully transparent, -5 is opaque); an `na` transparency is fully
+ *   transparent
+ *
+ * @example
+ * ```typescript
+ * color.rgb(255, 0, 0) // Returns: "rgb(255, 0, 0)" - Red
+ * color.rgb(0, 255, 0, 50) // Returns: "rgba(0, 255, 0, 0.5)" - Semi-transparent green
+ * color.rgb(300, 0, 0) // Returns: "rgb(255, 0, 0)" - Clamped to 255
+ * ```
+ */
+export declare function rgb(red: simple_int, green: simple_int, blue: simple_int, transp?: simple_float): string;
+/**
+ * Creates a color from a hexadecimal string with optional transparency.
+ *
+ * @param hex - Hex color string (with or without '#' prefix, e.g., "#FF0000" or "FF0000")
+ * @param transp - Optional transparency (0-100). 0 = opaque, 100 = fully transparent
+ * @returns Color string in rgb() or rgba() format
+ *
+ * @remarks
+ * - Accepts hex strings with or without '#' prefix
+ * - Case-insensitive (accepts both "FF0000" and "ff0000")
+ * - Must be 6 characters (excluding '#')
+ * - Format: RRGGBB where each component is 00-FF
+ *
+ * @example
+ * ```typescript
+ * color.from_hex("#FF0000") // Returns: "rgb(255, 0, 0)" - Red
+ * color.from_hex("00FF00", 50) // Returns: "rgba(0, 255, 0, 0.5)" - Semi-transparent green
+ * color.from_hex("#0000FF") // Returns: "rgb(0, 0, 255)" - Blue
+ * color.from_hex("FFA500") // Returns: "rgb(255, 165, 0)" - Orange
+ * ```
+ */
+export declare function from_hex(hex: string, transp?: simple_float): string;
+/**
+ * Creates a new color with modified transparency, preserving RGB components.
+ *
+ * @param baseColor - The base color to modify
+ * @param transp - New transparency value (0-100). 0 = opaque, 100 = fully transparent
+ * @returns New color with updated transparency
+ *
+ * @remarks
+ * - Preserves the RGB values from the base color
+ * - Replaces the transparency with the new value
+ * - Useful for creating semi-transparent versions of existing colors
+ * - PineScript clamps the transparency to 0..100 (`color.new(c, 140)` is fully transparent, `color.new(c, -5)` is
+ *   opaque); an `na` transparency is fully transparent
+ *
+ * @example
+ * ```typescript
+ * const red = color.rgb(255, 0, 0)
+ * color.new_color(red, 50) // Returns: "rgba(255, 0, 0, 0.5)" - Semi-transparent red
+ * color.new_color(red, 0) // Returns: "rgb(255, 0, 0)" - Fully opaque
+ * color.new_color(red, 100) // Returns: "rgba(255, 0, 0, 0)" - Fully transparent
+ * ```
+ */
+export declare function new_color(baseColor: color, transp: simple_float): string;
+/**
+ * Extracts the red component from a color.
+ *
+ * @param clr - The color to extract from
+ * @returns Red component value (0-255)
+ *
+ * @example
+ * ```typescript
+ * color.r(color.rgb(255, 128, 64)) // Returns: 255
+ * color.r(color.from_hex("#FF0000")) // Returns: 255
+ * color.r(color.from_hex("#FFA500")) // Returns: 255 (orange)
+ * ```
+ */
+export declare function r(clr: color): int;
+/**
+ * Extracts the green component from a color.
+ *
+ * @param clr - The color to extract from
+ * @returns Green component value (0-255)
+ *
+ * @example
+ * ```typescript
+ * color.g(color.rgb(255, 128, 64)) // Returns: 128
+ * color.g(color.from_hex("#00FF00")) // Returns: 255
+ * color.g(color.from_hex("#FFA500")) // Returns: 165 (orange)
+ * ```
+ */
+export declare function g(clr: color): int;
+/**
+ * Extracts the blue component from a color.
+ *
+ * @param clr - The color to extract from
+ * @returns Blue component value (0-255)
+ *
+ * @example
+ * ```typescript
+ * color.b(color.rgb(255, 128, 64)) // Returns: 64
+ * color.b(color.from_hex("#0000FF")) // Returns: 255
+ * color.b(color.from_hex("#FFA500")) // Returns: 0 (orange)
+ * ```
+ */
+export declare function b(clr: color): int;
+/**
+ * Extracts the transparency component from a color.
+ *
+ * @param clr - The color to extract from
+ * @returns Transparency value (0-100). 0 = fully opaque, 100 = fully transparent
+ *
+ * @remarks
+ * - Returns 0 for colors without transparency (rgb format)
+ * - Converts alpha channel (0-1) to transparency (0-100)
+ * - PineScript stores the alpha as a byte (0-255) and returns an integer transparency:
+ *   `color.t(color.new(c, 33.3))` is 33
+ *
+ * @example
+ * ```typescript
+ * color.t(color.rgb(255, 0, 0)) // Returns: 0 (opaque)
+ * color.t(color.rgb(255, 0, 0, 50)) // Returns: 50
+ * color.t(color.rgb(255, 0, 0, 100)) // Returns: 100 (fully transparent)
+ * ```
+ */
+export declare function t(clr: color): float;
+/**
+ * Aqua/Cyan color constant
+ * @constant {string} #00BCD4 - RGB(0, 188, 212)
+ */
+export declare const aqua = "#00BCD4";
+/**
+ * Black color constant
+ * @constant {string} #363A45 - RGB(54, 58, 69)
+ */
+export declare const black = "#363A45";
+/**
+ * Blue color constant
+ * @constant {string} #2962FF - RGB(41, 98, 255)
+ */
+export declare const blue = "#2962FF";
+/**
+ * Fuchsia/Magenta color constant
+ * @constant {string} #E040FB - RGB(224, 64, 251)
+ */
+export declare const fuchsia = "#E040FB";
+/**
+ * Gray color constant
+ * @constant {string} #787B86 - RGB(120, 123, 134)
+ */
+export declare const gray = "#787B86";
+/**
+ * Green color constant (same as lime)
+ * @constant {string} #4CAF50 - RGB(76, 175, 80)
+ */
+export declare const green = "#4CAF50";
+/**
+ * Lime color constant (same as green)
+ * @constant {string} #00E676 - RGB(0, 230, 118)
+ */
+export declare const lime = "#00E676";
+/**
+ * Maroon color constant
+ * @constant {string} #880E4F - RGB(136, 14, 79)
+ */
+export declare const maroon = "#880E4F";
+/**
+ * Navy color constant
+ * @constant {string} #311B92 - RGB(49, 27, 146)
+ */
+export declare const navy = "#311B92";
+/**
+ * Olive color constant
+ * @constant {string} #808000 - RGB(128, 128, 0)
+ */
+export declare const olive = "#808000";
+/**
+ * Orange color constant
+ * @constant {string} #FF9800 - RGB(255, 152, 0)
+ */
+export declare const orange = "#FF9800";
+/**
+ * Purple color constant
+ * @constant {string} #9C27B0 - RGB(156, 39, 176)
+ */
+export declare const purple = "#9C27B0";
+/**
+ * Red color constant
+ * @constant {string} #F23645 - RGB(242, 54, 69)
+ */
+export declare const red = "#F23645";
+/**
+ * Silver color constant
+ * @constant {string} #B2B5BE - RGB(178, 181, 190)
+ */
+export declare const silver = "#B2B5BE";
+/**
+ * Teal color constant
+ * @constant {string} #089981 - RGB(8, 153, 129)
+ */
+export declare const teal = "#089981";
+/**
+ * White color constant
+ * @constant {string} #FFFFFF - RGB(255, 255, 255)
+ */
+export declare const white = "#FFFFFF";
+/**
+ * Yellow color constant
+ * @constant {string} #FDD835 - RGB(253, 216, 53)
+ */
+export declare const yellow = "#FDD835";
+/**
+ * Creates a color from a gradient based on value position.
+ *
+ * @param value - Value to calculate position-dependent color
+ * @param bottom_value - Bottom position value corresponding to bottom_color
+ * @param top_value - Top position value corresponding to top_color
+ * @param bottom_color - Bottom position color
+ * @param top_color - Top position color
+ * @returns Color calculated from linear gradient
+ *
+ * @remarks
+ * PineScript rules:
+ * - If value <= bottom_value, returns bottom_color; else if value >= top_value, returns top_color
+ * - An inverted range (bottom_value > top_value) returns bottom_color, wherever the value is
+ * - Otherwise the colours are mixed with their transparency (premultiplied alpha, alpha as a byte); the RGB channels
+ *   and the alpha are truncated. PineScript's float rounding order is not known: a channel can differ by 1 when the
+ *   exact result is an integer (same RGB at both ends)
+ * - An na value or bottom_value / top_value, or bottom_value == top_value, gives a fully transparent colour
+ * - An na colour counts as fully transparent
+ * - Works with rgb(), rgba() and hex (#RRGGBB, #RRGGBBAA) colours
+ *
+ * @example
+ * ```typescript
+ * // Value at middle of range gets middle color
+ * const midColor = color.from_gradient(50, 0, 100,
+ *   color.rgb(255, 0, 0),    // Red at bottom
+ *   color.rgb(0, 255, 0)      // Green at top
+ * ); // Returns color between red and green
+ *
+ * // Value at extremes
+ * const lowColor = color.from_gradient(-10, 0, 100, red, green); // Returns red
+ * const highColor = color.from_gradient(150, 0, 100, red, green); // Returns green
+ * ```
+ */
+export declare function from_gradient(value: float, bottom_value: float, top_value: float, bottom_color: color, top_color: color): string;
+/**
+ * Alias for new_color function.
+ * Creates a new color with specified transparency from an existing color.
+ *
+ * @param baseColor - The base color
+ * @param transp - Transparency value (0-100). 0 = fully opaque, 100 = fully transparent
+ * @returns New color with applied transparency
+ *
+ * @remarks
+ * This is an alias for `new_color()` to match PineScript's `color.new()` syntax.
+ *
+ * @example
+ * ```typescript
+ * const redColor = color.rgb(255, 0, 0);
+ * const transparentRed = color.new(redColor, 50); // 50% transparent red
+ * ```
+ */
+export { new_color as new };
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/color/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/color/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAcrF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,GAAG,CAAC,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,YAAY,GAAG,MAAM,CAUvG;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,YAAY,GAAG,MAAM,CASnE;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,SAAS,CAAC,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY,GAAG,MAAM,CAIxE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,CAAC,CAAC,GAAG,EAAE,KAAK,GAAG,GAAG,CAEjC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,CAAC,CAAC,GAAG,EAAE,KAAK,GAAG,GAAG,CAEjC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,CAAC,CAAC,GAAG,EAAE,KAAK,GAAG,GAAG,CAEjC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,CAAC,CAAC,GAAG,EAAE,KAAK,GAAG,KAAK,CAEnC;AAID;;;GAGG;AACH,eAAO,MAAM,IAAI,YAAY,CAAC;AAE9B;;;GAGG;AACH,eAAO,MAAM,KAAK,YAAY,CAAC;AAE/B;;;GAGG;AACH,eAAO,MAAM,IAAI,YAAY,CAAC;AAE9B;;;GAGG;AACH,eAAO,MAAM,OAAO,YAAY,CAAC;AAEjC;;;GAGG;AACH,eAAO,MAAM,IAAI,YAAY,CAAC;AAE9B;;;GAGG;AACH,eAAO,MAAM,KAAK,YAAY,CAAC;AAE/B;;;GAGG;AACH,eAAO,MAAM,IAAI,YAAY,CAAC;AAE9B;;;GAGG;AACH,eAAO,MAAM,MAAM,YAAY,CAAC;AAEhC;;;GAGG;AACH,eAAO,MAAM,IAAI,YAAY,CAAC;AAE9B;;;GAGG;AACH,eAAO,MAAM,KAAK,YAAY,CAAC;AAE/B;;;GAGG;AACH,eAAO,MAAM,MAAM,YAAY,CAAC;AAEhC;;;GAGG;AACH,eAAO,MAAM,MAAM,YAAY,CAAC;AAEhC;;;GAGG;AACH,eAAO,MAAM,GAAG,YAAY,CAAC;AAE7B;;;GAGG;AACH,eAAO,MAAM,MAAM,YAAY,CAAC;AAEhC;;;GAGG;AACH,eAAO,MAAM,IAAI,YAAY,CAAC;AAE9B;;;GAGG;AACH,eAAO,MAAM,KAAK,YAAY,CAAC;AAE/B;;;GAGG;AACH,eAAO,MAAM,MAAM,YAAY,CAAC;AAEhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,KAAK,EACZ,YAAY,EAAE,KAAK,EACnB,SAAS,EAAE,KAAK,EAChB,YAAY,EAAE,KAAK,EACnB,SAAS,EAAE,KAAK,GACf,MAAM,CA0BR;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAAE,SAAS,IAAI,GAAG,EAAE,CAAC"}

package/dist/cjs/color/index.js

@@ -0,0 +1,122 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var color_exports = {};
+__export(color_exports, {
+  aqua: () => aqua,
+  b: () => b,
+  black: () => black,
+  blue: () => blue,
+  from_gradient: () => from_gradient,
+  from_hex: () => from_hex,
+  fuchsia: () => fuchsia,
+  g: () => g,
+  gray: () => gray,
+  green: () => green,
+  lime: () => lime,
+  maroon: () => maroon,
+  navy: () => navy,
+  new: () => new_color,
+  new_color: () => new_color,
+  olive: () => olive,
+  orange: () => orange,
+  purple: () => purple,
+  r: () => r,
+  red: () => red,
+  rgb: () => rgb,
+  silver: () => silver,
+  t: () => t,
+  teal: () => teal,
+  white: () => white,
+  yellow: () => yellow
+});
+module.exports = __toCommonJS(color_exports);
+var import_parse = require("./parse.js");
+const channel = (v) => v === null || v === void 0 || Number.isNaN(v) ? 0 : Math.max(0, Math.min(255, Math.trunc(v)));
+const alphaOf = (transp) => transp === null || Number.isNaN(transp) ? 0 : 1 - Math.max(0, Math.min(100, transp)) / 100;
+function rgb(red2, green2, blue2, transp) {
+  const r2 = channel(red2);
+  const g2 = channel(green2);
+  const b2 = channel(blue2);
+  const a = transp !== void 0 ? alphaOf(transp) : 1;
+  if (a === 1) {
+    return `rgb(${r2}, ${g2}, ${b2})`;
+  }
+  return `rgba(${r2}, ${g2}, ${b2}, ${a})`;
+}
+function from_hex(hex, transp) {
+  hex = hex.replace("#", "");
+  const r2 = parseInt(hex.substring(0, 2), 16);
+  const g2 = parseInt(hex.substring(2, 4), 16);
+  const b2 = parseInt(hex.substring(4, 6), 16);
+  return rgb(r2, g2, b2, transp);
+}
+function new_color(baseColor, transp) {
+  const rgba = (0, import_parse.parseColor)(baseColor);
+  return rgb(rgba.r, rgba.g, rgba.b, transp);
+}
+function r(clr) {
+  return (0, import_parse.parseColor)(clr).r;
+}
+function g(clr) {
+  return (0, import_parse.parseColor)(clr).g;
+}
+function b(clr) {
+  return (0, import_parse.parseColor)(clr).b;
+}
+function t(clr) {
+  return Math.round((1 - (0, import_parse.alphaByte)((0, import_parse.parseColor)(clr).a) / 255) * 100);
+}
+const aqua = "#00BCD4";
+const black = "#363A45";
+const blue = "#2962FF";
+const fuchsia = "#E040FB";
+const gray = "#787B86";
+const green = "#4CAF50";
+const lime = "#00E676";
+const maroon = "#880E4F";
+const navy = "#311B92";
+const olive = "#808000";
+const orange = "#FF9800";
+const purple = "#9C27B0";
+const red = "#F23645";
+const silver = "#B2B5BE";
+const teal = "#089981";
+const white = "#FFFFFF";
+const yellow = "#FDD835";
+function from_gradient(value, bottom_value, top_value, bottom_color, top_color) {
+  const transparent = "rgba(0, 0, 0, 0)";
+  if ([value, bottom_value, top_value].some((v) => v === null || v === void 0 || Number.isNaN(v)) || bottom_value === top_value) {
+    return transparent;
+  }
+  const k = value <= bottom_value || bottom_value > top_value ? 0 : value >= top_value ? 1 : (value - bottom_value) / (top_value - bottom_value);
+  const rgba = (c) => {
+    if (c === null || c === void 0) return { r: 0, g: 0, b: 0, a: 0 };
+    const p = (0, import_parse.parseColor)(c);
+    return { r: p.r, g: p.g, b: p.b, a: (0, import_parse.alphaByte)(p.a) };
+  };
+  const c1 = rgba(bottom_color);
+  const c2 = rgba(top_color);
+  const a = c1.a * (1 - k) + c2.a * k;
+  if (a === 0) return transparent;
+  const mix = (x1, x2) => Math.floor((x1 / 255 * c1.a * (1 - k) + x2 / 255 * c2.a * k) / (a / 255));
+  const [r2, g2, b2] = [mix(c1.r, c2.r), mix(c1.g, c2.g), mix(c1.b, c2.b)];
+  const alpha = Math.floor(a);
+  return alpha === 255 ? `rgb(${r2}, ${g2}, ${b2})` : `rgba(${r2}, ${g2}, ${b2}, ${alpha / 255})`;
+}
+//# sourceMappingURL=index.js.map

package/dist/cjs/color/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/color/index.ts"],
+  "sourcesContent": ["/**\n * Color namespace\n * Mirrors PineScript's color.* functions for color creation and manipulation.\n *\n * @remarks\n * All color functions in this namespace follow PineScript v6 API specifications.\n * Colors are represented as RGB or RGBA strings.\n * Transparency values range from 0 (fully opaque) to 100 (fully transparent).\n *\n * @version 6\n */\n\nimport type { color, int, float, simple_int, simple_float } from '../types/index.js';\nimport { alphaByte, parseColor } from './parse.js';\n\n/** Channel of color.rgb: na is 0, a fraction is truncated. */\nconst channel = (v: number): int =>\n  v === null || v === undefined || Number.isNaN(v) ? 0 : Math.max(0, Math.min(255, Math.trunc(v)));\n\n/**\n * Alpha (0-1) of a transparency given to color.rgb / color.new: na is fully transparent, clamped to 0..100.\n * `1 - t / 100` as in PineScript: `color.new(c, 90)` has the alpha byte 25 (0.09999999999999998 * 255 rounded).\n */\nconst alphaOf = (transp: number): float =>\n  transp === null || Number.isNaN(transp) ? 0 : 1 - Math.max(0, Math.min(100, transp)) / 100;\n\n/**\n * Creates a color from RGB values with optional transparency.\n *\n * @param red - Red component (0-255, values are clamped)\n * @param green - Green component (0-255, values are clamped)\n * @param blue - Blue component (0-255, values are clamped)\n * @param transp - Optional transparency (0-100). 0 = opaque, 100 = fully transparent\n * @returns Color string in rgb() or rgba() format\n *\n * @remarks\n * - RGB values are automatically clamped to the 0-255 range\n * - Transparency of 0 or omitted results in rgb() format\n * - Transparency > 0 results in rgba() format\n * - Transparency is converted to alpha channel (0-1 range)\n *\n * PineScript rules:\n * - an `na` channel is 0; a fractional channel is truncated (127.6 is 127)\n * - the transparency is clamped to 0..100 (140 is fully transparent, -5 is opaque); an `na` transparency is fully\n *   transparent\n *\n * @example\n * ```typescript\n * color.rgb(255, 0, 0) // Returns: \"rgb(255, 0, 0)\" - Red\n * color.rgb(0, 255, 0, 50) // Returns: \"rgba(0, 255, 0, 0.5)\" - Semi-transparent green\n * color.rgb(300, 0, 0) // Returns: \"rgb(255, 0, 0)\" - Clamped to 255\n * ```\n */\nexport function rgb(red: simple_int, green: simple_int, blue: simple_int, transp?: simple_float): string {\n  const r = channel(red);\n  const g = channel(green);\n  const b = channel(blue);\n  const a = transp !== undefined ? alphaOf(transp) : 1;\n\n  if (a === 1) {\n    return `rgb(${r}, ${g}, ${b})`;\n  }\n  return `rgba(${r}, ${g}, ${b}, ${a})`;\n}\n\n/**\n * Creates a color from a hexadecimal string with optional transparency.\n *\n * @param hex - Hex color string (with or without '#' prefix, e.g., \"#FF0000\" or \"FF0000\")\n * @param transp - Optional transparency (0-100). 0 = opaque, 100 = fully transparent\n * @returns Color string in rgb() or rgba() format\n *\n * @remarks\n * - Accepts hex strings with or without '#' prefix\n * - Case-insensitive (accepts both \"FF0000\" and \"ff0000\")\n * - Must be 6 characters (excluding '#')\n * - Format: RRGGBB where each component is 00-FF\n *\n * @example\n * ```typescript\n * color.from_hex(\"#FF0000\") // Returns: \"rgb(255, 0, 0)\" - Red\n * color.from_hex(\"00FF00\", 50) // Returns: \"rgba(0, 255, 0, 0.5)\" - Semi-transparent green\n * color.from_hex(\"#0000FF\") // Returns: \"rgb(0, 0, 255)\" - Blue\n * color.from_hex(\"FFA500\") // Returns: \"rgb(255, 165, 0)\" - Orange\n * ```\n */\nexport function from_hex(hex: string, transp?: simple_float): string {\n  // Remove # if present\n  hex = hex.replace('#', '');\n\n  const r = parseInt(hex.substring(0, 2), 16);\n  const g = parseInt(hex.substring(2, 4), 16);\n  const b = parseInt(hex.substring(4, 6), 16);\n\n  return rgb(r, g, b, transp);\n}\n\n/**\n * Creates a new color with modified transparency, preserving RGB components.\n *\n * @param baseColor - The base color to modify\n * @param transp - New transparency value (0-100). 0 = opaque, 100 = fully transparent\n * @returns New color with updated transparency\n *\n * @remarks\n * - Preserves the RGB values from the base color\n * - Replaces the transparency with the new value\n * - Useful for creating semi-transparent versions of existing colors\n * - PineScript clamps the transparency to 0..100 (`color.new(c, 140)` is fully transparent, `color.new(c, -5)` is\n *   opaque); an `na` transparency is fully transparent\n *\n * @example\n * ```typescript\n * const red = color.rgb(255, 0, 0)\n * color.new_color(red, 50) // Returns: \"rgba(255, 0, 0, 0.5)\" - Semi-transparent red\n * color.new_color(red, 0) // Returns: \"rgb(255, 0, 0)\" - Fully opaque\n * color.new_color(red, 100) // Returns: \"rgba(255, 0, 0, 0)\" - Fully transparent\n * ```\n */\nexport function new_color(baseColor: color, transp: simple_float): string {\n  // Parse the color and apply transparency\n  const rgba = parseColor(baseColor);\n  return rgb(rgba.r, rgba.g, rgba.b, transp);\n}\n\n/**\n * Extracts the red component from a color.\n *\n * @param clr - The color to extract from\n * @returns Red component value (0-255)\n *\n * @example\n * ```typescript\n * color.r(color.rgb(255, 128, 64)) // Returns: 255\n * color.r(color.from_hex(\"#FF0000\")) // Returns: 255\n * color.r(color.from_hex(\"#FFA500\")) // Returns: 255 (orange)\n * ```\n */\nexport function r(clr: color): int {\n  return parseColor(clr).r;\n}\n\n/**\n * Extracts the green component from a color.\n *\n * @param clr - The color to extract from\n * @returns Green component value (0-255)\n *\n * @example\n * ```typescript\n * color.g(color.rgb(255, 128, 64)) // Returns: 128\n * color.g(color.from_hex(\"#00FF00\")) // Returns: 255\n * color.g(color.from_hex(\"#FFA500\")) // Returns: 165 (orange)\n * ```\n */\nexport function g(clr: color): int {\n  return parseColor(clr).g;\n}\n\n/**\n * Extracts the blue component from a color.\n *\n * @param clr - The color to extract from\n * @returns Blue component value (0-255)\n *\n * @example\n * ```typescript\n * color.b(color.rgb(255, 128, 64)) // Returns: 64\n * color.b(color.from_hex(\"#0000FF\")) // Returns: 255\n * color.b(color.from_hex(\"#FFA500\")) // Returns: 0 (orange)\n * ```\n */\nexport function b(clr: color): int {\n  return parseColor(clr).b;\n}\n\n/**\n * Extracts the transparency component from a color.\n *\n * @param clr - The color to extract from\n * @returns Transparency value (0-100). 0 = fully opaque, 100 = fully transparent\n *\n * @remarks\n * - Returns 0 for colors without transparency (rgb format)\n * - Converts alpha channel (0-1) to transparency (0-100)\n * - PineScript stores the alpha as a byte (0-255) and returns an integer transparency:\n *   `color.t(color.new(c, 33.3))` is 33\n *\n * @example\n * ```typescript\n * color.t(color.rgb(255, 0, 0)) // Returns: 0 (opaque)\n * color.t(color.rgb(255, 0, 0, 50)) // Returns: 50\n * color.t(color.rgb(255, 0, 0, 100)) // Returns: 100 (fully transparent)\n * ```\n */\nexport function t(clr: color): float {\n  return Math.round((1 - alphaByte(parseColor(clr).a) / 255) * 100);\n}\n\n// Predefined color constants of PineScript v6.\n// PineScript v5 differs for red (#FF5252), teal (#00897B) and yellow (#FFEB3B).\n/**\n * Aqua/Cyan color constant\n * @constant {string} #00BCD4 - RGB(0, 188, 212)\n */\nexport const aqua = '#00BCD4';\n\n/**\n * Black color constant\n * @constant {string} #363A45 - RGB(54, 58, 69)\n */\nexport const black = '#363A45';\n\n/**\n * Blue color constant\n * @constant {string} #2962FF - RGB(41, 98, 255)\n */\nexport const blue = '#2962FF';\n\n/**\n * Fuchsia/Magenta color constant\n * @constant {string} #E040FB - RGB(224, 64, 251)\n */\nexport const fuchsia = '#E040FB';\n\n/**\n * Gray color constant\n * @constant {string} #787B86 - RGB(120, 123, 134)\n */\nexport const gray = '#787B86';\n\n/**\n * Green color constant (same as lime)\n * @constant {string} #4CAF50 - RGB(76, 175, 80)\n */\nexport const green = '#4CAF50';\n\n/**\n * Lime color constant (same as green)\n * @constant {string} #00E676 - RGB(0, 230, 118)\n */\nexport const lime = '#00E676';\n\n/**\n * Maroon color constant\n * @constant {string} #880E4F - RGB(136, 14, 79)\n */\nexport const maroon = '#880E4F';\n\n/**\n * Navy color constant\n * @constant {string} #311B92 - RGB(49, 27, 146)\n */\nexport const navy = '#311B92';\n\n/**\n * Olive color constant\n * @constant {string} #808000 - RGB(128, 128, 0)\n */\nexport const olive = '#808000';\n\n/**\n * Orange color constant\n * @constant {string} #FF9800 - RGB(255, 152, 0)\n */\nexport const orange = '#FF9800';\n\n/**\n * Purple color constant\n * @constant {string} #9C27B0 - RGB(156, 39, 176)\n */\nexport const purple = '#9C27B0';\n\n/**\n * Red color constant\n * @constant {string} #F23645 - RGB(242, 54, 69)\n */\nexport const red = '#F23645';\n\n/**\n * Silver color constant\n * @constant {string} #B2B5BE - RGB(178, 181, 190)\n */\nexport const silver = '#B2B5BE';\n\n/**\n * Teal color constant\n * @constant {string} #089981 - RGB(8, 153, 129)\n */\nexport const teal = '#089981';\n\n/**\n * White color constant\n * @constant {string} #FFFFFF - RGB(255, 255, 255)\n */\nexport const white = '#FFFFFF';\n\n/**\n * Yellow color constant\n * @constant {string} #FDD835 - RGB(253, 216, 53)\n */\nexport const yellow = '#FDD835';\n\n/**\n * Creates a color from a gradient based on value position.\n *\n * @param value - Value to calculate position-dependent color\n * @param bottom_value - Bottom position value corresponding to bottom_color\n * @param top_value - Top position value corresponding to top_color\n * @param bottom_color - Bottom position color\n * @param top_color - Top position color\n * @returns Color calculated from linear gradient\n *\n * @remarks\n * PineScript rules:\n * - If value <= bottom_value, returns bottom_color; else if value >= top_value, returns top_color\n * - An inverted range (bottom_value > top_value) returns bottom_color, wherever the value is\n * - Otherwise the colours are mixed with their transparency (premultiplied alpha, alpha as a byte); the RGB channels\n *   and the alpha are truncated. PineScript's float rounding order is not known: a channel can differ by 1 when the\n *   exact result is an integer (same RGB at both ends)\n * - An na value or bottom_value / top_value, or bottom_value == top_value, gives a fully transparent colour\n * - An na colour counts as fully transparent\n * - Works with rgb(), rgba() and hex (#RRGGBB, #RRGGBBAA) colours\n *\n * @example\n * ```typescript\n * // Value at middle of range gets middle color\n * const midColor = color.from_gradient(50, 0, 100,\n *   color.rgb(255, 0, 0),    // Red at bottom\n *   color.rgb(0, 255, 0)      // Green at top\n * ); // Returns color between red and green\n *\n * // Value at extremes\n * const lowColor = color.from_gradient(-10, 0, 100, red, green); // Returns red\n * const highColor = color.from_gradient(150, 0, 100, red, green); // Returns green\n * ```\n */\nexport function from_gradient(\n  value: float,\n  bottom_value: float,\n  top_value: float,\n  bottom_color: color,\n  top_color: color\n): string {\n  const transparent = 'rgba(0, 0, 0, 0)';\n  if ([value, bottom_value, top_value].some((v) => v === null || v === undefined || Number.isNaN(v)) || bottom_value === top_value) {\n    return transparent;\n  }\n  const k =\n    value <= bottom_value || bottom_value > top_value\n      ? 0\n      : value >= top_value\n        ? 1\n        : (value - bottom_value) / (top_value - bottom_value);\n  // alpha as a byte (0-255), as PineScript stores it; an na colour (null / undefined) is fully transparent\n  const rgba = (c: color) => {\n    if (c === null || c === undefined) return { r: 0, g: 0, b: 0, a: 0 };\n    const p = parseColor(c);\n    return { r: p.r, g: p.g, b: p.b, a: alphaByte(p.a) };\n  };\n  const c1 = rgba(bottom_color);\n  const c2 = rgba(top_color);\n  const a = c1.a * (1 - k) + c2.a * k;\n  if (a === 0) return transparent;\n  // operation order with the fewest differences to PineScript (channels as 0-1, alpha as a byte)\n  const mix = (x1: number, x2: number) => Math.floor((((x1 / 255) * c1.a) * (1 - k) + ((x2 / 255) * c2.a) * k) / (a / 255));\n  const [r, g, b] = [mix(c1.r, c2.r), mix(c1.g, c2.g), mix(c1.b, c2.b)];\n  const alpha = Math.floor(a);\n  return alpha === 255 ? `rgb(${r}, ${g}, ${b})` : `rgba(${r}, ${g}, ${b}, ${alpha / 255})`;\n}\n\n/**\n * Alias for new_color function.\n * Creates a new color with specified transparency from an existing color.\n *\n * @param baseColor - The base color\n * @param transp - Transparency value (0-100). 0 = fully opaque, 100 = fully transparent\n * @returns New color with applied transparency\n *\n * @remarks\n * This is an alias for `new_color()` to match PineScript's `color.new()` syntax.\n *\n * @example\n * ```typescript\n * const redColor = color.rgb(255, 0, 0);\n * const transparentRed = color.new(redColor, 50); // 50% transparent red\n * ```\n */\nexport { new_color as new };\n"],
+  "mappings": "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",
+  "names": ["red", "green", "blue", "r", "g", "b"]
+}

package/dist/cjs/color/parse.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Colour parsing shared by the color namespace and input.color (internal, not part of the public API).
+ */
+import type { color, int, float } from '../types/index.js';
+/**
+ * Parses a colour string to its channels (0-255) and alpha (0-1).
+ * Hex: #RRGGBB, #RRGGBBAA (PineScript literals), #RGB, #RGBA; rgb() / rgba(). Anything else is opaque black.
+ */
+export declare function parseColor(clr: color): {
+    r: int;
+    g: int;
+    b: int;
+    a: float;
+};
+/** Alpha byte (0-255) of an alpha (0-1), as PineScript stores it. */
+export declare const alphaByte: (a: float) => int;
+/**
+ * The colour a script receives for the default of `input.color(defval)`.
+ *
+ * PineScript rules (measured):
+ * - the default is stored with an alpha of 2 decimals: a `color.new(c, t)` / `color.rgb(r, g, b, t)` default keeps
+ *   `(100 - trunc(t)) / 100` (90 gives 0.1, 9.9 gives 0.91), a hex literal `#RRGGBBAA` keeps `round(AA / 255, 2)`
+ * - the input value is then the alpha byte `round(255 * alpha)`: `color.new(c, 90)` as an input default has the
+ *   byte 26, where `color.new(c, 90)` in the script has 25
+ *
+ * A default whose alpha byte does not change is returned unchanged.
+ */
+export declare function inputColorDefault(defval: color): color;
+//# sourceMappingURL=parse.d.ts.map

package/dist/cjs/color/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../src/color/parse.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAE3D;;;GAGG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,KAAK,GAAG;IAAE,CAAC,EAAE,GAAG,CAAC;IAAC,CAAC,EAAE,GAAG,CAAC;IAAC,CAAC,EAAE,GAAG,CAAC;IAAC,CAAC,EAAE,KAAK,CAAA;CAAE,CAoB3E;AAED,qEAAqE;AACrE,eAAO,MAAM,SAAS,GAAI,GAAG,KAAK,KAAG,GAA0B,CAAC;AAEhE;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,KAAK,GAAG,KAAK,CAStD"}

package/dist/cjs/color/parse.js

@@ -0,0 +1,57 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var parse_exports = {};
+__export(parse_exports, {
+  alphaByte: () => alphaByte,
+  inputColorDefault: () => inputColorDefault,
+  parseColor: () => parseColor
+});
+module.exports = __toCommonJS(parse_exports);
+function parseColor(clr) {
+  if (typeof clr === "string") {
+    const hex = /^#([0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i.exec(clr.trim());
+    if (hex) {
+      let digits = hex[1];
+      if (digits.length <= 4) digits = [...digits].map((c) => c + c).join("");
+      const byte = (k) => parseInt(digits.slice(k, k + 2), 16);
+      return { r: byte(0), g: byte(2), b: byte(4), a: digits.length === 8 ? byte(6) / 255 : 1 };
+    }
+    const match = clr.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)(?:,\s*([\d.]+))?\)/);
+    if (match) {
+      return {
+        r: parseInt(match[1]),
+        g: parseInt(match[2]),
+        b: parseInt(match[3]),
+        a: match[4] ? parseFloat(match[4]) : 1
+      };
+    }
+  }
+  return { r: 0, g: 0, b: 0, a: 1 };
+}
+const alphaByte = (a) => Math.round(a * 255);
+function inputColorDefault(defval) {
+  if (typeof defval !== "string") return defval;
+  const p = parseColor(defval);
+  const hex = defval.trim().startsWith("#");
+  const stored = hex ? Math.round(p.a * 100) / 100 : Math.ceil(Math.round(p.a * 100 * 1e6) / 1e6) / 100;
+  const byte = alphaByte(stored);
+  if (byte === alphaByte(p.a)) return defval;
+  return byte === 255 ? `rgb(${p.r}, ${p.g}, ${p.b})` : `rgba(${p.r}, ${p.g}, ${p.b}, ${byte / 255})`;
+}
+//# sourceMappingURL=parse.js.map

package/dist/cjs/color/parse.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/color/parse.ts"],
+  "sourcesContent": ["/**\n * Colour parsing shared by the color namespace and input.color (internal, not part of the public API).\n */\n\nimport type { color, int, float } from '../types/index.js';\n\n/**\n * Parses a colour string to its channels (0-255) and alpha (0-1).\n * Hex: #RRGGBB, #RRGGBBAA (PineScript literals), #RGB, #RGBA; rgb() / rgba(). Anything else is opaque black.\n */\nexport function parseColor(clr: color): { r: int; g: int; b: int; a: float } {\n  if (typeof clr === 'string') {\n    const hex = /^#([0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i.exec(clr.trim());\n    if (hex) {\n      let digits = hex[1]!;\n      if (digits.length <= 4) digits = [...digits].map((c) => c + c).join('');\n      const byte = (k: number) => parseInt(digits.slice(k, k + 2), 16);\n      return { r: byte(0), g: byte(2), b: byte(4), a: digits.length === 8 ? byte(6) / 255 : 1 };\n    }\n    const match = clr.match(/rgba?\\((\\d+),\\s*(\\d+),\\s*(\\d+)(?:,\\s*([\\d.]+))?\\)/);\n    if (match) {\n      return {\n        r: parseInt(match[1]!),\n        g: parseInt(match[2]!),\n        b: parseInt(match[3]!),\n        a: match[4] ? parseFloat(match[4]) : 1,\n      };\n    }\n  }\n  return { r: 0, g: 0, b: 0, a: 1 };\n}\n\n/** Alpha byte (0-255) of an alpha (0-1), as PineScript stores it. */\nexport const alphaByte = (a: float): int => Math.round(a * 255);\n\n/**\n * The colour a script receives for the default of `input.color(defval)`.\n *\n * PineScript rules (measured):\n * - the default is stored with an alpha of 2 decimals: a `color.new(c, t)` / `color.rgb(r, g, b, t)` default keeps\n *   `(100 - trunc(t)) / 100` (90 gives 0.1, 9.9 gives 0.91), a hex literal `#RRGGBBAA` keeps `round(AA / 255, 2)`\n * - the input value is then the alpha byte `round(255 * alpha)`: `color.new(c, 90)` as an input default has the\n *   byte 26, where `color.new(c, 90)` in the script has 25\n *\n * A default whose alpha byte does not change is returned unchanged.\n */\nexport function inputColorDefault(defval: color): color {\n  if (typeof defval !== 'string') return defval;\n  const p = parseColor(defval);\n  const hex = defval.trim().startsWith('#');\n  // rgba() from color.new / color.rgb: alpha = 1 - t / 100, so alpha * 100 = 100 - t (float noise removed first)\n  const stored = hex ? Math.round(p.a * 100) / 100 : Math.ceil(Math.round(p.a * 100 * 1e6) / 1e6) / 100;\n  const byte = alphaByte(stored);\n  if (byte === alphaByte(p.a)) return defval;\n  return byte === 255 ? `rgb(${p.r}, ${p.g}, ${p.b})` : `rgba(${p.r}, ${p.g}, ${p.b}, ${byte / 255})`;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAUO,SAAS,WAAW,KAAkD;AAC3E,MAAI,OAAO,QAAQ,UAAU;AAC3B,UAAM,MAAM,8CAA8C,KAAK,IAAI,KAAK,CAAC;AACzE,QAAI,KAAK;AACP,UAAI,SAAS,IAAI,CAAC;AAClB,UAAI,OAAO,UAAU,EAAG,UAAS,CAAC,GAAG,MAAM,EAAE,IAAI,CAAC,MAAM,IAAI,CAAC,EAAE,KAAK,EAAE;AACtE,YAAM,OAAO,CAAC,MAAc,SAAS,OAAO,MAAM,GAAG,IAAI,CAAC,GAAG,EAAE;AAC/D,aAAO,EAAE,GAAG,KAAK,CAAC,GAAG,GAAG,KAAK,CAAC,GAAG,GAAG,KAAK,CAAC,GAAG,GAAG,OAAO,WAAW,IAAI,KAAK,CAAC,IAAI,MAAM,EAAE;AAAA,IAC1F;AACA,UAAM,QAAQ,IAAI,MAAM,mDAAmD;AAC3E,QAAI,OAAO;AACT,aAAO;AAAA,QACL,GAAG,SAAS,MAAM,CAAC,CAAE;AAAA,QACrB,GAAG,SAAS,MAAM,CAAC,CAAE;AAAA,QACrB,GAAG,SAAS,MAAM,CAAC,CAAE;AAAA,QACrB,GAAG,MAAM,CAAC,IAAI,WAAW,MAAM,CAAC,CAAC,IAAI;AAAA,MACvC;AAAA,IACF;AAAA,EACF;AACA,SAAO,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,EAAE;AAClC;AAGO,MAAM,YAAY,CAAC,MAAkB,KAAK,MAAM,IAAI,GAAG;AAavD,SAAS,kBAAkB,QAAsB;AACtD,MAAI,OAAO,WAAW,SAAU,QAAO;AACvC,QAAM,IAAI,WAAW,MAAM;AAC3B,QAAM,MAAM,OAAO,KAAK,EAAE,WAAW,GAAG;AAExC,QAAM,SAAS,MAAM,KAAK,MAAM,EAAE,IAAI,GAAG,IAAI,MAAM,KAAK,KAAK,KAAK,MAAM,EAAE,IAAI,MAAM,GAAG,IAAI,GAAG,IAAI;AAClG,QAAM,OAAO,UAAU,MAAM;AAC7B,MAAI,SAAS,UAAU,EAAE,CAAC,EAAG,QAAO;AACpC,SAAO,SAAS,MAAM,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,MAAM,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG;AAClG;",
+  "names": []
+}

package/dist/cjs/compare/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * PineScript comparison operators (`==`, `!=`, `<`, `<=`, `>`, `>=`) on numbers.
+ *
+ * PineScript rules:
+ * - the operators use an absolute tolerance of 1e-10: `a == b` when `|a - b| <= 1e-10`, `a < b` when
+ *   `b - a > 1e-10` (the same for every magnitude; `0.1 + 0.2 == 0.3` is true)
+ * - every comparison with an `na` operand is false, `!=` included
+ * - built-in functions (`ta.crossover`, `ta.pivothigh`, `ta.highestbars`...) compare exactly
+ *
+ * The `Series` comparison methods (`gt`, `gte`, `lt`, `lte`, `eq`, `neq`) follow the same rules.
+ */
+/** Tolerance of PineScript's comparison operators. */
+export declare const EPSILON = 1e-10;
+/** PineScript `a == b`. */
+export declare function eq(a: number, b: number): boolean;
+/** PineScript `a != b` (false when an operand is `na`). */
+export declare function ne(a: number, b: number): boolean;
+/** PineScript `a < b`. */
+export declare function lt(a: number, b: number): boolean;
+/** PineScript `a <= b`. */
+export declare function le(a: number, b: number): boolean;
+/** PineScript `a > b`. */
+export declare function gt(a: number, b: number): boolean;
+/** PineScript `a >= b`. */
+export declare function ge(a: number, b: number): boolean;
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/compare/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/compare/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,sDAAsD;AACtD,eAAO,MAAM,OAAO,QAAQ,CAAC;AAI7B,2BAA2B;AAC3B,wBAAgB,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAEhD;AAED,2DAA2D;AAC3D,wBAAgB,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAEhD;AAED,0BAA0B;AAC1B,wBAAgB,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAEhD;AAED,2BAA2B;AAC3B,wBAAgB,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAEhD;AAED,0BAA0B;AAC1B,wBAAgB,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAEhD;AAED,2BAA2B;AAC3B,wBAAgB,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAEhD"}

package/dist/cjs/compare/index.js

@@ -0,0 +1,50 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var compare_exports = {};
+__export(compare_exports, {
+  EPSILON: () => EPSILON,
+  eq: () => eq,
+  ge: () => ge,
+  gt: () => gt,
+  le: () => le,
+  lt: () => lt,
+  ne: () => ne
+});
+module.exports = __toCommonJS(compare_exports);
+const EPSILON = 1e-10;
+const valid = (a, b) => !Number.isNaN(a) && !Number.isNaN(b);
+function eq(a, b) {
+  return valid(a, b) && Math.abs(a - b) <= EPSILON;
+}
+function ne(a, b) {
+  return valid(a, b) && Math.abs(a - b) > EPSILON;
+}
+function lt(a, b) {
+  return valid(a, b) && b - a > EPSILON;
+}
+function le(a, b) {
+  return valid(a, b) && a - b <= EPSILON;
+}
+function gt(a, b) {
+  return valid(a, b) && a - b > EPSILON;
+}
+function ge(a, b) {
+  return valid(a, b) && b - a <= EPSILON;
+}
+//# sourceMappingURL=index.js.map

package/dist/cjs/compare/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/compare/index.ts"],
+  "sourcesContent": ["/**\n * PineScript comparison operators (`==`, `!=`, `<`, `<=`, `>`, `>=`) on numbers.\n *\n * PineScript rules:\n * - the operators use an absolute tolerance of 1e-10: `a == b` when `|a - b| <= 1e-10`, `a < b` when\n *   `b - a > 1e-10` (the same for every magnitude; `0.1 + 0.2 == 0.3` is true)\n * - every comparison with an `na` operand is false, `!=` included\n * - built-in functions (`ta.crossover`, `ta.pivothigh`, `ta.highestbars`...) compare exactly\n *\n * The `Series` comparison methods (`gt`, `gte`, `lt`, `lte`, `eq`, `neq`) follow the same rules.\n */\n\n/** Tolerance of PineScript's comparison operators. */\nexport const EPSILON = 1e-10;\n\nconst valid = (a: number, b: number): boolean => !Number.isNaN(a) && !Number.isNaN(b);\n\n/** PineScript `a == b`. */\nexport function eq(a: number, b: number): boolean {\n  return valid(a, b) && Math.abs(a - b) <= EPSILON;\n}\n\n/** PineScript `a != b` (false when an operand is `na`). */\nexport function ne(a: number, b: number): boolean {\n  return valid(a, b) && Math.abs(a - b) > EPSILON;\n}\n\n/** PineScript `a < b`. */\nexport function lt(a: number, b: number): boolean {\n  return valid(a, b) && b - a > EPSILON;\n}\n\n/** PineScript `a <= b`. */\nexport function le(a: number, b: number): boolean {\n  return valid(a, b) && a - b <= EPSILON;\n}\n\n/** PineScript `a > b`. */\nexport function gt(a: number, b: number): boolean {\n  return valid(a, b) && a - b > EPSILON;\n}\n\n/** PineScript `a >= b`. */\nexport function ge(a: number, b: number): boolean {\n  return valid(a, b) && b - a <= EPSILON;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAaO,MAAM,UAAU;AAEvB,MAAM,QAAQ,CAAC,GAAW,MAAuB,CAAC,OAAO,MAAM,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC;AAG7E,SAAS,GAAG,GAAW,GAAoB;AAChD,SAAO,MAAM,GAAG,CAAC,KAAK,KAAK,IAAI,IAAI,CAAC,KAAK;AAC3C;AAGO,SAAS,GAAG,GAAW,GAAoB;AAChD,SAAO,MAAM,GAAG,CAAC,KAAK,KAAK,IAAI,IAAI,CAAC,IAAI;AAC1C;AAGO,SAAS,GAAG,GAAW,GAAoB;AAChD,SAAO,MAAM,GAAG,CAAC,KAAK,IAAI,IAAI;AAChC;AAGO,SAAS,GAAG,GAAW,GAAoB;AAChD,SAAO,MAAM,GAAG,CAAC,KAAK,IAAI,KAAK;AACjC;AAGO,SAAS,GAAG,GAAW,GAAoB;AAChD,SAAO,MAAM,GAAG,CAAC,KAAK,IAAI,IAAI;AAChC;AAGO,SAAS,GAAG,GAAW,GAAoB;AAChD,SAAO,MAAM,GAAG,CAAC,KAAK,IAAI,KAAK;AACjC;",
+  "names": []
+}