oakscriptjs 0.9.5 → 0.10.0

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/array/index.ts"],
-  "sourcesContent": ["/**\n * Array namespace\n * Mirrors PineScript's array.* functions\n */\n\nimport type { PineArray, int, float, bool, simple_int, color, Line, Box, Label, Linefill } from '../types/index.js';\n\n/**\n * Creates a new array with initial size and default value\n */\nexport function new_array<T>(size: simple_int = 0, initial_value?: T): PineArray<T> {\n  const arr: PineArray<T> = [];\n  for (let i = 0; i < size; i++) {\n    arr.push(initial_value as T);\n  }\n  return arr;\n}\n\n/**\n * Returns the number of elements in an array\n */\nexport function size<T>(id: PineArray<T>): int {\n  return id.length;\n}\n\n/**\n * Returns the element at the specified index\n */\nexport function get<T>(id: PineArray<T>, index: simple_int): T {\n  return id[index]!;\n}\n\n/**\n * Sets the value of the element at the specified index\n */\nexport function set<T>(id: PineArray<T>, index: simple_int, value: T): void {\n  id[index] = value;\n}\n\n/**\n * Appends a value to the end of the array\n */\nexport function push<T>(id: PineArray<T>, value: T): void {\n  id.push(value);\n}\n\n/**\n * Removes and returns the last element of the array\n */\nexport function pop<T>(id: PineArray<T>): T {\n  return id.pop() as T;\n}\n\n/**\n * Inserts a value at the beginning of the array\n */\nexport function unshift<T>(id: PineArray<T>, value: T): void {\n  id.unshift(value);\n}\n\n/**\n * Removes and returns the first element of the array\n */\nexport function shift<T>(id: PineArray<T>): T {\n  return id.shift() as T;\n}\n\n/**\n * Removes all elements from the array\n */\nexport function clear<T>(id: PineArray<T>): void {\n  id.length = 0;\n}\n\n/**\n * Inserts a value at the specified index\n */\nexport function insert<T>(id: PineArray<T>, index: simple_int, value: T): void {\n  id.splice(index, 0, value);\n}\n\n/**\n * Removes the element at the specified index\n */\nexport function remove<T>(id: PineArray<T>, index: simple_int): T {\n  return id.splice(index, 1)[0]!;\n}\n\n/**\n * Returns true if the array contains the value\n */\nexport function includes<T>(id: PineArray<T>, value: T): bool {\n  return id.includes(value);\n}\n\n/**\n * Returns the index of the first occurrence of the value\n */\nexport function indexof<T>(id: PineArray<T>, value: T): int {\n  return id.indexOf(value);\n}\n\n/**\n * Returns the index of the last occurrence of the value\n */\nexport function lastindexof<T>(id: PineArray<T>, value: T): int {\n  return id.lastIndexOf(value);\n}\n\n/**\n * Returns a shallow copy of the array\n */\nexport function copy<T>(id: PineArray<T>): PineArray<T> {\n  return [...id] as PineArray<T>;\n}\n\n/**\n * Concatenates two arrays\n */\nexport function concat<T>(id1: PineArray<T>, id2: PineArray<T>): PineArray<T> {\n  return [...id1, ...id2] as PineArray<T>;\n}\n\n/**\n * Joins all elements into a string\n */\nexport function join(id: PineArray<any>, separator: string = ','): string {\n  return id.join(separator);\n}\n\n/**\n * Reverses the array in place\n */\nexport function reverse<T>(id: PineArray<T>): void {\n  id.reverse();\n}\n\n/**\n * Returns a slice of the array\n */\nexport function slice<T>(id: PineArray<T>, index_from: simple_int, index_to?: simple_int): PineArray<T> {\n  return id.slice(index_from, index_to) as PineArray<T>;\n}\n\n/**\n * Sorts array elements (numeric)\n */\nexport function sort<T>(id: PineArray<T>, order: 'asc' | 'desc' = 'asc'): void {\n  id.sort((a, b) => {\n    if (order === 'asc') {\n      return (a as any) - (b as any);\n    } else {\n      return (b as any) - (a as any);\n    }\n  });\n}\n\n/**\n * Returns the sum of all elements (numeric arrays only)\n */\nexport function sum(id: PineArray<float>): float {\n  return id.reduce((acc, val) => acc + val, 0);\n}\n\n/**\n * Average of the non-na elements (PineScript `array.avg(id)`); an array without values gives NaN.\n */\nexport function avg(id: PineArray<float>): float {\n  const values = id.filter((v) => !Number.isNaN(v));\n  return values.length ? values.reduce((a, b) => a + b, 0) / values.length : NaN;\n}\n\n/**\n * The `nth` smallest value (0 = the smallest) of the non-na elements (PineScript `array.min(id, nth)`).\n * An `nth` past the end gives the greatest value; an array without values gives NaN.\n */\nexport function min(id: PineArray<float>, nth: simple_int = 0): float {\n  const values = id.filter((v) => !Number.isNaN(v)).sort((a, b) => a - b);\n  return values.length ? values[Math.min(nth, values.length - 1)]! : NaN;\n}\n\n/**\n * The `nth` greatest value (0 = the greatest) of the non-na elements (PineScript `array.max(id, nth)`).\n * An `nth` past the end gives the smallest value; an array without values gives NaN.\n */\nexport function max(id: PineArray<float>, nth: simple_int = 0): float {\n  const values = id.filter((v) => !Number.isNaN(v)).sort((a, b) => b - a);\n  return values.length ? values[Math.min(nth, values.length - 1)]! : NaN;\n}\n\n/**\n * Returns the median value (numeric arrays only)\n */\nexport function median(id: PineArray<float>): float {\n  const sorted = [...id].sort((a, b) => a - b);\n  const mid = Math.floor(sorted.length / 2);\n  return sorted.length % 2 === 0 ? (sorted[mid - 1]! + sorted[mid]!) / 2 : sorted[mid]!;\n}\n\n/**\n * Returns the mode (most frequent value)\n */\nexport function mode(id: PineArray<float>): float {\n  const frequency: Map<float, int> = new Map();\n  let maxFreq = 0;\n  let mode = id[0]!;\n\n  for (const val of id) {\n    const freq = (frequency.get(val) || 0) + 1;\n    frequency.set(val, freq);\n    if (freq > maxFreq) {\n      maxFreq = freq;\n      mode = val;\n    }\n  }\n\n  return mode;\n}\n\n/**\n * Standard deviation of the non-na elements (PineScript `array.stdev(id, biased)`).\n * `biased` true (default) divides by the count, false by the count - 1.\n */\nexport function stdev(id: PineArray<float>, biased: bool = true): float {\n  return Math.sqrt(variance(id, biased));\n}\n\n/**\n * Variance of the non-na elements (PineScript `array.variance(id, biased)`).\n * `biased` true (default) divides by the count, false by the count - 1.\n */\nexport function variance(id: PineArray<float>, biased: bool = true): float {\n  const values = id.filter((v) => !Number.isNaN(v));\n  if (!values.length) return NaN;\n  const mean = values.reduce((a, b) => a + b, 0) / values.length;\n  const squares = values.reduce((a, b) => a + (b - mean) * (b - mean), 0);\n  return squares / (biased ? values.length : values.length - 1);\n}\n\n/**\n * Fills the array with the specified value\n */\nexport function fill<T>(id: PineArray<T>, value: T, index_from: simple_int = 0, index_to?: simple_int): void {\n  const end = index_to ?? id.length;\n  for (let i = index_from; i < end; i++) {\n    id[i] = value;\n  }\n}\n\n/**\n * Creates an array from its arguments (PineScript `array.from(arg0, arg1, ...)`).\n * `na` values are kept.\n *\n * @example\n * ```typescript\n * array.from(0.236, 0.382, 0.5, 0.618); // [0.236, 0.382, 0.5, 0.618]\n * ```\n */\nexport function from<T>(...values: T[]): PineArray<T> {\n  return [...values];\n}\n\n/**\n * Returns the first element of the array\n *\n * @param id - The array\n * @returns The first element, or undefined if array is empty\n *\n * @remarks\n * - Equivalent to `array.get(id, 0)`\n * - Returns undefined for empty arrays\n *\n * @example\n * ```typescript\n * const arr = [1, 2, 3, 4, 5];\n * const firstElement = array.first(arr); // Returns: 1\n * ```\n */\nexport function first<T>(id: PineArray<T>): T {\n  return id[0]!;\n}\n\n/**\n * Returns the last element of the array\n *\n * @param id - The array\n * @returns The last element, or undefined if array is empty\n *\n * @remarks\n * - Equivalent to `array.get(id, array.size(id) - 1)`\n * - Returns undefined for empty arrays\n *\n * @example\n * ```typescript\n * const arr = [1, 2, 3, 4, 5];\n * const lastElement = array.last(arr); // Returns: 5\n * ```\n */\nexport function last<T>(id: PineArray<T>): T {\n  return id[id.length - 1]!;\n}\n\n/**\n * True when at least one element of a bool array is true (PineScript `array.some(id)`).\n * An empty array gives false.\n */\nexport function some(id: PineArray<bool>): bool {\n  return id.some((v) => v === true);\n}\n\n/**\n * True when every element of a bool array is true (PineScript `array.every(id)`).\n * An empty array gives false, as in PineScript.\n */\nexport function every(id: PineArray<bool>): bool {\n  return id.length > 0 && id.every((v) => v === true);\n}\n\n/**\n * Create new boolean array\n *\n * Creates a new array object of bool type elements.\n *\n * @param size - Initial size of array (default: 0)\n * @param initial_value - Initial value for all elements (default: false)\n * @returns New boolean array\n *\n * @example\n * ```typescript\n * const arr = array.new_bool(5, true);\n * // Creates: [true, true, true, true, true]\n * ```\n */\nexport function new_bool(size: simple_int = 0, initial_value: bool = false): PineArray<bool> {\n  return new_array<bool>(size, initial_value);\n}\n\n/**\n * Create new float array\n *\n * Creates a new array object of float type elements.\n *\n * @param size - Initial size of array (default: 0)\n * @param initial_value - Initial value for all elements (default: NaN)\n * @returns New float array\n *\n * @example\n * ```typescript\n * const arr = array.new_float(5, 0.0);\n * // Creates: [0.0, 0.0, 0.0, 0.0, 0.0]\n * ```\n */\nexport function new_float(size: simple_int = 0, initial_value: float = NaN): PineArray<float> {\n  return new_array<float>(size, initial_value);\n}\n\n/**\n * Create new integer array\n *\n * Creates a new array object of int type elements.\n *\n * @param size - Initial size of array (default: 0)\n * @param initial_value - Initial value for all elements (default: NaN)\n * @returns New integer array\n *\n * @example\n * ```typescript\n * const arr = array.new_int(5, 0);\n * // Creates: [0, 0, 0, 0, 0]\n * ```\n */\nexport function new_int(size: simple_int = 0, initial_value: int = NaN): PineArray<int> {\n  return new_array<int>(size, initial_value);\n}\n\n/**\n * Create new string array\n *\n * Creates a new array object of string type elements.\n *\n * @param size - Initial size of array (default: 0)\n * @param initial_value - Initial value for all elements (default: undefined)\n * @returns New string array\n *\n * @example\n * ```typescript\n * const arr = array.new_string(5, \"text\");\n * // Creates: [\"text\", \"text\", \"text\", \"text\", \"text\"]\n * ```\n */\nexport function new_string(size: simple_int = 0, initial_value?: string): PineArray<string> {\n  return new_array<string>(size, initial_value);\n}\n\n/**\n * Create new color array\n *\n * Creates a new array object of color type elements.\n *\n * @param size - Initial size of array (default: 0)\n * @param initial_value - Initial value for all elements (default: undefined)\n * @returns New color array\n *\n * @example\n * ```typescript\n * const arr = array.new_color(5, \"#FF0000\");\n * // Creates: [\"#FF0000\", \"#FF0000\", \"#FF0000\", \"#FF0000\", \"#FF0000\"]\n * ```\n */\nexport function new_color(size: simple_int = 0, initial_value?: color): PineArray<color> {\n  return new_array<color>(size, initial_value);\n}\n\n/**\n * Create new line array\n *\n * Creates a new array object of line type elements.\n *\n * @param size - Initial size of array (default: 0)\n * @param initial_value - Initial value for all elements (default: undefined)\n * @returns New line array\n *\n * @example\n * ```typescript\n * import { array, line } from 'oakscriptjs';\n *\n * // Create array to store last 15 lines\n * const lines = array.new_line();\n * const trendLine = line.new(0, 100, 50, 150);\n * array.push(lines, trendLine);\n *\n * // Manage line count\n * if (array.size(lines) > 15) {\n *   const oldLine = array.shift(lines);\n * }\n * ```\n *\n * @remarks\n * Useful for managing collections of trend lines, support/resistance levels, or channel lines.\n * In PineScript, this is typically used with line.delete() to manage chart object limits.\n */\nexport function new_line(size: simple_int = 0, initial_value?: Line): PineArray<Line> {\n  return new_array<Line>(size, initial_value);\n}\n\n/**\n * Create new box array\n *\n * Creates a new array object of box type elements.\n *\n * @param size - Initial size of array (default: 0)\n * @param initial_value - Initial value for all elements (default: undefined)\n * @returns New box array\n *\n * @example\n * ```typescript\n * import { array, box } from 'oakscriptjs';\n *\n * // Create array to store gap boxes\n * const gaps = array.new_box();\n * const gapBox = box.new(10, 120, 15, 110);\n * array.push(gaps, gapBox);\n *\n * // Track multiple gaps\n * for (let i = 0; i < array.size(gaps); i++) {\n *   const gap = array.get(gaps, i);\n *   const gapTop = box.get_top(gap);\n *   const gapBottom = box.get_bottom(gap);\n *   // Check if gap filled...\n * }\n * ```\n *\n * @remarks\n * Useful for tracking ranges, gaps, consolidation zones, or rectangle patterns.\n * Enables systematic analysis of multiple box objects.\n */\nexport function new_box(size: simple_int = 0, initial_value?: Box): PineArray<Box> {\n  return new_array<Box>(size, initial_value);\n}\n\n/**\n * Create new label array\n *\n * Creates a new array object of label type elements.\n *\n * @param size - Initial size of array (default: 0)\n * @param initial_value - Initial value for all elements (default: undefined)\n * @returns New label array\n *\n * @example\n * ```typescript\n * import { array, label } from 'oakscriptjs';\n *\n * // Create array to store pivot labels\n * const pivotLabels = array.new_label();\n *\n * // Add labels for pivot highs\n * const pivotLabel = label.new(50, 155.5, 'PH', 'bar_index', 'abovebar');\n * array.push(pivotLabels, pivotLabel);\n *\n * // Limit number of labels shown\n * const maxLabels = 50;\n * if (array.size(pivotLabels) > maxLabels) {\n *   array.shift(pivotLabels);\n * }\n * ```\n *\n * @remarks\n * Useful for managing collections of annotations, pivot markers, or signal labels.\n * Helps limit the number of labels displayed by removing old ones.\n */\nexport function new_label(size: simple_int = 0, initial_value?: Label): PineArray<Label> {\n  return new_array<Label>(size, initial_value);\n}\n\n/**\n * Create new linefill array\n *\n * Creates a new array object of linefill type elements.\n *\n * @param size - Initial size of array (default: 0)\n * @param initial_value - Initial value for all elements (default: undefined)\n * @returns New linefill array\n *\n * @example\n * ```typescript\n * import { array, line, linefill } from 'oakscriptjs';\n *\n * // Create array to store channel fills\n * const channels = array.new_linefill();\n *\n * // Create channel\n * const upperLine = line.new(0, 120, 50, 130);\n * const lowerLine = line.new(0, 100, 50, 110);\n * const channelFill = linefill.new(upperLine, lowerLine, '#0000FF15');\n *\n * array.push(channels, channelFill);\n * ```\n *\n * @remarks\n * Useful for managing collections of channel fills, Bollinger Band fills, or regression channel fills.\n * Enables dynamic color changes across multiple channels.\n */\nexport function new_linefill(size: simple_int = 0, initial_value?: Linefill): PineArray<Linefill> {\n  return new_array<Linefill>(size, initial_value);\n}\n\n/**\n * Absolute value of array elements\n *\n * Returns an array containing the absolute value of each element in the original array.\n *\n * @param id - Array of numeric values\n * @returns New array with absolute values\n *\n * @example\n * ```typescript\n * const arr = [-1, -2, 3, -4, 5];\n * const result = array.abs(arr);\n * // Returns: [1, 2, 3, 4, 5]\n * ```\n */\nexport function abs(id: PineArray<float>): PineArray<float> {\n  return id.map(x => Math.abs(x)) as PineArray<float>;\n}\n\n/**\n * Range of array values\n *\n * Returns the difference between the maximum and minimum values in the array.\n *\n * @param id - Array of numeric values\n * @returns Difference between max and min (range)\n *\n * @example\n * ```typescript\n * const arr = [1, 5, 3, 9, 2];\n * const result = array.range(arr);\n * // Returns: 8 (9 - 1)\n * ```\n *\n * @remarks\n * Returns NaN if the array is empty.\n */\nexport function range(id: PineArray<float>): float {\n  if (id.length === 0) {\n    return NaN;\n  }\n  return max(id) - min(id);\n}\n\n/**\n * Binary Search\n *\n * Searches for a value in a sorted array using binary search algorithm.\n * Returns the index of the value if found, or -1 if not found.\n *\n * @param id - Sorted array (ascending order)\n * @param val - Value to search for\n * @returns Index of the value, or -1 if not found\n *\n * @example\n * ```typescript\n * const arr = [-2, 0, 1, 5, 9]; // Must be sorted\n * const index = array.binary_search(arr, 5);\n * // Returns: 3\n * ```\n *\n * @remarks\n * - Array must be sorted in ascending order\n * - Uses standard binary search algorithm\n * - Time complexity: O(log n)\n */\nexport function binary_search(id: PineArray<float>, val: float): int {\n  let left = 0;\n  let right = id.length - 1;\n\n  while (left <= right) {\n    const mid = Math.floor((left + right) / 2);\n\n    if (id[mid]! === val) {\n      return mid;\n    }\n\n    if (id[mid]! < val) {\n      left = mid + 1;\n    } else {\n      right = mid - 1;\n    }\n  }\n\n  return -1; // Not found\n}\n\n/**\n * Binary Search Leftmost\n *\n * Returns the index of the value if found. When not found, returns the index\n * of the next smallest element to the left of where the value would be.\n *\n * @param id - Sorted array (ascending order)\n * @param val - Value to search for\n * @returns Index of value or insertion point to the left\n *\n * @example\n * ```typescript\n * const arr = [-2, 0, 1, 5, 9];\n * const index = array.binary_search_leftmost(arr, 3);\n * // Returns: 2 (index of 1, which is left of where 3 would be)\n * ```\n *\n * @example\n * ```typescript\n * const arr = [4, 5, 5, 5];\n * const index = array.binary_search_leftmost(arr, 5);\n * // Returns: 1 (index of first instance of 5)\n * ```\n *\n * @remarks\n * - Array must be sorted in ascending order\n * - For duplicate values, returns leftmost occurrence\n * - When value not found, returns position of next smaller element\n * - PineScript rules: a value below every element gives 0; `na` counts as greater than every number (an array\n *   without na gives `size - 1`); the comparison is exact (no 1e-10 tolerance)\n */\nexport function binary_search_leftmost(id: PineArray<float>, val: float): int {\n  if (id.length === 0) return -1;\n  const at = searchBound(id, val, false);\n  return at < id.length && compareSorted(id[at]!, val) === 0 ? at : Math.max(0, at - 1);\n}\n\n/**\n * Order of the PineScript binary searches: numbers in ascending order, na above every number (equal to na).\n */\nfunction compareSorted(a: float, b: float): number {\n  const an = Number.isNaN(a);\n  const bn = Number.isNaN(b);\n  if (an || bn) return an === bn ? 0 : an ? 1 : -1;\n  return a < b ? -1 : a > b ? 1 : 0;\n}\n\n/** First index whose element is >= `val` (`after` false) or > `val` (`after` true); `id.length` when none. */\nfunction searchBound(id: PineArray<float>, val: float, after: boolean): int {\n  let lo = 0;\n  let hi = id.length;\n  while (lo < hi) {\n    const mid = (lo + hi) >>> 1;\n    const c = compareSorted(id[mid]!, val);\n    if (c < 0 || (after && c === 0)) lo = mid + 1;\n    else hi = mid;\n  }\n  return lo;\n}\n\n/**\n * Binary Search Rightmost\n *\n * Returns the index of the value if found. When not found, returns the index\n * of the element to the right of where the value would be.\n *\n * @param id - Sorted array (ascending order)\n * @param val - Value to search for\n * @returns Index of value or insertion point to the right\n *\n * @example\n * ```typescript\n * const arr = [-2, 0, 1, 5, 9];\n * const index = array.binary_search_rightmost(arr, 3);\n * // Returns: 3 (index of 5, which is right of where 3 would be)\n * ```\n *\n * @example\n * ```typescript\n * const arr = [4, 5, 5, 5];\n * const index = array.binary_search_rightmost(arr, 5);\n * // Returns: 3 (index of last instance of 5)\n * ```\n *\n * @remarks\n * - Array must be sorted in ascending order\n * - For duplicate values, returns rightmost occurrence\n * - When value not found, returns position of next larger element\n * - PineScript rules: a value above every element gives `size` (the position after the last element); `na` counts\n *   as greater than every number (an array without na gives `size`); the comparison is exact (no 1e-10 tolerance)\n */\nexport function binary_search_rightmost(id: PineArray<float>, val: float): int {\n  if (id.length === 0) return -1;\n  const at = searchBound(id, val, true);\n  return at > 0 && compareSorted(id[at - 1]!, val) === 0 ? at - 1 : at;\n}\n\n/**\n * Covariance\n *\n * Returns the covariance between two arrays.\n *\n * @param id1 - First array\n * @param id2 - Second array\n * @param biased - If true, uses biased estimate (population). If false, uses unbiased estimate (sample). Default: true\n * @returns Covariance between the two arrays\n *\n * @example\n * ```typescript\n * const prices = [100, 102, 98, 105, 103];\n * const volume = [1000, 1200, 950, 1300, 1100];\n * const cov = array.covariance(prices, volume);\n * // Returns covariance between price and volume\n * ```\n *\n * @remarks\n * - Biased (true): divides by n (population covariance)\n * - Unbiased (false): divides by n-1 (sample covariance)\n * - Returns NaN if arrays are empty or have different lengths\n * - Formula: Cov(X,Y) = E[(X - \u03BCX)(Y - \u03BCY)]\n */\nexport function covariance(id1: PineArray<float>, id2: PineArray<float>, biased: bool = true): float {\n  if (id1.length === 0 || id2.length === 0) {\n    return NaN;\n  }\n\n  if (id1.length !== id2.length) {\n    return NaN;\n  }\n\n  const n = id1.length;\n  const mean1 = avg(id1);\n  const mean2 = avg(id2);\n\n  let sum = 0;\n  for (let i = 0; i < n; i++) {\n    sum += (id1[i]! - mean1) * (id2[i]! - mean2);\n  }\n\n  // Biased: divide by n, Unbiased: divide by n-1\n  const divisor = biased ? n : n - 1;\n  return sum / divisor;\n}\n\n/**\n * Percentile Linear Interpolation\n *\n * Returns the value for which the specified percentage of array values are\n * less than or equal to it, using linear interpolation.\n *\n * @param id - Array of numeric values\n * @param percentage - Percentage (0-100)\n * @returns Percentile value using linear interpolation\n *\n * @example\n * ```typescript\n * const arr = [1, 2, 3, 4, 5];\n * const p50 = array.percentile_linear_interpolation(arr, 50);\n * // Returns: 3 (median)\n * ```\n *\n * @remarks\n * - Uses linear interpolation between adjacent values\n * - Result may not be a member of the array\n * - Returns NaN if array is empty\n *\n * PineScript rules:\n * - position in the sorted array: `percentage / 100 * size - 0.5`, clamped to the first / last value, linear\n *   interpolation between the two neighbours\n * - `na` values are sorted after all numbers; with an `na` in the array, a position between two values gives `na`\n */\nexport function percentile_linear_interpolation(id: PineArray<float>, percentage: float): float {\n  if (id.length === 0) {\n    return NaN;\n  }\n  const s = sortedNaLast(id);\n  const n = s.length;\n  const pos = (percentage / 100) * n - 0.5;\n  if (pos <= 0) return s[0]!;\n  if (pos >= n - 1) return s[n - 1]!;\n  const lo = Math.floor(pos);\n  const f = pos - lo;\n  if (f === 0) return s[lo]!;\n  return Number.isNaN(s[n - 1]!) ? NaN : s[lo]! + f * (s[lo + 1]! - s[lo]!);\n}\n\n/** Array values sorted ascending, `na` values after the numbers (array.percentile_*). */\nfunction sortedNaLast(id: PineArray<float>): number[] {\n  const numbers = id.filter((v) => !Number.isNaN(v)).sort((a, b) => a - b);\n  return [...numbers, ...Array<number>(id.length - numbers.length).fill(NaN)];\n}\n\n/**\n * Percentile Nearest Rank\n *\n * Returns the value for which the specified percentage of array values are\n * less than or equal to it, using the nearest-rank method.\n *\n * @param id - Array of numeric values\n * @param percentage - Percentage (0-100)\n * @returns Percentile value using nearest rank\n *\n * @example\n * ```typescript\n * const arr = [1, 2, 3, 4, 5];\n * const p50 = array.percentile_nearest_rank(arr, 50);\n * // Returns: 3 (median, always a member of array)\n * ```\n *\n * @remarks\n * - Result is always a member of the array\n * - Uses nearest-rank method (no interpolation)\n * - Returns NaN if array is empty\n *\n * PineScript rules:\n * - the value at rank `ceil(percentage / 100 * size)` of the sorted array\n * - `na` values are sorted after all numbers (na when that rank holds an `na`)\n */\nexport function percentile_nearest_rank(id: PineArray<float>, percentage: float): float {\n  if (id.length === 0) {\n    return NaN;\n  }\n  const s = sortedNaLast(id);\n  const rank = Math.min(s.length, Math.max(1, Math.ceil((percentage / 100) * s.length)));\n  return s[rank - 1]!;\n}\n\n/**\n * Percent Rank\n *\n * Returns the percentile rank of the element at the specified index.\n * The percentile rank is the percentage of elements that are less than\n * or equal to the reference value.\n *\n * @param id - Array of numeric values\n * @param index - Index of element to rank\n * @returns Percentile rank (0-100)\n *\n * @example\n * ```typescript\n * const arr = [1, 2, 3, 4, 5];\n * const rank = array.percentrank(arr, 2); // Value at index 2 is 3\n * // Returns: 40 (40% of values <= 3)\n * ```\n *\n * @remarks\n * - Returns percentage of elements <= the value at given index\n * - Range: 0 to 100\n * - Returns NaN if array is empty or index out of bounds\n */\nexport function percentrank(id: PineArray<float>, index: int): float {\n  if (id.length === 0 || index < 0 || index >= id.length) {\n    return NaN;\n  }\n\n  const value = id[index]!;\n\n  if (isNaN(value)) {\n    return NaN;\n  }\n\n  // Count elements less than or equal to the value\n  let count = 0;\n  for (let i = 0; i < id.length; i++) {\n    if (!isNaN(id[i]!) && id[i]! <= value) {\n      count++;\n    }\n  }\n\n  // Calculate percentage\n  return (count / id.length) * 100;\n}\n\n/**\n * Sort Indices\n *\n * Returns an array of indices which, when used to index the original array,\n * will access its elements in their sorted order. Does not modify the original array.\n *\n * @param id - Array to get sorted indices from\n * @param order - Sort order: 'asc' or 'desc' (default: 'asc')\n * @returns Array of indices in sorted order\n *\n * @example\n * ```typescript\n * const arr = [5, -2, 0, 9, 1];\n * const indices = array.sort_indices(arr); // [1, 2, 4, 0, 3]\n * // arr[1] = -2 (smallest)\n * // arr[2] = 0\n * // arr[4] = 1\n * // arr[0] = 5\n * // arr[3] = 9 (largest)\n * ```\n *\n * @remarks\n * - Original array is not modified\n * - Returns indices that would sort the array\n * - Useful for maintaining correspondence with other arrays\n */\nexport function sort_indices(id: PineArray<float>, order: 'asc' | 'desc' = 'asc'): PineArray<int> {\n  // Create array of indices\n  const indices: PineArray<int> = Array.from({ length: id.length }, (_, i) => i) as PineArray<int>;\n\n  // Sort indices based on values in original array\n  indices.sort((a, b) => {\n    if (order === 'asc') {\n      return id[a]! - id[b]!;\n    } else {\n      return id[b]! - id[a]!;\n    }\n  });\n\n  return indices;\n}\n\n/**\n * Standardize\n *\n * Returns an array of standardized elements (z-score normalization).\n * Each element is transformed to (value - mean) / stddev.\n *\n * @param id - Array of numeric values\n * @returns Array of standardized values (z-scores)\n *\n * @example\n * ```typescript\n * const arr = [1, 2, 3, 4, 5];\n * const standardized = array.standardize(arr);\n * // Mean = 3, StdDev \u2248 1.414\n * // Result \u2248 [-1.414, -0.707, 0, 0.707, 1.414]\n * ```\n *\n * @remarks\n * - Formula: z = (x - \u03BC) / \u03C3\n * - Result has mean of 0 and standard deviation of 1\n * - Returns array of NaN if standard deviation is 0\n * - Useful for comparing values on different scales\n */\nexport function standardize(id: PineArray<float>): PineArray<float> {\n  if (id.length === 0) {\n    return [] as PineArray<float>;\n  }\n\n  const mean = avg(id);\n  const stdDev = stdev(id);\n\n  // If stddev is 0, all values are the same - return array of 0s or NaN\n  if (stdDev === 0) {\n    return id.map(() => NaN) as PineArray<float>;\n  }\n\n  // Calculate z-score for each element\n  return id.map(value => (value - mean) / stdDev) as PineArray<float>;\n}\n\n/**\n * New Type (User-Defined Type Array)\n *\n * Creates a new array of user-defined type elements.\n *\n * @param size - Initial size of array (default: 0)\n * @param initial_value - Initial value for all elements\n * @returns New array of user-defined type\n *\n * @example\n * ```typescript\n * // NOTE: User-defined types (UDTs) are not fully supported yet\n * // This is a placeholder for future implementation\n * const arr = array.newtype<MyType>(5);\n * ```\n *\n * @remarks\n * - **\u26A0\uFE0F LIMITED SUPPORT**: User-defined types (UDTs) require a type system\n *   that is not yet fully implemented in this library\n * - This function currently works like `new_array<T>()` for basic types\n * - Full UDT support will be added in a future version\n * - See PineScript documentation for UDT usage patterns\n */\nexport function newtype<T>(size: simple_int = 0, initial_value?: T): PineArray<T> {\n  // For now, this is just an alias for new_array\n  // Full UDT support requires implementing the type system\n  return new_array<T>(size, initial_value);\n}\n\n/**\n * \u26A0\uFE0F RENDERING FUNCTIONS NOT IMPLEMENTED\n *\n * The following array constructor functions are intentionally excluded\n * because they create arrays for rendering objects, which are outside\n * the scope of this calculation-focused library:\n *\n * - `new_box()` - Creates arrays of box drawing objects\n * - `new_label()` - Creates arrays of label objects\n * - `new_line()` - Creates arrays of line drawing objects\n * - `new_linefill()` - Creates arrays of line fill objects\n * - `new_table()` - Creates arrays of table layout objects\n *\n * **Design Constraint**: This library focuses on calculation and indicator\n * functions only. Rendering, visualization, and UI functions require a\n * rendering engine and are not included.\n *\n * If you need these functions, consider:\n * 1. Using PineScript directly\n * 2. Implementing a rendering layer separately\n * 3. Using this library for calculations and another library for visualization\n */\n"],
-  "mappings": "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",
-  "names": ["size", "mode", "sum"]
+  "sourcesContent": ["/**\n * Array namespace\n * Mirrors PineScript's array.* functions\n */\n\nimport type { PineArray, int, float, bool, simple_int, color, Line, Box, Label, Linefill, Table } from '../types/index.js';\n\n/**\n * Creates a new array with initial size and default value\n */\nexport function new_array<T>(size: simple_int = 0, initial_value?: T): PineArray<T> {\n  const arr: PineArray<T> = [];\n  for (let i = 0; i < size; i++) {\n    arr.push(initial_value as T);\n  }\n  return arr;\n}\n\n/**\n * Returns the number of elements in an array\n */\nexport function size<T>(id: PineArray<T>): int {\n  return id.length;\n}\n\n/** True for a PineScript `na` element: NaN, null or undefined. */\nfunction isNa(v: unknown): boolean {\n  return v === undefined || v === null || (typeof v === 'number' && Number.isNaN(v));\n}\n\n/** The `na` of the array's element type: NaN for a numeric (or empty) array, undefined otherwise. */\nfunction naOf<T>(id: PineArray<T>): T {\n  return (id.length === 0 || typeof id[0] === 'number' ? NaN : undefined) as T;\n}\n\n/**\n * Position addressed by a PineScript index: truncated, a negative index counts from the end. An index outside\n * `-size .. size - 1 + extra` is a runtime error.\n */\nfunction position(name: string, id: PineArray<unknown>, index: number, extra = 0): number {\n  const i = Math.trunc(index);\n  const n = id.length;\n  if (i < -n || i >= n + extra) {\n    throw new Error(`array.${name}: index ${i} is out of bounds, array size is ${n}`);\n  }\n  return i < 0 ? i + n : i;\n}\n\n/**\n * Returns the element at the specified index.\n *\n * PineScript rules: a negative index counts from the end (`get(a, -1)` is the last element); an index outside\n * `-size .. size - 1` is a runtime error (throws); an `na` index gives `na`.\n */\nexport function get<T>(id: PineArray<T>, index: simple_int): T {\n  if (Number.isNaN(index)) return naOf(id);\n  return id[position('get', id, index)]!;\n}\n\n/**\n * Sets the value of the element at the specified index.\n *\n * PineScript rules: a negative index counts from the end; an index outside `-size .. size - 1` is a runtime error\n * (throws); an `na` index does nothing.\n */\nexport function set<T>(id: PineArray<T>, index: simple_int, value: T): void {\n  if (Number.isNaN(index)) return;\n  id[position('set', id, index)] = value;\n}\n\n/**\n * Appends a value to the end of the array\n */\nexport function push<T>(id: PineArray<T>, value: T): void {\n  id.push(value);\n}\n\n/**\n * Removes and returns the last element of the array\n */\nexport function pop<T>(id: PineArray<T>): T {\n  return id.pop() as T;\n}\n\n/**\n * Inserts a value at the beginning of the array\n */\nexport function unshift<T>(id: PineArray<T>, value: T): void {\n  id.unshift(value);\n}\n\n/**\n * Removes and returns the first element of the array\n */\nexport function shift<T>(id: PineArray<T>): T {\n  return id.shift() as T;\n}\n\n/**\n * Removes all elements from the array\n */\nexport function clear<T>(id: PineArray<T>): void {\n  id.length = 0;\n}\n\n/**\n * Inserts a value at the specified index.\n *\n * PineScript rules: a negative index counts from the end and `size` appends, so `-size .. size` is valid; any other\n * index is a runtime error (throws); an `na` index appends.\n */\nexport function insert<T>(id: PineArray<T>, index: simple_int, value: T): void {\n  if (Number.isNaN(index)) {\n    id.push(value);\n    return;\n  }\n  id.splice(position('insert', id, index, 1), 0, value);\n}\n\n/**\n * Removes the element at the specified index and returns it.\n *\n * PineScript rules: a negative index counts from the end; an index outside `-size .. size - 1` is a runtime error\n * (throws); an `na` index removes nothing and gives `na`.\n */\nexport function remove<T>(id: PineArray<T>, index: simple_int): T {\n  if (Number.isNaN(index)) return naOf(id);\n  return id.splice(position('remove', id, index), 1)[0]!;\n}\n\n/** PineScript `==` of two elements: numbers are equal when |a - b| <= 1e-10; `na` never equals anything. */\nfunction pineEqual(a: unknown, b: unknown): boolean {\n  if (isNa(a) || isNa(b)) return false;\n  if (a === b) return true;\n  if (typeof a === 'number' && typeof b === 'number') {\n    const d = a - b;\n    return -1e-10 <= d && d <= 1e-10;\n  }\n  return false;\n}\n\n/**\n * Returns true if the array contains the value.\n *\n * PineScript rules: numbers are compared with a 1e-10 tolerance (|a - b| <= 1e-10); `na` is never found.\n */\nexport function includes<T>(id: PineArray<T>, value: T): bool {\n  return indexof(id, value) >= 0;\n}\n\n/**\n * Returns the index of the first occurrence of the value, -1 when not found.\n *\n * PineScript rules: numbers are compared with a 1e-10 tolerance (|a - b| <= 1e-10); `na` is never found.\n */\nexport function indexof<T>(id: PineArray<T>, value: T): int {\n  for (let i = 0; i < id.length; i++) {\n    if (pineEqual(id[i], value)) return i;\n  }\n  return -1;\n}\n\n/**\n * Returns the index of the last occurrence of the value, -1 when not found.\n *\n * PineScript rules: numbers are compared with a 1e-10 tolerance (|a - b| <= 1e-10); `na` is never found.\n */\nexport function lastindexof<T>(id: PineArray<T>, value: T): int {\n  for (let i = id.length - 1; i >= 0; i--) {\n    if (pineEqual(id[i], value)) return i;\n  }\n  return -1;\n}\n\n/**\n * Returns a shallow copy of the array\n */\nexport function copy<T>(id: PineArray<T>): PineArray<T> {\n  return [...id] as PineArray<T>;\n}\n\n/**\n * Appends the elements of `id2` to `id1` and returns `id1` (PineScript `array.concat` changes `id1`).\n */\nexport function concat<T>(id1: PineArray<T>, id2: PineArray<T>): PineArray<T> {\n  for (const v of Array.from(id2)) id1.push(v);\n  return id1;\n}\n\n/**\n * Joins all elements into a string\n */\nexport function join(id: PineArray<any>, separator: string = ','): string {\n  return id.join(separator);\n}\n\n/**\n * Reverses the array in place\n */\nexport function reverse<T>(id: PineArray<T>): void {\n  id.reverse();\n}\n\n/**\n * Returns the elements from `index_from` (included) to `index_to` (excluded, default: the size) as a live view of\n * the array (PineScript `array.slice`).\n *\n * PineScript rules:\n * - the slice shares the elements of the original array: a change of an element of the slice changes the original\n *   array, and adding / removing elements of the slice adds / removes them in the original array, inside the slice\n *   bounds (a push to the slice inserts at the end of the slice)\n * - `index_from` must address an element (`0 .. size - 1`) and `index_to` may be `size`; other bounds, or\n *   `index_from > index_to`, are a runtime error (throws); an `na` bound means the start / the end of the array\n */\nexport function slice<T>(id: PineArray<T>, index_from: simple_int, index_to?: simple_int): PineArray<T> {\n  const n = id.length;\n  const start = Number.isNaN(index_from) ? 0 : Math.trunc(index_from);\n  const stop = index_to === undefined || Number.isNaN(index_to) ? n : Math.trunc(index_to);\n  if (start < 0 || start >= n) throw new Error(`array.slice: index ${start} is out of bounds, array size is ${n}`);\n  if (stop < 0 || stop > n) throw new Error(`array.slice: index ${stop} is out of bounds, array size is ${n}`);\n  if (start > stop) throw new Error(`array.slice: index_from ${start} is greater than index_to ${stop}`);\n  return sliceView(id, start, stop - start);\n}\n\n/** Index of a property key that is an array index, -1 otherwise. */\nfunction indexKey(p: string | symbol): number {\n  if (typeof p !== 'string') return -1;\n  const i = Number(p);\n  return Number.isInteger(i) && i >= 0 && String(i) === p ? i : -1;\n}\n\n/**\n * Live view of `size` elements of `parent` from `start`: an array (a Proxy) whose element reads and writes go to\n * `parent`, and whose size changes insert / remove elements in `parent` at the end of the view.\n */\nfunction sliceView<T>(parent: PineArray<T>, start: number, size: number): PineArray<T> {\n  const resize = (target: number): void => {\n    if (target > size) parent.splice(start + size, 0, ...Array<T>(target - size).fill(undefined as T));\n    else if (target < size) parent.splice(start + target, size - target);\n    size = target;\n  };\n  return new Proxy<T[]>([], {\n    get(target, p, receiver) {\n      const i = indexKey(p);\n      if (i >= 0) return i < size ? parent[start + i] : undefined;\n      if (p === 'length') return size;\n      return Reflect.get(target, p, receiver);\n    },\n    set(target, p, value, receiver) {\n      const i = indexKey(p);\n      if (i >= 0) {\n        if (i >= size) resize(i + 1);\n        parent[start + i] = value;\n        return true;\n      }\n      if (p === 'length') {\n        resize(Number(value));\n        return true;\n      }\n      return Reflect.set(target, p, value, receiver);\n    },\n    has(target, p) {\n      const i = indexKey(p);\n      return i >= 0 ? i < size : Reflect.has(target, p);\n    },\n    // Array methods delete the slots past the new end before they set the length, which does the removal.\n    deleteProperty(target, p) {\n      return indexKey(p) >= 0 ? true : Reflect.deleteProperty(target, p);\n    },\n    ownKeys(target) {\n      return [...Array.from({ length: size }, (_, i) => String(i)), ...Reflect.ownKeys(target)];\n    },\n    getOwnPropertyDescriptor(target, p) {\n      const i = indexKey(p);\n      if (i >= 0) {\n        return i < size ? { value: parent[start + i], writable: true, enumerable: true, configurable: true } : undefined;\n      }\n      if (p === 'length') return { value: size, writable: true, enumerable: false, configurable: false };\n      return Reflect.getOwnPropertyDescriptor(target, p);\n    },\n  });\n}\n\n/** Sort order of array.sort / array.sort_indices (PineScript `order.ascending` / `order.descending`). */\nexport type SortOrder = 'asc' | 'desc' | 'ascending' | 'descending';\n\n/**\n * Positions of the elements in PineScript sorted order: ascending values, `na` after the numbers (before the\n * strings of a string array), stable; descending is the ascending result reversed.\n */\nfunction sortedPositions<T>(id: PineArray<T>, order: SortOrder): number[] {\n  const values: number[] = [];\n  const nas: number[] = [];\n  for (let i = 0; i < id.length; i++) (isNa(id[i]) ? nas : values).push(i);\n  values.sort((a, b) => {\n    const x = id[a] as unknown as number;\n    const y = id[b] as unknown as number;\n    return x < y ? -1 : x > y ? 1 : 0;\n  });\n  const naFirst = values.length > 0 && typeof id[values[0]!] === 'string';\n  const positions = naFirst ? [...nas, ...values] : [...values, ...nas];\n  if (order === 'desc' || order === 'descending') positions.reverse();\n  return positions;\n}\n\n/**\n * Sorts the array in place.\n *\n * PineScript rules: `na` goes after the numbers in ascending order and before them in descending order (the\n * ascending result reversed); in a string array `na` goes first in ascending order.\n */\nexport function sort<T>(id: PineArray<T>, order: SortOrder = 'asc'): void {\n  const sorted = sortedPositions(id, order).map((p) => id[p]!);\n  for (let i = 0; i < sorted.length; i++) id[i] = sorted[i]!;\n}\n\n/**\n * Sum of the non-na elements (PineScript `array.sum(id)`), added from left to right; an array without values gives NaN.\n * As PineScript, the running sum is set to 0 after a step when its absolute value is <= 1e-10.\n */\nexport function sum(id: PineArray<float>): float {\n  let total = 0;\n  let count = 0;\n  for (const v of id) {\n    if (Number.isNaN(v)) continue;\n    count++;\n    total += v;\n    if (Math.abs(total) <= 1e-10) total = 0;\n  }\n  return count ? total : NaN;\n}\n\n/**\n * Average of the non-na elements (PineScript `array.avg(id)`); an array without values gives NaN.\n */\nexport function avg(id: PineArray<float>): float {\n  const values = id.filter((v) => !Number.isNaN(v));\n  return values.length ? values.reduce((a, b) => a + b, 0) / values.length : NaN;\n}\n\n/** The `nth` value of the non-na elements sorted with `compare` (array.min / array.max). */\nfunction nthValue(name: string, id: PineArray<float>, nth: number, compare: (a: number, b: number) => number): float {\n  const rank = Number.isNaN(nth) ? 0 : Math.trunc(nth);\n  const values = id.filter((v) => !Number.isNaN(v));\n  if (!values.length) return NaN;\n  if (rank < 0 || rank >= id.length) {\n    throw new Error(`array.${name}: nth ${rank} is out of bounds, array size is ${id.length}`);\n  }\n  values.sort(compare);\n  return values[Math.min(rank, values.length - 1)]!;\n}\n\n/**\n * The `nth` smallest value (0 = the smallest) of the non-na elements (PineScript `array.min(id, nth)`).\n *\n * PineScript rules: an `nth` past the non-na values but inside the array size gives the greatest value; an `nth`\n * outside `0 .. size - 1` is a runtime error (throws); an `na` nth counts as 0; an array without values gives NaN.\n */\nexport function min(id: PineArray<float>, nth: simple_int = 0): float {\n  return nthValue('min', id, nth, (a, b) => a - b);\n}\n\n/**\n * The `nth` greatest value (0 = the greatest) of the non-na elements (PineScript `array.max(id, nth)`).\n *\n * PineScript rules: an `nth` past the non-na values but inside the array size gives the smallest value; an `nth`\n * outside `0 .. size - 1` is a runtime error (throws); an `na` nth counts as 0; an array without values gives NaN.\n */\nexport function max(id: PineArray<float>, nth: simple_int = 0): float {\n  return nthValue('max', id, nth, (a, b) => b - a);\n}\n\n/**\n * Median of the non-na elements (PineScript `array.median(id)`): the middle value, or the mean of the two middle\n * values for an even count; an array without values gives NaN.\n */\nexport function median(id: PineArray<float>): float {\n  const sorted = id.filter((v) => !Number.isNaN(v)).sort((a, b) => a - b);\n  if (!sorted.length) return NaN;\n  const mid = Math.floor(sorted.length / 2);\n  return sorted.length % 2 === 0 ? (sorted[mid - 1]! + sorted[mid]!) / 2 : sorted[mid]!;\n}\n\n/**\n * Most frequent non-na element (PineScript `array.mode(id)`), compared exactly.\n *\n * PineScript rules: with several values of the same frequency, the smallest one; an array without values gives NaN.\n */\nexport function mode(id: PineArray<float>): float {\n  const frequency = new Map<float, int>();\n  for (const v of id) {\n    if (!Number.isNaN(v)) frequency.set(v, (frequency.get(v) ?? 0) + 1);\n  }\n  let best = NaN;\n  let bestCount = 0;\n  for (const [v, count] of frequency) {\n    if (count > bestCount || (count === bestCount && v < best)) {\n      best = v;\n      bestCount = count;\n    }\n  }\n  return best;\n}\n\n/**\n * Standard deviation of the non-na elements (PineScript `array.stdev(id, biased)`): the square root of\n * `array.variance(id, biased)`.\n */\nexport function stdev(id: PineArray<float>, biased: bool = true): float {\n  return Math.sqrt(variance(id, biased));\n}\n\n/** Sum of the values and sum of their squares, both added from the first to the last value. */\nfunction moments(values: number[]): [number, number] {\n  let p = 0;\n  let q = 0;\n  for (const v of values) p += v;\n  for (const v of values) q += v * v;\n  return [p, q];\n}\n\n/**\n * Variance of the non-na elements (PineScript `array.variance(id, biased)`).\n *\n * PineScript rule (moment form): with `p` the sum of the values, `q` the sum of their squares, `n` the count and\n * `m = p / n`: biased (default) `max(0, q / n - m * m)`, unbiased `max(0, q / (n - 1) - (p / (n - 1)) * m)`.\n * One value gives 0 biased and NaN unbiased; an array without values gives NaN.\n */\nexport function variance(id: PineArray<float>, biased: bool = true): float {\n  const values = id.filter((v) => !Number.isNaN(v));\n  const n = values.length;\n  if (!n) return NaN;\n  if (n < 2) return biased ? 0 : NaN;\n  const [p, q] = moments(values);\n  const mean = p / n;\n  return biased ? Math.max(0, q / n - mean * mean) : Math.max(0, q / (n - 1) - (p / (n - 1)) * mean);\n}\n\n/**\n * Fills the array with the specified value\n */\nexport function fill<T>(id: PineArray<T>, value: T, index_from: simple_int = 0, index_to?: simple_int): void {\n  // PineScript: an na bound is the start / the end; a bound past the end is a runtime error\n  const start = index_from === undefined || index_from === null || Number.isNaN(index_from) ? 0 : index_from;\n  const end = index_to === undefined || index_to === null || Number.isNaN(index_to) ? id.length : index_to;\n  for (const i of [start, end]) {\n    if (i < 0 || i > id.length) throw new Error(`array.fill: index ${i} is out of bounds, array size is ${id.length}`);\n  }\n  for (let i = start; i < end; i++) {\n    id[i] = value;\n  }\n}\n\n/**\n * Creates an array from its arguments (PineScript `array.from(arg0, arg1, ...)`).\n * `na` values are kept.\n *\n * @example\n * ```typescript\n * array.from(0.236, 0.382, 0.5, 0.618); // [0.236, 0.382, 0.5, 0.618]\n * ```\n */\nexport function from<T>(...values: T[]): PineArray<T> {\n  return [...values];\n}\n\n/**\n * Returns the first element of the array\n *\n * @param id - The array\n * @returns The first element, or undefined if array is empty\n *\n * @remarks\n * - Equivalent to `array.get(id, 0)`\n * - Returns undefined for empty arrays\n *\n * @example\n * ```typescript\n * const arr = [1, 2, 3, 4, 5];\n * const firstElement = array.first(arr); // Returns: 1\n * ```\n */\nexport function first<T>(id: PineArray<T>): T {\n  // PineScript: a runtime error on an empty array\n  if (id.length === 0) throw new Error('Cannot call array.first() if array is empty');\n  return id[0]!;\n}\n\n/**\n * Returns the last element of the array\n *\n * @param id - The array\n * @returns The last element, or undefined if array is empty\n *\n * @remarks\n * - Equivalent to `array.get(id, array.size(id) - 1)`\n * - Returns undefined for empty arrays\n *\n * @example\n * ```typescript\n * const arr = [1, 2, 3, 4, 5];\n * const lastElement = array.last(arr); // Returns: 5\n * ```\n */\nexport function last<T>(id: PineArray<T>): T {\n  // PineScript: a runtime error on an empty array (as array.first)\n  if (id.length === 0) throw new Error('Cannot call array.last() if array is empty');\n  return id[id.length - 1]!;\n}\n\n/**\n * True when at least one element of a bool array is true (PineScript `array.some(id)`).\n * An empty array gives false.\n */\nexport function some(id: PineArray<bool>): bool {\n  return id.some((v) => v === true);\n}\n\n/**\n * True when every element of a bool array is true (PineScript `array.every(id)`).\n * An empty array gives false, as in PineScript.\n */\nexport function every(id: PineArray<bool>): bool {\n  return id.length > 0 && id.every((v) => v === true);\n}\n\n/**\n * Create new boolean array\n *\n * Creates a new array object of bool type elements.\n *\n * @param size - Initial size of array (default: 0)\n * @param initial_value - Initial value for all elements (default: false)\n * @returns New boolean array\n *\n * @example\n * ```typescript\n * const arr = array.new_bool(5, true);\n * // Creates: [true, true, true, true, true]\n * ```\n */\nexport function new_bool(size: simple_int = 0, initial_value: bool = false): PineArray<bool> {\n  return new_array<bool>(size, initial_value);\n}\n\n/**\n * Create new float array\n *\n * Creates a new array object of float type elements.\n *\n * @param size - Initial size of array (default: 0)\n * @param initial_value - Initial value for all elements (default: NaN)\n * @returns New float array\n *\n * @example\n * ```typescript\n * const arr = array.new_float(5, 0.0);\n * // Creates: [0.0, 0.0, 0.0, 0.0, 0.0]\n * ```\n */\nexport function new_float(size: simple_int = 0, initial_value: float = NaN): PineArray<float> {\n  return new_array<float>(size, initial_value);\n}\n\n/**\n * Create new integer array\n *\n * Creates a new array object of int type elements.\n *\n * @param size - Initial size of array (default: 0)\n * @param initial_value - Initial value for all elements (default: NaN)\n * @returns New integer array\n *\n * @example\n * ```typescript\n * const arr = array.new_int(5, 0);\n * // Creates: [0, 0, 0, 0, 0]\n * ```\n */\nexport function new_int(size: simple_int = 0, initial_value: int = NaN): PineArray<int> {\n  return new_array<int>(size, initial_value);\n}\n\n/**\n * Create new string array\n *\n * Creates a new array object of string type elements.\n *\n * @param size - Initial size of array (default: 0)\n * @param initial_value - Initial value for all elements (default: undefined)\n * @returns New string array\n *\n * @example\n * ```typescript\n * const arr = array.new_string(5, \"text\");\n * // Creates: [\"text\", \"text\", \"text\", \"text\", \"text\"]\n * ```\n */\nexport function new_string(size: simple_int = 0, initial_value?: string): PineArray<string> {\n  return new_array<string>(size, initial_value);\n}\n\n/**\n * Create new color array\n *\n * Creates a new array object of color type elements.\n *\n * @param size - Initial size of array (default: 0)\n * @param initial_value - Initial value for all elements (default: undefined)\n * @returns New color array\n *\n * @example\n * ```typescript\n * const arr = array.new_color(5, \"#FF0000\");\n * // Creates: [\"#FF0000\", \"#FF0000\", \"#FF0000\", \"#FF0000\", \"#FF0000\"]\n * ```\n */\nexport function new_color(size: simple_int = 0, initial_value?: color): PineArray<color> {\n  return new_array<color>(size, initial_value);\n}\n\n/**\n * Create new line array\n *\n * Creates a new array object of line type elements.\n *\n * @param size - Initial size of array (default: 0)\n * @param initial_value - Initial value for all elements (default: undefined)\n * @returns New line array\n *\n * @example\n * ```typescript\n * import { array, line } from 'oakscriptjs';\n *\n * // Create array to store last 15 lines\n * const lines = array.new_line();\n * const trendLine = line.new(0, 100, 50, 150);\n * array.push(lines, trendLine);\n *\n * // Manage line count\n * if (array.size(lines) > 15) {\n *   const oldLine = array.shift(lines);\n * }\n * ```\n *\n * @remarks\n * Useful for managing collections of trend lines, support/resistance levels, or channel lines.\n * In PineScript, this is typically used with line.delete() to manage chart object limits.\n */\nexport function new_line(size: simple_int = 0, initial_value?: Line): PineArray<Line> {\n  return new_array<Line>(size, initial_value);\n}\n\n/**\n * Create new box array\n *\n * Creates a new array object of box type elements.\n *\n * @param size - Initial size of array (default: 0)\n * @param initial_value - Initial value for all elements (default: undefined)\n * @returns New box array\n *\n * @example\n * ```typescript\n * import { array, box } from 'oakscriptjs';\n *\n * // Create array to store gap boxes\n * const gaps = array.new_box();\n * const gapBox = box.new(10, 120, 15, 110);\n * array.push(gaps, gapBox);\n *\n * // Track multiple gaps\n * for (let i = 0; i < array.size(gaps); i++) {\n *   const gap = array.get(gaps, i);\n *   const gapTop = box.get_top(gap);\n *   const gapBottom = box.get_bottom(gap);\n *   // Check if gap filled...\n * }\n * ```\n *\n * @remarks\n * Useful for tracking ranges, gaps, consolidation zones, or rectangle patterns.\n * Enables systematic analysis of multiple box objects.\n */\nexport function new_box(size: simple_int = 0, initial_value?: Box): PineArray<Box> {\n  return new_array<Box>(size, initial_value);\n}\n\n/**\n * Create new label array\n *\n * Creates a new array object of label type elements.\n *\n * @param size - Initial size of array (default: 0)\n * @param initial_value - Initial value for all elements (default: undefined)\n * @returns New label array\n *\n * @example\n * ```typescript\n * import { array, label } from 'oakscriptjs';\n *\n * // Create array to store pivot labels\n * const pivotLabels = array.new_label();\n *\n * // Add labels for pivot highs\n * const pivotLabel = label.new(50, 155.5, 'PH', 'bar_index', 'abovebar');\n * array.push(pivotLabels, pivotLabel);\n *\n * // Limit number of labels shown\n * const maxLabels = 50;\n * if (array.size(pivotLabels) > maxLabels) {\n *   array.shift(pivotLabels);\n * }\n * ```\n *\n * @remarks\n * Useful for managing collections of annotations, pivot markers, or signal labels.\n * Helps limit the number of labels displayed by removing old ones.\n */\nexport function new_label(size: simple_int = 0, initial_value?: Label): PineArray<Label> {\n  return new_array<Label>(size, initial_value);\n}\n\n/**\n * Create new linefill array\n *\n * Creates a new array object of linefill type elements.\n *\n * @param size - Initial size of array (default: 0)\n * @param initial_value - Initial value for all elements (default: undefined)\n * @returns New linefill array\n *\n * @example\n * ```typescript\n * import { array, line, linefill } from 'oakscriptjs';\n *\n * // Create array to store channel fills\n * const channels = array.new_linefill();\n *\n * // Create channel\n * const upperLine = line.new(0, 120, 50, 130);\n * const lowerLine = line.new(0, 100, 50, 110);\n * const channelFill = linefill.new(upperLine, lowerLine, '#0000FF15');\n *\n * array.push(channels, channelFill);\n * ```\n *\n * @remarks\n * Useful for managing collections of channel fills, Bollinger Band fills, or regression channel fills.\n * Enables dynamic color changes across multiple channels.\n */\nexport function new_linefill(size: simple_int = 0, initial_value?: Linefill): PineArray<Linefill> {\n  return new_array<Linefill>(size, initial_value);\n}\n\n/**\n * Creates a new array of tables (PineScript `array.new_table`).\n *\n * @param size - Initial size of array (default: 0)\n * @param initial_value - Initial value for all elements (default: undefined)\n * @returns New table array\n */\nexport function new_table(size: simple_int = 0, initial_value?: Table): PineArray<Table> {\n  return new_array<Table>(size, initial_value);\n}\n\n/**\n * Absolute value of array elements\n *\n * Returns an array containing the absolute value of each element in the original array.\n *\n * @param id - Array of numeric values\n * @returns New array with absolute values\n *\n * @example\n * ```typescript\n * const arr = [-1, -2, 3, -4, 5];\n * const result = array.abs(arr);\n * // Returns: [1, 2, 3, 4, 5]\n * ```\n */\nexport function abs(id: PineArray<float>): PineArray<float> {\n  return id.map(x => Math.abs(x)) as PineArray<float>;\n}\n\n/**\n * Range of array values\n *\n * Returns the difference between the maximum and minimum values in the array.\n *\n * @param id - Array of numeric values\n * @returns Difference between max and min (range)\n *\n * @example\n * ```typescript\n * const arr = [1, 5, 3, 9, 2];\n * const result = array.range(arr);\n * // Returns: 8 (9 - 1)\n * ```\n *\n * @remarks\n * Returns NaN if the array is empty.\n */\nexport function range(id: PineArray<float>): float {\n  if (id.length === 0) {\n    return NaN;\n  }\n  return max(id) - min(id);\n}\n\n/**\n * Binary Search\n *\n * Searches for a value in a sorted array using binary search algorithm.\n * Returns the index of the value if found, or -1 if not found.\n *\n * @param id - Sorted array (ascending order)\n * @param val - Value to search for\n * @returns Index of the value, or -1 if not found\n *\n * @example\n * ```typescript\n * const arr = [-2, 0, 1, 5, 9]; // Must be sorted\n * const index = array.binary_search(arr, 5);\n * // Returns: 3\n * ```\n *\n * @remarks\n * - Array must be sorted in ascending order\n * - Uses standard binary search algorithm\n * - Time complexity: O(log n)\n */\nexport function binary_search(id: PineArray<float>, val: float): int {\n  let left = 0;\n  let right = id.length - 1;\n\n  while (left <= right) {\n    const mid = Math.floor((left + right) / 2);\n\n    if (id[mid]! === val) {\n      return mid;\n    }\n\n    if (id[mid]! < val) {\n      left = mid + 1;\n    } else {\n      right = mid - 1;\n    }\n  }\n\n  return -1; // Not found\n}\n\n/**\n * Binary Search Leftmost\n *\n * Returns the index of the value if found. When not found, returns the index\n * of the next smallest element to the left of where the value would be.\n *\n * @param id - Sorted array (ascending order)\n * @param val - Value to search for\n * @returns Index of value or insertion point to the left\n *\n * @example\n * ```typescript\n * const arr = [-2, 0, 1, 5, 9];\n * const index = array.binary_search_leftmost(arr, 3);\n * // Returns: 2 (index of 1, which is left of where 3 would be)\n * ```\n *\n * @example\n * ```typescript\n * const arr = [4, 5, 5, 5];\n * const index = array.binary_search_leftmost(arr, 5);\n * // Returns: 1 (index of first instance of 5)\n * ```\n *\n * @remarks\n * - Array must be sorted in ascending order\n * - For duplicate values, returns leftmost occurrence\n * - When value not found, returns position of next smaller element\n * - PineScript rules: a value below every element gives 0; `na` counts as greater than every number (an array\n *   without na gives `size - 1`); the comparison is exact (no 1e-10 tolerance)\n */\nexport function binary_search_leftmost(id: PineArray<float>, val: float): int {\n  if (id.length === 0) return -1;\n  const at = searchBound(id, val, false);\n  return at < id.length && compareSorted(id[at]!, val) === 0 ? at : Math.max(0, at - 1);\n}\n\n/**\n * Order of the PineScript binary searches: numbers in ascending order, na above every number (equal to na).\n */\nfunction compareSorted(a: float, b: float): number {\n  const an = Number.isNaN(a);\n  const bn = Number.isNaN(b);\n  if (an || bn) return an === bn ? 0 : an ? 1 : -1;\n  return a < b ? -1 : a > b ? 1 : 0;\n}\n\n/** First index whose element is >= `val` (`after` false) or > `val` (`after` true); `id.length` when none. */\nfunction searchBound(id: PineArray<float>, val: float, after: boolean): int {\n  let lo = 0;\n  let hi = id.length;\n  while (lo < hi) {\n    const mid = (lo + hi) >>> 1;\n    const c = compareSorted(id[mid]!, val);\n    if (c < 0 || (after && c === 0)) lo = mid + 1;\n    else hi = mid;\n  }\n  return lo;\n}\n\n/**\n * Binary Search Rightmost\n *\n * Returns the index of the value if found. When not found, returns the index\n * of the element to the right of where the value would be.\n *\n * @param id - Sorted array (ascending order)\n * @param val - Value to search for\n * @returns Index of value or insertion point to the right\n *\n * @example\n * ```typescript\n * const arr = [-2, 0, 1, 5, 9];\n * const index = array.binary_search_rightmost(arr, 3);\n * // Returns: 3 (index of 5, which is right of where 3 would be)\n * ```\n *\n * @example\n * ```typescript\n * const arr = [4, 5, 5, 5];\n * const index = array.binary_search_rightmost(arr, 5);\n * // Returns: 3 (index of last instance of 5)\n * ```\n *\n * @remarks\n * - Array must be sorted in ascending order\n * - For duplicate values, returns rightmost occurrence\n * - When value not found, returns position of next larger element\n * - PineScript rules: a value above every element gives `size` (the position after the last element); `na` counts\n *   as greater than every number (an array without na gives `size`); the comparison is exact (no 1e-10 tolerance)\n */\nexport function binary_search_rightmost(id: PineArray<float>, val: float): int {\n  if (id.length === 0) return -1;\n  const at = searchBound(id, val, true);\n  return at > 0 && compareSorted(id[at - 1]!, val) === 0 ? at - 1 : at;\n}\n\n/**\n * Covariance\n *\n * Returns the covariance between two arrays.\n *\n * @param id1 - First array\n * @param id2 - Second array\n * @param biased - If true, uses biased estimate (population). If false, uses unbiased estimate (sample). Default: true\n * @returns Covariance between the two arrays\n *\n * @example\n * ```typescript\n * const prices = [100, 102, 98, 105, 103];\n * const volume = [1000, 1200, 950, 1300, 1100];\n * const cov = array.covariance(prices, volume);\n * // Returns covariance between price and volume\n * ```\n *\n * @remarks\n * - Biased (true): divides by n (population covariance)\n * - Unbiased (false): divides by n-1 (sample covariance)\n * - Returns NaN if arrays are empty or have different lengths\n * - Formula: Cov(X,Y) = E[(X - \u03BCX)(Y - \u03BCY)]\n *\n * PineScript rules: a pair where either value is `na` is skipped and the count is the number of pairs kept; both\n * means first, then the sum of the products from the first to the last pair. One pair gives 0 biased, NaN unbiased.\n */\nexport function covariance(id1: PineArray<float>, id2: PineArray<float>, biased: bool = true): float {\n  if (id1.length !== id2.length) {\n    return NaN;\n  }\n  const xs: number[] = [];\n  const ys: number[] = [];\n  for (let i = 0; i < id1.length; i++) {\n    if (Number.isNaN(id1[i]!) || Number.isNaN(id2[i]!)) continue;\n    xs.push(id1[i]!);\n    ys.push(id2[i]!);\n  }\n  const n = xs.length;\n  if (!n || (!biased && n < 2)) return NaN;\n  let mean1 = 0;\n  let mean2 = 0;\n  for (let i = 0; i < n; i++) {\n    mean1 += xs[i]!;\n    mean2 += ys[i]!;\n  }\n  mean1 /= n;\n  mean2 /= n;\n  let sum = 0;\n  for (let i = 0; i < n; i++) {\n    sum += (xs[i]! - mean1) * (ys[i]! - mean2);\n  }\n  return sum / (biased ? n : n - 1);\n}\n\n/**\n * Percentile Linear Interpolation\n *\n * Returns the value for which the specified percentage of array values are\n * less than or equal to it, using linear interpolation.\n *\n * @param id - Array of numeric values\n * @param percentage - Percentage (0-100)\n * @returns Percentile value using linear interpolation\n *\n * @example\n * ```typescript\n * const arr = [1, 2, 3, 4, 5];\n * const p50 = array.percentile_linear_interpolation(arr, 50);\n * // Returns: 3 (median)\n * ```\n *\n * @remarks\n * - Uses linear interpolation between adjacent values\n * - Result may not be a member of the array\n * - Returns NaN if array is empty\n *\n * PineScript rules:\n * - 1-based position in the sorted array: `size * percentage / 100 + 0.5` (snapped to an integer within 1e-9),\n *   clamped to the first / last value; between two values `lo * (1 - frac) + hi * frac`\n * - `na` values are sorted after all numbers; with an `na` in the array, a position between two values gives `na`\n * - an `na` percentage gives `na`; a percentage outside 0 .. 100 is a runtime error (throws)\n */\nexport function percentile_linear_interpolation(id: PineArray<float>, percentage: float): float {\n  if (id.length === 0 || Number.isNaN(percentage)) {\n    return NaN;\n  }\n  checkPercentage('percentile_linear_interpolation', percentage);\n  const s = sortedNaLast(id);\n  const n = s.length;\n  let pos = (n * percentage) / 100 + 0.5;\n  const nearest = Math.round(pos);\n  if (Math.abs(pos - nearest) < 1e-9) pos = nearest;\n  if (pos <= 1) return s[0]!;\n  if (pos >= n) return s[n - 1]!;\n  const lower = Math.floor(pos);\n  const frac = pos - lower;\n  if (frac === 0) return s[lower - 1]!;\n  if (Number.isNaN(s[n - 1]!)) return NaN;\n  return s[lower - 1]! * (1 - frac) + s[lower]! * frac;\n}\n\n/** Array values sorted ascending, `na` values after the numbers (array.percentile_*). */\nfunction sortedNaLast(id: PineArray<float>): number[] {\n  const numbers = id.filter((v) => !Number.isNaN(v)).sort((a, b) => a - b);\n  return [...numbers, ...Array<number>(id.length - numbers.length).fill(NaN)];\n}\n\n/** A percentage outside 0 .. 100 is a PineScript runtime error. */\nfunction checkPercentage(name: string, percentage: number): void {\n  if (!(percentage >= 0 && percentage <= 100)) {\n    throw new Error(`array.${name}: percentage ${percentage} must be between 0 and 100`);\n  }\n}\n\n/**\n * Percentile Nearest Rank\n *\n * Returns the value for which the specified percentage of array values are\n * less than or equal to it, using the nearest-rank method.\n *\n * @param id - Array of numeric values\n * @param percentage - Percentage (0-100)\n * @returns Percentile value using nearest rank\n *\n * @example\n * ```typescript\n * const arr = [1, 2, 3, 4, 5];\n * const p50 = array.percentile_nearest_rank(arr, 50);\n * // Returns: 3 (median, always a member of array)\n * ```\n *\n * @remarks\n * - Result is always a member of the array\n * - Uses nearest-rank method (no interpolation)\n * - Returns NaN if array is empty\n *\n * PineScript rules:\n * - the value at rank `ceil(percentage * size / 100)` (clamped to 1 .. size) of the sorted array\n * - `na` values are sorted after all numbers (na when that rank holds an `na`)\n * - an `na` percentage counts as 0; a percentage outside 0 .. 100 is a runtime error (throws)\n */\nexport function percentile_nearest_rank(id: PineArray<float>, percentage: float): float {\n  if (id.length === 0) {\n    return NaN;\n  }\n  const pct = Number.isNaN(percentage) ? 0 : percentage;\n  checkPercentage('percentile_nearest_rank', pct);\n  const s = sortedNaLast(id);\n  const rank = Math.min(s.length, Math.max(1, Math.ceil((pct * s.length) / 100)));\n  return s[rank - 1]!;\n}\n\n/**\n * Percent Rank\n *\n * Returns the percentile rank of the element at the specified index.\n * The percentile rank is the percentage of elements that are less than\n * or equal to the reference value.\n *\n * @param id - Array of numeric values\n * @param index - Index of element to rank\n * @returns Percentile rank (0-100)\n *\n * @example\n * ```typescript\n * const arr = [1, 2, 3, 4, 5];\n * const rank = array.percentrank(arr, 2); // Value at index 2 is 3\n * // Returns: 50 ((3 - 1) * 100 / (5 - 1))\n * ```\n *\n * @remarks\n * - Range: 0 to 100\n *\n * PineScript rules:\n * - `(count - 1) * 100 / (size - 1)`, with `count` the number of non-na elements <= the element (exact\n *   comparison, no 1e-10 tolerance); `na` elements count in the size\n * - an `na` element, a one-element array or an empty array gives NaN\n * - an `na` index counts as 0; an index outside `0 .. size - 1` is a runtime error (throws)\n */\nexport function percentrank(id: PineArray<float>, index: int): float {\n  const i = Number.isNaN(index) ? 0 : Math.trunc(index);\n  if (id.length === 0) {\n    return NaN;\n  }\n  if (i < 0 || i >= id.length) {\n    throw new Error(`array.percentrank: index ${i} is out of bounds, array size is ${id.length}`);\n  }\n  if (id.length === 1) {\n    return NaN;\n  }\n  const value = id[i]!;\n  if (Number.isNaN(value)) {\n    return NaN;\n  }\n  let count = 0;\n  for (const v of id) {\n    if (v <= value) count++;\n  }\n  return ((count - 1) * 100) / (id.length - 1);\n}\n\n/**\n * Sort Indices\n *\n * Returns an array of indices which, when used to index the original array,\n * will access its elements in their sorted order. Does not modify the original array.\n *\n * @param id - Array to get sorted indices from\n * @param order - Sort order: 'asc' or 'desc' (default: 'asc')\n * @returns Array of indices in sorted order\n *\n * @example\n * ```typescript\n * const arr = [5, -2, 0, 9, 1];\n * const indices = array.sort_indices(arr); // [1, 2, 4, 0, 3]\n * // arr[1] = -2 (smallest)\n * // arr[2] = 0\n * // arr[4] = 1\n * // arr[0] = 5\n * // arr[3] = 9 (largest)\n * ```\n *\n * @remarks\n * - Original array is not modified\n * - Returns indices that would sort the array\n * - Useful for maintaining correspondence with other arrays\n * - PineScript rule: the indices of `na` elements go where `array.sort` puts them (after the numbers in ascending\n *   order, in their original order: `sort_indices([na, na, 5, 1])` is `[3, 2, 0, 1]`)\n */\nexport function sort_indices<T>(id: PineArray<T>, order: SortOrder = 'asc'): PineArray<int> {\n  return sortedPositions(id, order);\n}\n\n/**\n * Standardize\n *\n * Returns an array of standardized elements (z-score normalization).\n * Each element is transformed to (value - mean) / stddev.\n *\n * @param id - Array of numeric values\n * @returns Array of standardized values (z-scores)\n *\n * @example\n * ```typescript\n * const arr = [1, 2, 3, 4, 5];\n * const standardized = array.standardize(arr);\n * // Mean = 3, StdDev \u2248 1.414\n * // Result \u2248 [-1.414, -0.707, 0, 0.707, 1.414]\n * ```\n *\n * @remarks\n * - Formula: z = (x - \u03BC) / \u03C3\n * - Result has mean of 0 and standard deviation of 1\n * - Useful for comparing values on different scales\n *\n * PineScript rules:\n * - \u03BC and \u03C3 are the population mean and standard deviation of the non-na elements, as `array.variance` (moment\n *   form); `na` elements stay `na`\n * - when \u03C3 is 0 (all values equal) every non-na element gives 1\n */\nexport function standardize(id: PineArray<float>): PineArray<float> {\n  const values = id.filter((v) => !Number.isNaN(v));\n  if (!values.length) {\n    return id.map(() => NaN);\n  }\n  const [p, q] = moments(values);\n  const mean = p / values.length;\n  const stdDev = Math.sqrt(Math.max(0, q / values.length - mean * mean));\n  if (stdDev === 0) {\n    return id.map((v) => (Number.isNaN(v) ? NaN : 1));\n  }\n  return id.map((v) => (Number.isNaN(v) ? NaN : (v - mean) / stdDev));\n}\n\n/**\n * New Type (User-Defined Type Array)\n *\n * Creates a new array of user-defined type elements.\n *\n * @param size - Initial size of array (default: 0)\n * @param initial_value - Initial value for all elements\n * @returns New array of user-defined type\n *\n * @example\n * ```typescript\n * // NOTE: User-defined types (UDTs) are not fully supported yet\n * // This is a placeholder for future implementation\n * const arr = array.newtype<MyType>(5);\n * ```\n *\n * @remarks\n * - **\u26A0\uFE0F LIMITED SUPPORT**: User-defined types (UDTs) require a type system\n *   that is not yet fully implemented in this library\n * - This function currently works like `new_array<T>()` for basic types\n * - Full UDT support will be added in a future version\n * - See PineScript documentation for UDT usage patterns\n */\nexport function newtype<T>(size: simple_int = 0, initial_value?: T): PineArray<T> {\n  // For now, this is just an alias for new_array\n  // Full UDT support requires implementing the type system\n  return new_array<T>(size, initial_value);\n}\n\n"],
+  "mappings": "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",
+  "names": ["size", "sum"]
 }

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

@@ -13,6 +13,7 @@
  *   call), which PineScript computes with a state kept between calls.
  * - {@link lowestByBar} / {@link highestByBar} / {@link linreg}: `ta.lowest` / `ta.highest` / `ta.linreg` in a
  *   conditional block, whose history is kept by bar (not by call).
+ * - {@link sum} / {@link sma}: `math.sum` / `ta.sma` in a `for` / `while` loop, called several times on one bar.
  *
  * Since PineScript v6, `and` / `or` are lazy: the right operand runs only when the left operand does not decide
  * the result. A ta.* call in the right operand of `a or b` runs on the bars where `a` is false, in `a and b` on the
@@ -67,8 +68,9 @@ export declare function crossunder(): (a: number, b: number) => boolean;
  */
 export declare function barssince(): (condition: boolean | number) => number;
 /**
- * One `ta.cross(a, b)` call site: compared with the last call where both arguments were not na; false before such
- * a call.
+ * One `ta.cross(a, b)` call site, rules of `ta.cross`: the site keeps the side of the last call where `a` was
+ * strictly above or strictly below `b` (none before such a call; equal values and na arguments do not change it),
+ * and is true when the arguments are strictly on the other side. False with an na argument.
  */
 export declare function cross(): (a: number, b: number) => boolean;
 /**
@@ -144,4 +146,81 @@ export declare function highestByBar(): (barIndex: number, value: number, length
  * ```
  */
 export declare function linreg(): (barIndex: number, value: number, length: number, offset?: number) => number;
+/**
+ * One `math.sum(source, length)` call site inside a `for` / `while` loop, called with `(barIndex, value, length)` on
+ * each call.
+ *
+ * PineScript rules (measured on calls in loops, 1 to 3 calls per bar, and bars without a call):
+ * - the call site keeps one history value per bar: the value of its last call on that bar
+ * - every call on a bar starts from the state of the earlier bars, so it gives the sum of its value and the last
+ *   `length - 1` kept values; the last call of the bar is the one kept for the later bars
+ * - the length can change from one call to the next (also on the same bar): each call first moves the kept sum to
+ *   its own length as `math.sum` with a series length does (Kahan steps of the raw values)
+ * - a bar without a call is not in the history (as a call in an `if` block)
+ * - the sum is the same compensated running sum as `math.sum` (bit for bit)
+ *
+ * An na value is skipped as in `math.sum` (it returns the sum of the last `length` earlier values); when it is the
+ * last call of a bar, the bar is not in the history (not measured).
+ *
+ * @example
+ * ```typescript
+ * // Pine:  for i = 0 to 2
+ * //            s = math.sum(close * (1 + 0.01 * i), 7)
+ * const site = callsite.sum();
+ * for (let b = 0; b < closes.length; b++) {
+ *   for (let i = 0; i <= 2; i++) {
+ *     const s = site(b, closes[b]! * (1 + 0.01 * i), 7);
+ *   }
+ * }
+ * ```
+ */
+export declare function sum(): (barIndex: number, value: number, length: number) => number;
+/**
+ * One `ta.sma(source, length)` call site inside a `for` / `while` loop, called with `(barIndex, value, length)` on
+ * each call: {@link sum} divided by the length (same rules).
+ *
+ * @example
+ * ```typescript
+ * // Pine:  evaluate(ratio) => ta.sma(gann(ratio), n)   // called once per ratio in a while loop
+ * const site = callsite.sma();
+ * for (let b = 0; b < closes.length; b++) {
+ *   for (const ratio of ratios) {
+ *     const avg = site(b, gann(b, ratio), n);
+ *   }
+ * }
+ * ```
+ */
+export declare function sma(): (barIndex: number, value: number, length: number) => number;
+/**
+ * One `ta.stdev(source, length, biased)` call site inside a `for` / `while` loop, called with
+ * `(barIndex, value, length, biased?)` on each call: the running sums of the values and of their squares follow the
+ * rules of {@link sum}; the result is computed from them as `ta.stdev` (bit for bit).
+ *
+ * @example
+ * ```typescript
+ * // Pine:  for len in lengths
+ * //            [mid, up, lo] = ta.bb(close, len, 2)
+ * const avgSite = callsite.sma();
+ * const devSite = callsite.stdev();
+ * for (let b = 0; b < closes.length; b++) {
+ *   for (const len of lengths) {
+ *     const mid = avgSite(b, closes[b]!, len);
+ *     const dev = devSite(b, closes[b]!, len);
+ *   }
+ * }
+ * ```
+ */
+export declare function stdev(): (barIndex: number, value: number, length: number, biased?: boolean) => number;
+/**
+ * One `math.random(min, max, seed)` call site: PineScript keeps one generator per call site, so two call sites
+ * with the same seed give the same sequence. Called with `(min?, max?)` once per bar.
+ *
+ * @example
+ * ```typescript
+ * // Pine: a = math.random(0, 1, 42), b = math.random(0, 1, 42)   // a == b on every bar
+ * const a = callsite.random(42);
+ * const b = callsite.random(42);
+ * ```
+ */
+export declare function random(seed: number): (min?: number, max?: number) => number;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/callsite/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAGhD;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,GAAG,OAAO,EACnD,MAAM,EAAE,SAAS,CAAC,OAAO,GAAG,MAAM,CAAC,EACnC,EAAE,EAAE,CAAC,GAAG,MAAM,EAAE,MAAM,EAAE,EAAE,KAAK,SAAS,CAAC,CAAC,CAAC,EAC3C,GAAG,OAAO,EAAE,MAAM,EAAE,GACnB,KAAK,CAAC,CAAC,GAAG,MAAM,CAAC,CASnB;AAmBD;;;GAGG;AACH,wBAAgB,SAAS,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,OAAO,CAE7D;AAED;;;GAGG;AACH,wBAAgB,UAAU,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,OAAO,CAE9D;AAED;;;GAGG;AACH,wBAAgB,SAAS,IAAI,CAAC,SAAS,EAAE,OAAO,GAAG,MAAM,KAAK,MAAM,CAOnE;AAED;;;GAGG;AACH,wBAAgB,KAAK,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,OAAO,CAEzD;AA2CD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,MAAM,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,CAElE;AAED;;;GAGG;AACH,wBAAgB,OAAO,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,CAEnE;AAgCD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,WAAW,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,CAEzF;AAED;;;;GAIG;AACH,wBAAgB,YAAY,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,CAE1F;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,MAAM,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,MAAM,CAUrG"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/callsite/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAKhD;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,GAAG,OAAO,EACnD,MAAM,EAAE,SAAS,CAAC,OAAO,GAAG,MAAM,CAAC,EACnC,EAAE,EAAE,CAAC,GAAG,MAAM,EAAE,MAAM,EAAE,EAAE,KAAK,SAAS,CAAC,CAAC,CAAC,EAC3C,GAAG,OAAO,EAAE,MAAM,EAAE,GACnB,KAAK,CAAC,CAAC,GAAG,MAAM,CAAC,CASnB;AAmBD;;;GAGG;AACH,wBAAgB,SAAS,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,OAAO,CAE7D;AAED;;;GAGG;AACH,wBAAgB,UAAU,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,OAAO,CAE9D;AAED;;;GAGG;AACH,wBAAgB,SAAS,IAAI,CAAC,SAAS,EAAE,OAAO,GAAG,MAAM,KAAK,MAAM,CAOnE;AAED;;;;GAIG;AACH,wBAAgB,KAAK,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,OAAO,CASzD;AA2CD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,MAAM,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,CAElE;AAED;;;GAGG;AACH,wBAAgB,OAAO,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,CAEnE;AAgCD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,WAAW,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,CAEzF;AAED;;;;GAIG;AACH,wBAAgB,YAAY,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,CAE1F;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,MAAM,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,MAAM,CAUrG;AAqCD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,GAAG,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,CAGjF;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,GAAG,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,CAGjF;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,KAAK,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,KAAK,MAAM,CAUrG;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,KAAK,MAAM,CAE3E"}

package/dist/cjs/callsite/index.js

@@ -27,10 +27,16 @@ __export(callsite_exports, {
   linreg: () => linreg,
   lowest: () => lowest,
   lowestByBar: () => lowestByBar,
+  random: () => random,
+  sma: () => sma,
+  stdev: () => stdev,
+  sum: () => sum,
   whenCalled: () => whenCalled
 });
 module.exports = __toCommonJS(callsite_exports);
 var import_ta = require("../ta/index.js");
+var import_running_sum = require("../ta/running-sum.js");
+var import_math = require("../math/index.js");
 function whenCalled(called, fn, ...sources) {
   const bars = [];
   for (let i = 0; i < called.length; i++) if (called[i]) bars.push(i);
@@ -68,7 +74,14 @@ function barssince() {
   };
 }
 function cross() {
-  return twoSeriesSite((a, b, pa, pb) => a > b && pa <= pb || a < b && pa >= pb);
+  let side = 0;
+  return (a, b) => {
+    if (Number.isNaN(a) || Number.isNaN(b)) return false;
+    const result = side < 0 && a > b || side > 0 && a < b;
+    if (a < b) side = -1;
+    else if (a > b) side = 1;
+    return result;
+  };
 }
 function extremeSite(isLowest) {
   const better = isLowest ? (a, b) => a < b : (a, b) => a > b;
@@ -160,4 +173,52 @@ function linreg() {
     return (0, import_ta.linreg)(window, len, offset)[len - 1];
   };
 }
+function loopSumSite(name, squares) {
+  const running = new import_running_sum.RunningSum();
+  const runningSq = new import_running_sum.RunningSum();
+  let lastBar = NaN;
+  let pending = false;
+  return (barIndex, value, length) => {
+    const len = Math.floor(length);
+    if (!(len >= 1)) throw new Error(`callsite.${name}: length must be at least 1 (got ${length})`);
+    if (barIndex !== lastBar) {
+      if (pending) {
+        running.commit();
+        if (squares) runningSq.commit();
+      }
+      pending = false;
+      lastBar = barIndex;
+    }
+    if ((0, import_running_sum.isNa)(value)) {
+      pending = false;
+      return [running.stepNa(len), squares ? runningSq.stepNa(len) : NaN];
+    }
+    const x = value;
+    const out = [running.step(x, len), squares ? runningSq.step(x * x, len) : NaN];
+    pending = true;
+    return out;
+  };
+}
+function sum() {
+  const site = loopSumSite("sum", false);
+  return (barIndex, value, length) => site(barIndex, value, length)[0];
+}
+function sma() {
+  const site = loopSumSite("sma", false);
+  return (barIndex, value, length) => site(barIndex, value, length)[0] / Math.floor(length);
+}
+function stdev() {
+  const site = loopSumSite("stdev", true);
+  return (barIndex, value, length, biased = true) => {
+    const len = Math.floor(length);
+    const [s, sq] = site(barIndex, value, length);
+    const mean = s / len;
+    const variance = biased ? sq / len - mean * mean : sq / (len - 1) - mean * s / (len - 1);
+    if (!biased && len <= 1) return NaN;
+    return Number.isNaN(variance) ? NaN : variance > 0 ? Math.sqrt(variance) : 0;
+  };
+}
+function random(seed) {
+  return (0, import_math.seededRandom)(seed);
+}
 //# sourceMappingURL=index.js.map

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/callsite/index.ts"],
-  "sourcesContent": ["/**\n * @fileoverview Per-call history of ta.* functions called in a conditional block.\n *\n * In PineScript, every ta.* call keeps its own history of the values it receives. A call inside\n * an `if` block receives values only on the bars where the block runs, so its history skips the\n * other bars: `ta.crossover(a, b)` is false on the first bar the block runs, and `ta.sma(x, 3)`\n * averages the last 3 values it received, not the last 3 bars.\n *\n * - {@link whenCalled}: vectorized, when the bars of the calls are known in advance.\n * - {@link crossover} / {@link crossunder} / {@link cross} / {@link barssince}: one stateful call site for bar\n *   loops, called only on the bars where the Pine call runs.\n * - {@link lowest} / {@link highest}: `ta.lowest` / `ta.highest` with a series length (a different length on each\n *   call), which PineScript computes with a state kept between calls.\n * - {@link lowestByBar} / {@link highestByBar} / {@link linreg}: `ta.lowest` / `ta.highest` / `ta.linreg` in a\n *   conditional block, whose history is kept by bar (not by call).\n *\n * Since PineScript v6, `and` / `or` are lazy: the right operand runs only when the left operand does not decide\n * the result. A ta.* call in the right operand of `a or b` runs on the bars where `a` is false, in `a and b` on the\n * bars where `a` is true, so it needs a call site too:\n *\n * ```typescript\n * // Pine:  longCond = longUp or (src > sig and ta.barssince(longUp) <= lookback)\n * const since = callsite.whenCalled(longUp.map((u, i) => !u && src[i] > sig[i]), (c) => taCore.barssince(c.map(Boolean)), longUp);\n * // ta.barssince(longUp) only runs where longUp is false: it never sees true and stays na\n * ```\n *\n * ```typescript\n * // Pine:  if inRange\n * //            buy = ta.crossover(cumRsi, 60)\n * const buy = callsite.whenCalled(inRange, (a) => taCore.crossover(a, a.map(() => 60)), cumRsi);\n *\n * // Same call in a bar loop\n * const buyCross = callsite.crossover();\n * for (let i = 0; i < n; i++) {\n *   if (inRange[i]) {\n *     const buy = buyCross(cumRsi[i], 60);\n *   }\n * }\n * ```\n *\n * @module callsite\n */\n\nimport type { Source } from '../types/index.js';\nimport { linreg as linregSeries } from '../ta/index.js';\n\n/**\n * Runs `fn` on the bars where `called` is true only, like a ta.* call inside an `if` block.\n * `fn` receives the values of `sources` on those bars, in order; its results are placed back on\n * the same bars. The other bars get na (NaN).\n *\n * @param called - true (or non-zero) on the bars where the call runs\n * @param fn - the calculation, for example `(x) => taCore.sma(x, 3)`\n * @param sources - the arguments of the call, one value per chart bar\n */\nexport function whenCalled<T extends number | boolean>(\n  called: ArrayLike<boolean | number>,\n  fn: (...values: number[][]) => ArrayLike<T>,\n  ...sources: Source[]\n): Array<T | number> {\n  const bars: number[] = [];\n  for (let i = 0; i < called.length; i++) if (called[i]) bars.push(i);\n  const result = fn(...sources.map(s => bars.map(i => s[i] ?? NaN)));\n  const out = new Array<T | number>(called.length).fill(NaN);\n  bars.forEach((bar, k) => {\n    out[bar] = result[k]!;\n  });\n  return out;\n}\n\n/**\n * A call site that keeps the arguments of the last call where both were not na (na before such a call), as\n * ta.crossover / ta.crossunder / ta.cross.\n */\nfunction twoSeriesSite(test: (a: number, b: number, prevA: number, prevB: number) => boolean) {\n  let prevA = NaN;\n  let prevB = NaN;\n  return (a: number, b: number): boolean => {\n    const result = test(a, b, prevA, prevB);\n    if (!Number.isNaN(a) && !Number.isNaN(b)) {\n      prevA = a;\n      prevB = b;\n    }\n    return result;\n  };\n}\n\n/**\n * One `ta.crossover(a, b)` call site: compared with the last call where both arguments were not na; false before\n * such a call.\n */\nexport function crossover(): (a: number, b: number) => boolean {\n  return twoSeriesSite((a, b, pa, pb) => a > b && pa <= pb);\n}\n\n/**\n * One `ta.crossunder(a, b)` call site: compared with the last call where both arguments were not na; false before\n * such a call.\n */\nexport function crossunder(): (a: number, b: number) => boolean {\n  return twoSeriesSite((a, b, pa, pb) => a < b && pa >= pb);\n}\n\n/**\n * One `ta.barssince(condition)` call site: the number of calls since the condition was true on a call (0 on that\n * call), na before the first true condition. An na condition counts as false.\n */\nexport function barssince(): (condition: boolean | number) => number {\n  let count = NaN;\n  return (condition) => {\n    if (condition && !Number.isNaN(condition)) count = 0;\n    else if (!Number.isNaN(count)) count++;\n    return count;\n  };\n}\n\n/**\n * One `ta.cross(a, b)` call site: compared with the last call where both arguments were not na; false before such\n * a call.\n */\nexport function cross(): (a: number, b: number) => boolean {\n  return twoSeriesSite((a, b, pa, pb) => (a > b && pa <= pb) || (a < b && pa >= pb));\n}\n\n/** One `ta.lowest` / `ta.highest` call site with a series length; rules in {@link lowest}. */\nfunction extremeSite(isLowest: boolean): (value: number, length: number) => number {\n  const better = isLowest ? (a: number, b: number) => a < b : (a: number, b: number) => a > b;\n  const values: number[] = [];\n  let extreme = NaN;\n  let extremeAt = -1;\n  let prevLength = NaN;\n  const keep = (v: number, at: number) => {\n    extreme = v;\n    extremeAt = at;\n  };\n  const rescan = (i: number, length: number) => {\n    extreme = NaN;\n    for (let b = i; b > i - length && b >= 0; b--) {\n      const v = values[b]!;\n      if (!Number.isNaN(v) && (Number.isNaN(extreme) || !better(extreme, v))) keep(v, b);\n    }\n  };\n  return (value, length) => {\n    const i = values.length;\n    values.push(value);\n    if (Number.isNaN(value)) {\n      extreme = NaN;\n      prevLength = length;\n      return NaN;\n    }\n    if (length > prevLength) {\n      const from = Math.max(0, i - length + 1);\n      const to = Math.max(0, i - prevLength + 1);\n      if (values.slice(from, to).some(Number.isNaN)) keep(value, i);\n      else {\n        for (let b = from; b < to; b++) if (Number.isNaN(extreme) || better(values[b]!, extreme)) keep(values[b]!, b);\n        if (Number.isNaN(extreme) || better(value, extreme)) keep(value, i);\n      }\n    } else if (length < prevLength || Number.isNaN(extreme) || i - extremeAt >= length) rescan(i, length);\n    else if (better(value, extreme)) keep(value, i);\n    prevLength = length;\n    return i < length - 1 ? NaN : extreme;\n  };\n}\n\n/**\n * One `ta.lowest(source, length)` call site with a series length (a different length on each call), called with\n * `(value, length)`.\n *\n * PineScript rules (measured with a length that changes on each bar):\n * - the extreme is kept with its bar; a new value that passes it replaces it; when the kept extreme is `length`\n *   calls old, the last `length` values are scanned again (na skipped, the oldest wins a tie)\n * - a length smaller than on the previous call: the last `length` values are scanned again\n * - a length larger than on the previous call: the values that enter the window at its old end are compared with the\n *   extreme; when one of them is na, the extreme restarts from the current value (the values in between are not read)\n * - an na value gives na and resets the extreme; na before call `length - 1`\n *\n * @example\n * ```typescript\n * // Pine:  lowPrice = ta.lowest(close[1], lookback)   // lookback changes per bar\n * const lowPrice = callsite.lowest();\n * const out = closes.map((_, i) => lowPrice(i > 0 ? closes[i - 1]! : NaN, lookback[i]!));\n * ```\n */\nexport function lowest(): (value: number, length: number) => number {\n  return extremeSite(true);\n}\n\n/**\n * One `ta.highest(source, length)` call site with a series length (a different length on each call), called with\n * `(value, length)`. Same rules as {@link lowest}.\n */\nexport function highest(): (value: number, length: number) => number {\n  return extremeSite(false);\n}\n\n/** One `ta.lowest` / `ta.highest` call site whose history is kept by bar; rules in {@link lowestByBar}. */\nfunction extremeByBarSite(isLowest: boolean): (barIndex: number, value: number, length: number) => number {\n  const better = isLowest ? (a: number, b: number) => a < b : (a: number, b: number) => a > b;\n  let ring: number[] = [];\n  let extreme = NaN;\n  let extremeAt = -1;\n  return (barIndex, value, length) => {\n    const len = Math.floor(length);\n    if (ring.length !== len + 1) {\n      ring = new Array<number>(len + 1).fill(0);\n      extreme = NaN;\n    }\n    ring[barIndex % (len + 1)] = value;\n    if (Number.isNaN(extreme) || better(value, extreme)) {\n      extreme = value;\n      extremeAt = barIndex;\n    } else if (barIndex - extremeAt >= len) {\n      extreme = NaN;\n      for (let b = barIndex - len + 1; b <= barIndex; b++) {\n        const v = ring[b % (len + 1)]!;\n        if (!Number.isNaN(v) && (Number.isNaN(extreme) || better(v, extreme))) {\n          extreme = v;\n          extremeAt = b;\n        }\n      }\n    }\n    return barIndex < len - 1 ? NaN : extreme;\n  };\n}\n\n/**\n * One `ta.lowest(source, length)` call site in a conditional block whose history is kept by bar (not by call), called\n * with `(barIndex, value, length)` on the bars where the Pine call runs.\n *\n * PineScript rules (measured on a call in a ternary branch, length 6):\n * - the values are kept in a ring of `length + 1` slots indexed by the bar index, filled with 0 at the start and\n *   written only on the bars where the call runs: a bar before the first call counts as 0, and a bar without a call\n *   holds the value of the call `length + 1` bars earlier (0 if there was none)\n * - on a call, the value replaces the kept extreme when there is none or when it is strictly lower; only otherwise,\n *   when the kept extreme is `length` bars old, the last `length` bars are read again from the ring (the oldest bar\n *   wins a tie)\n * - na before bar `length - 1` (by bar, not by call)\n *\n * {@link lowest} keeps the history by call instead; both rules were measured, on different scripts.\n *\n * @example\n * ```typescript\n * // Pine:  lo = cond ? ta.lowest(low, 6) : na\n * const site = callsite.lowestByBar();\n * const lo = lows.map((v, i) => (cond[i] ? site(i, v, 6) : NaN));\n * ```\n */\nexport function lowestByBar(): (barIndex: number, value: number, length: number) => number {\n  return extremeByBarSite(true);\n}\n\n/**\n * One `ta.highest(source, length)` call site in a conditional block whose history is kept by bar, called with\n * `(barIndex, value, length)`. Same rules as {@link lowestByBar} (a value replaces the kept extreme when it is\n * strictly higher).\n */\nexport function highestByBar(): (barIndex: number, value: number, length: number) => number {\n  return extremeByBarSite(false);\n}\n\n/**\n * One `ta.linreg(source, length, offset)` call site in a conditional block, called with\n * `(barIndex, value, length, offset)` on the bars where the Pine call runs.\n *\n * PineScript rules (measured): `ta.linreg` keeps the values it receives in a ring of `length + 1` slots indexed by the\n * bar index, filled with 0 at the start and written only on the bars where it is called. The window is read from the\n * ring for the last `length` bars: a bar before the first call counts as 0, and a bar without a call holds the value of\n * the call `length + 1` bars earlier (0 if there was none). The result is na before bar `length - 1`. Called on every\n * bar, it equals `ta.linreg`.\n *\n * @example\n * ```typescript\n * // Pine:  if bar_index >= 20\n * //            a := ta.linreg(close, 10, 0)\n * const site = callsite.linreg();\n * const a = closes.map((c, i) => (i >= 20 ? site(i, c, 10, 0) : NaN));\n * ```\n */\nexport function linreg(): (barIndex: number, value: number, length: number, offset?: number) => number {\n  let ring: number[] = [];\n  return (barIndex, value, length, offset = 0) => {\n    const len = Math.floor(length);\n    if (ring.length !== len + 1) ring = new Array<number>(len + 1).fill(0);\n    ring[barIndex % (len + 1)] = value;\n    if (barIndex < len - 1) return NaN;\n    const window = Array.from({ length: len }, (_, k) => ring[(barIndex - len + 1 + k) % (len + 1)]!);\n    return linregSeries(window, len, offset)[len - 1]!;\n  };\n}\n\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA4CA,gBAAuC;AAWhC,SAAS,WACd,QACA,OACG,SACgB;AACnB,QAAM,OAAiB,CAAC;AACxB,WAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,IAAK,KAAI,OAAO,CAAC,EAAG,MAAK,KAAK,CAAC;AAClE,QAAM,SAAS,GAAG,GAAG,QAAQ,IAAI,OAAK,KAAK,IAAI,OAAK,EAAE,CAAC,KAAK,GAAG,CAAC,CAAC;AACjE,QAAM,MAAM,IAAI,MAAkB,OAAO,MAAM,EAAE,KAAK,GAAG;AACzD,OAAK,QAAQ,CAAC,KAAK,MAAM;AACvB,QAAI,GAAG,IAAI,OAAO,CAAC;AAAA,EACrB,CAAC;AACD,SAAO;AACT;AAMA,SAAS,cAAc,MAAuE;AAC5F,MAAI,QAAQ;AACZ,MAAI,QAAQ;AACZ,SAAO,CAAC,GAAW,MAAuB;AACxC,UAAM,SAAS,KAAK,GAAG,GAAG,OAAO,KAAK;AACtC,QAAI,CAAC,OAAO,MAAM,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,GAAG;AACxC,cAAQ;AACR,cAAQ;AAAA,IACV;AACA,WAAO;AAAA,EACT;AACF;AAMO,SAAS,YAA+C;AAC7D,SAAO,cAAc,CAAC,GAAG,GAAG,IAAI,OAAO,IAAI,KAAK,MAAM,EAAE;AAC1D;AAMO,SAAS,aAAgD;AAC9D,SAAO,cAAc,CAAC,GAAG,GAAG,IAAI,OAAO,IAAI,KAAK,MAAM,EAAE;AAC1D;AAMO,SAAS,YAAqD;AACnE,MAAI,QAAQ;AACZ,SAAO,CAAC,cAAc;AACpB,QAAI,aAAa,CAAC,OAAO,MAAM,SAAS,EAAG,SAAQ;AAAA,aAC1C,CAAC,OAAO,MAAM,KAAK,EAAG;AAC/B,WAAO;AAAA,EACT;AACF;AAMO,SAAS,QAA2C;AACzD,SAAO,cAAc,CAAC,GAAG,GAAG,IAAI,OAAQ,IAAI,KAAK,MAAM,MAAQ,IAAI,KAAK,MAAM,EAAG;AACnF;AAGA,SAAS,YAAY,UAA8D;AACjF,QAAM,SAAS,WAAW,CAAC,GAAW,MAAc,IAAI,IAAI,CAAC,GAAW,MAAc,IAAI;AAC1F,QAAM,SAAmB,CAAC;AAC1B,MAAI,UAAU;AACd,MAAI,YAAY;AAChB,MAAI,aAAa;AACjB,QAAM,OAAO,CAAC,GAAW,OAAe;AACtC,cAAU;AACV,gBAAY;AAAA,EACd;AACA,QAAM,SAAS,CAAC,GAAW,WAAmB;AAC5C,cAAU;AACV,aAAS,IAAI,GAAG,IAAI,IAAI,UAAU,KAAK,GAAG,KAAK;AAC7C,YAAM,IAAI,OAAO,CAAC;AAClB,UAAI,CAAC,OAAO,MAAM,CAAC,MAAM,OAAO,MAAM,OAAO,KAAK,CAAC,OAAO,SAAS,CAAC,GAAI,MAAK,GAAG,CAAC;AAAA,IACnF;AAAA,EACF;AACA,SAAO,CAAC,OAAO,WAAW;AACxB,UAAM,IAAI,OAAO;AACjB,WAAO,KAAK,KAAK;AACjB,QAAI,OAAO,MAAM,KAAK,GAAG;AACvB,gBAAU;AACV,mBAAa;AACb,aAAO;AAAA,IACT;AACA,QAAI,SAAS,YAAY;AACvB,YAAM,OAAO,KAAK,IAAI,GAAG,IAAI,SAAS,CAAC;AACvC,YAAM,KAAK,KAAK,IAAI,GAAG,IAAI,aAAa,CAAC;AACzC,UAAI,OAAO,MAAM,MAAM,EAAE,EAAE,KAAK,OAAO,KAAK,EAAG,MAAK,OAAO,CAAC;AAAA,WACvD;AACH,iBAAS,IAAI,MAAM,IAAI,IAAI,IAAK,KAAI,OAAO,MAAM,OAAO,KAAK,OAAO,OAAO,CAAC,GAAI,OAAO,EAAG,MAAK,OAAO,CAAC,GAAI,CAAC;AAC5G,YAAI,OAAO,MAAM,OAAO,KAAK,OAAO,OAAO,OAAO,EAAG,MAAK,OAAO,CAAC;AAAA,MACpE;AAAA,IACF,WAAW,SAAS,cAAc,OAAO,MAAM,OAAO,KAAK,IAAI,aAAa,OAAQ,QAAO,GAAG,MAAM;AAAA,aAC3F,OAAO,OAAO,OAAO,EAAG,MAAK,OAAO,CAAC;AAC9C,iBAAa;AACb,WAAO,IAAI,SAAS,IAAI,MAAM;AAAA,EAChC;AACF;AAqBO,SAAS,SAAoD;AAClE,SAAO,YAAY,IAAI;AACzB;AAMO,SAAS,UAAqD;AACnE,SAAO,YAAY,KAAK;AAC1B;AAGA,SAAS,iBAAiB,UAAgF;AACxG,QAAM,SAAS,WAAW,CAAC,GAAW,MAAc,IAAI,IAAI,CAAC,GAAW,MAAc,IAAI;AAC1F,MAAI,OAAiB,CAAC;AACtB,MAAI,UAAU;AACd,MAAI,YAAY;AAChB,SAAO,CAAC,UAAU,OAAO,WAAW;AAClC,UAAM,MAAM,KAAK,MAAM,MAAM;AAC7B,QAAI,KAAK,WAAW,MAAM,GAAG;AAC3B,aAAO,IAAI,MAAc,MAAM,CAAC,EAAE,KAAK,CAAC;AACxC,gBAAU;AAAA,IACZ;AACA,SAAK,YAAY,MAAM,EAAE,IAAI;AAC7B,QAAI,OAAO,MAAM,OAAO,KAAK,OAAO,OAAO,OAAO,GAAG;AACnD,gBAAU;AACV,kBAAY;AAAA,IACd,WAAW,WAAW,aAAa,KAAK;AACtC,gBAAU;AACV,eAAS,IAAI,WAAW,MAAM,GAAG,KAAK,UAAU,KAAK;AACnD,cAAM,IAAI,KAAK,KAAK,MAAM,EAAE;AAC5B,YAAI,CAAC,OAAO,MAAM,CAAC,MAAM,OAAO,MAAM,OAAO,KAAK,OAAO,GAAG,OAAO,IAAI;AACrE,oBAAU;AACV,sBAAY;AAAA,QACd;AAAA,MACF;AAAA,IACF;AACA,WAAO,WAAW,MAAM,IAAI,MAAM;AAAA,EACpC;AACF;AAwBO,SAAS,cAA2E;AACzF,SAAO,iBAAiB,IAAI;AAC9B;AAOO,SAAS,eAA4E;AAC1F,SAAO,iBAAiB,KAAK;AAC/B;AAoBO,SAAS,SAAuF;AACrG,MAAI,OAAiB,CAAC;AACtB,SAAO,CAAC,UAAU,OAAO,QAAQ,SAAS,MAAM;AAC9C,UAAM,MAAM,KAAK,MAAM,MAAM;AAC7B,QAAI,KAAK,WAAW,MAAM,EAAG,QAAO,IAAI,MAAc,MAAM,CAAC,EAAE,KAAK,CAAC;AACrE,SAAK,YAAY,MAAM,EAAE,IAAI;AAC7B,QAAI,WAAW,MAAM,EAAG,QAAO;AAC/B,UAAM,SAAS,MAAM,KAAK,EAAE,QAAQ,IAAI,GAAG,CAAC,GAAG,MAAM,MAAM,WAAW,MAAM,IAAI,MAAM,MAAM,EAAE,CAAE;AAChG,eAAO,UAAAA,QAAa,QAAQ,KAAK,MAAM,EAAE,MAAM,CAAC;AAAA,EAClD;AACF;",
+  "sourcesContent": ["/**\n * @fileoverview Per-call history of ta.* functions called in a conditional block.\n *\n * In PineScript, every ta.* call keeps its own history of the values it receives. A call inside\n * an `if` block receives values only on the bars where the block runs, so its history skips the\n * other bars: `ta.crossover(a, b)` is false on the first bar the block runs, and `ta.sma(x, 3)`\n * averages the last 3 values it received, not the last 3 bars.\n *\n * - {@link whenCalled}: vectorized, when the bars of the calls are known in advance.\n * - {@link crossover} / {@link crossunder} / {@link cross} / {@link barssince}: one stateful call site for bar\n *   loops, called only on the bars where the Pine call runs.\n * - {@link lowest} / {@link highest}: `ta.lowest` / `ta.highest` with a series length (a different length on each\n *   call), which PineScript computes with a state kept between calls.\n * - {@link lowestByBar} / {@link highestByBar} / {@link linreg}: `ta.lowest` / `ta.highest` / `ta.linreg` in a\n *   conditional block, whose history is kept by bar (not by call).\n * - {@link sum} / {@link sma}: `math.sum` / `ta.sma` in a `for` / `while` loop, called several times on one bar.\n *\n * Since PineScript v6, `and` / `or` are lazy: the right operand runs only when the left operand does not decide\n * the result. A ta.* call in the right operand of `a or b` runs on the bars where `a` is false, in `a and b` on the\n * bars where `a` is true, so it needs a call site too:\n *\n * ```typescript\n * // Pine:  longCond = longUp or (src > sig and ta.barssince(longUp) <= lookback)\n * const since = callsite.whenCalled(longUp.map((u, i) => !u && src[i] > sig[i]), (c) => taCore.barssince(c.map(Boolean)), longUp);\n * // ta.barssince(longUp) only runs where longUp is false: it never sees true and stays na\n * ```\n *\n * ```typescript\n * // Pine:  if inRange\n * //            buy = ta.crossover(cumRsi, 60)\n * const buy = callsite.whenCalled(inRange, (a) => taCore.crossover(a, a.map(() => 60)), cumRsi);\n *\n * // Same call in a bar loop\n * const buyCross = callsite.crossover();\n * for (let i = 0; i < n; i++) {\n *   if (inRange[i]) {\n *     const buy = buyCross(cumRsi[i], 60);\n *   }\n * }\n * ```\n *\n * @module callsite\n */\n\nimport type { Source } from '../types/index.js';\nimport { linreg as linregSeries } from '../ta/index.js';\nimport { RunningSum, isNa } from '../ta/running-sum.js';\nimport { seededRandom } from '../math/index.js';\n\n/**\n * Runs `fn` on the bars where `called` is true only, like a ta.* call inside an `if` block.\n * `fn` receives the values of `sources` on those bars, in order; its results are placed back on\n * the same bars. The other bars get na (NaN).\n *\n * @param called - true (or non-zero) on the bars where the call runs\n * @param fn - the calculation, for example `(x) => taCore.sma(x, 3)`\n * @param sources - the arguments of the call, one value per chart bar\n */\nexport function whenCalled<T extends number | boolean>(\n  called: ArrayLike<boolean | number>,\n  fn: (...values: number[][]) => ArrayLike<T>,\n  ...sources: Source[]\n): Array<T | number> {\n  const bars: number[] = [];\n  for (let i = 0; i < called.length; i++) if (called[i]) bars.push(i);\n  const result = fn(...sources.map(s => bars.map(i => s[i] ?? NaN)));\n  const out = new Array<T | number>(called.length).fill(NaN);\n  bars.forEach((bar, k) => {\n    out[bar] = result[k]!;\n  });\n  return out;\n}\n\n/**\n * A call site that keeps the arguments of the last call where both were not na (na before such a call), as\n * ta.crossover / ta.crossunder / ta.cross.\n */\nfunction twoSeriesSite(test: (a: number, b: number, prevA: number, prevB: number) => boolean) {\n  let prevA = NaN;\n  let prevB = NaN;\n  return (a: number, b: number): boolean => {\n    const result = test(a, b, prevA, prevB);\n    if (!Number.isNaN(a) && !Number.isNaN(b)) {\n      prevA = a;\n      prevB = b;\n    }\n    return result;\n  };\n}\n\n/**\n * One `ta.crossover(a, b)` call site: compared with the last call where both arguments were not na; false before\n * such a call.\n */\nexport function crossover(): (a: number, b: number) => boolean {\n  return twoSeriesSite((a, b, pa, pb) => a > b && pa <= pb);\n}\n\n/**\n * One `ta.crossunder(a, b)` call site: compared with the last call where both arguments were not na; false before\n * such a call.\n */\nexport function crossunder(): (a: number, b: number) => boolean {\n  return twoSeriesSite((a, b, pa, pb) => a < b && pa >= pb);\n}\n\n/**\n * One `ta.barssince(condition)` call site: the number of calls since the condition was true on a call (0 on that\n * call), na before the first true condition. An na condition counts as false.\n */\nexport function barssince(): (condition: boolean | number) => number {\n  let count = NaN;\n  return (condition) => {\n    if (condition && !Number.isNaN(condition)) count = 0;\n    else if (!Number.isNaN(count)) count++;\n    return count;\n  };\n}\n\n/**\n * One `ta.cross(a, b)` call site, rules of `ta.cross`: the site keeps the side of the last call where `a` was\n * strictly above or strictly below `b` (none before such a call; equal values and na arguments do not change it),\n * and is true when the arguments are strictly on the other side. False with an na argument.\n */\nexport function cross(): (a: number, b: number) => boolean {\n  let side = 0; // -1: last strictly below, 1: last strictly above, 0: none yet\n  return (a, b) => {\n    if (Number.isNaN(a) || Number.isNaN(b)) return false;\n    const result = (side < 0 && a > b) || (side > 0 && a < b);\n    if (a < b) side = -1;\n    else if (a > b) side = 1;\n    return result;\n  };\n}\n\n/** One `ta.lowest` / `ta.highest` call site with a series length; rules in {@link lowest}. */\nfunction extremeSite(isLowest: boolean): (value: number, length: number) => number {\n  const better = isLowest ? (a: number, b: number) => a < b : (a: number, b: number) => a > b;\n  const values: number[] = [];\n  let extreme = NaN;\n  let extremeAt = -1;\n  let prevLength = NaN;\n  const keep = (v: number, at: number) => {\n    extreme = v;\n    extremeAt = at;\n  };\n  const rescan = (i: number, length: number) => {\n    extreme = NaN;\n    for (let b = i; b > i - length && b >= 0; b--) {\n      const v = values[b]!;\n      if (!Number.isNaN(v) && (Number.isNaN(extreme) || !better(extreme, v))) keep(v, b);\n    }\n  };\n  return (value, length) => {\n    const i = values.length;\n    values.push(value);\n    if (Number.isNaN(value)) {\n      extreme = NaN;\n      prevLength = length;\n      return NaN;\n    }\n    if (length > prevLength) {\n      const from = Math.max(0, i - length + 1);\n      const to = Math.max(0, i - prevLength + 1);\n      if (values.slice(from, to).some(Number.isNaN)) keep(value, i);\n      else {\n        for (let b = from; b < to; b++) if (Number.isNaN(extreme) || better(values[b]!, extreme)) keep(values[b]!, b);\n        if (Number.isNaN(extreme) || better(value, extreme)) keep(value, i);\n      }\n    } else if (length < prevLength || Number.isNaN(extreme) || i - extremeAt >= length) rescan(i, length);\n    else if (better(value, extreme)) keep(value, i);\n    prevLength = length;\n    return i < length - 1 ? NaN : extreme;\n  };\n}\n\n/**\n * One `ta.lowest(source, length)` call site with a series length (a different length on each call), called with\n * `(value, length)`.\n *\n * PineScript rules (measured with a length that changes on each bar):\n * - the extreme is kept with its bar; a new value that passes it replaces it; when the kept extreme is `length`\n *   calls old, the last `length` values are scanned again (na skipped, the oldest wins a tie)\n * - a length smaller than on the previous call: the last `length` values are scanned again\n * - a length larger than on the previous call: the values that enter the window at its old end are compared with the\n *   extreme; when one of them is na, the extreme restarts from the current value (the values in between are not read)\n * - an na value gives na and resets the extreme; na before call `length - 1`\n *\n * @example\n * ```typescript\n * // Pine:  lowPrice = ta.lowest(close[1], lookback)   // lookback changes per bar\n * const lowPrice = callsite.lowest();\n * const out = closes.map((_, i) => lowPrice(i > 0 ? closes[i - 1]! : NaN, lookback[i]!));\n * ```\n */\nexport function lowest(): (value: number, length: number) => number {\n  return extremeSite(true);\n}\n\n/**\n * One `ta.highest(source, length)` call site with a series length (a different length on each call), called with\n * `(value, length)`. Same rules as {@link lowest}.\n */\nexport function highest(): (value: number, length: number) => number {\n  return extremeSite(false);\n}\n\n/** One `ta.lowest` / `ta.highest` call site whose history is kept by bar; rules in {@link lowestByBar}. */\nfunction extremeByBarSite(isLowest: boolean): (barIndex: number, value: number, length: number) => number {\n  const better = isLowest ? (a: number, b: number) => a < b : (a: number, b: number) => a > b;\n  let ring: number[] = [];\n  let extreme = NaN;\n  let extremeAt = -1;\n  return (barIndex, value, length) => {\n    const len = Math.floor(length);\n    if (ring.length !== len + 1) {\n      ring = new Array<number>(len + 1).fill(0);\n      extreme = NaN;\n    }\n    ring[barIndex % (len + 1)] = value;\n    if (Number.isNaN(extreme) || better(value, extreme)) {\n      extreme = value;\n      extremeAt = barIndex;\n    } else if (barIndex - extremeAt >= len) {\n      extreme = NaN;\n      for (let b = barIndex - len + 1; b <= barIndex; b++) {\n        const v = ring[b % (len + 1)]!;\n        if (!Number.isNaN(v) && (Number.isNaN(extreme) || better(v, extreme))) {\n          extreme = v;\n          extremeAt = b;\n        }\n      }\n    }\n    return barIndex < len - 1 ? NaN : extreme;\n  };\n}\n\n/**\n * One `ta.lowest(source, length)` call site in a conditional block whose history is kept by bar (not by call), called\n * with `(barIndex, value, length)` on the bars where the Pine call runs.\n *\n * PineScript rules (measured on a call in a ternary branch, length 6):\n * - the values are kept in a ring of `length + 1` slots indexed by the bar index, filled with 0 at the start and\n *   written only on the bars where the call runs: a bar before the first call counts as 0, and a bar without a call\n *   holds the value of the call `length + 1` bars earlier (0 if there was none)\n * - on a call, the value replaces the kept extreme when there is none or when it is strictly lower; only otherwise,\n *   when the kept extreme is `length` bars old, the last `length` bars are read again from the ring (the oldest bar\n *   wins a tie)\n * - na before bar `length - 1` (by bar, not by call)\n *\n * {@link lowest} keeps the history by call instead; both rules were measured, on different scripts.\n *\n * @example\n * ```typescript\n * // Pine:  lo = cond ? ta.lowest(low, 6) : na\n * const site = callsite.lowestByBar();\n * const lo = lows.map((v, i) => (cond[i] ? site(i, v, 6) : NaN));\n * ```\n */\nexport function lowestByBar(): (barIndex: number, value: number, length: number) => number {\n  return extremeByBarSite(true);\n}\n\n/**\n * One `ta.highest(source, length)` call site in a conditional block whose history is kept by bar, called with\n * `(barIndex, value, length)`. Same rules as {@link lowestByBar} (a value replaces the kept extreme when it is\n * strictly higher).\n */\nexport function highestByBar(): (barIndex: number, value: number, length: number) => number {\n  return extremeByBarSite(false);\n}\n\n/**\n * One `ta.linreg(source, length, offset)` call site in a conditional block, called with\n * `(barIndex, value, length, offset)` on the bars where the Pine call runs.\n *\n * PineScript rules (measured): `ta.linreg` keeps the values it receives in a ring of `length + 1` slots indexed by the\n * bar index, filled with 0 at the start and written only on the bars where it is called. The window is read from the\n * ring for the last `length` bars: a bar before the first call counts as 0, and a bar without a call holds the value of\n * the call `length + 1` bars earlier (0 if there was none). The result is na before bar `length - 1`. Called on every\n * bar, it equals `ta.linreg`.\n *\n * @example\n * ```typescript\n * // Pine:  if bar_index >= 20\n * //            a := ta.linreg(close, 10, 0)\n * const site = callsite.linreg();\n * const a = closes.map((c, i) => (i >= 20 ? site(i, c, 10, 0) : NaN));\n * ```\n */\nexport function linreg(): (barIndex: number, value: number, length: number, offset?: number) => number {\n  let ring: number[] = [];\n  return (barIndex, value, length, offset = 0) => {\n    const len = Math.floor(length);\n    if (ring.length !== len + 1) ring = new Array<number>(len + 1).fill(0);\n    ring[barIndex % (len + 1)] = value;\n    if (barIndex < len - 1) return NaN;\n    const window = Array.from({ length: len }, (_, k) => ring[(barIndex - len + 1 + k) % (len + 1)]!);\n    return linregSeries(window, len, offset)[len - 1]!;\n  };\n}\n\n\n/**\n * One `math.sum` call site in a loop; rules in {@link sum}. With `squares`, it also keeps the running sum of the\n * squared values (for {@link stdev}). Returns `[sum, sumOfSquares]` (NaN when not kept).\n */\nfunction loopSumSite(\n  name: string,\n  squares: boolean\n): (barIndex: number, value: number, length: number) => [number, number] {\n  const running = new RunningSum();\n  const runningSq = new RunningSum();\n  let lastBar = NaN;\n  let pending = false;\n  return (barIndex, value, length) => {\n    const len = Math.floor(length);\n    if (!(len >= 1)) throw new Error(`callsite.${name}: length must be at least 1 (got ${length})`);\n    if (barIndex !== lastBar) {\n      if (pending) {\n        running.commit();\n        if (squares) runningSq.commit();\n      }\n      pending = false;\n      lastBar = barIndex;\n    }\n    if (isNa(value)) {\n      pending = false;\n      return [running.stepNa(len), squares ? runningSq.stepNa(len) : NaN];\n    }\n    const x = value;\n    const out: [number, number] = [running.step(x, len), squares ? runningSq.step(x * x, len) : NaN];\n    pending = true;\n    return out;\n  };\n}\n\n/**\n * One `math.sum(source, length)` call site inside a `for` / `while` loop, called with `(barIndex, value, length)` on\n * each call.\n *\n * PineScript rules (measured on calls in loops, 1 to 3 calls per bar, and bars without a call):\n * - the call site keeps one history value per bar: the value of its last call on that bar\n * - every call on a bar starts from the state of the earlier bars, so it gives the sum of its value and the last\n *   `length - 1` kept values; the last call of the bar is the one kept for the later bars\n * - the length can change from one call to the next (also on the same bar): each call first moves the kept sum to\n *   its own length as `math.sum` with a series length does (Kahan steps of the raw values)\n * - a bar without a call is not in the history (as a call in an `if` block)\n * - the sum is the same compensated running sum as `math.sum` (bit for bit)\n *\n * An na value is skipped as in `math.sum` (it returns the sum of the last `length` earlier values); when it is the\n * last call of a bar, the bar is not in the history (not measured).\n *\n * @example\n * ```typescript\n * // Pine:  for i = 0 to 2\n * //            s = math.sum(close * (1 + 0.01 * i), 7)\n * const site = callsite.sum();\n * for (let b = 0; b < closes.length; b++) {\n *   for (let i = 0; i <= 2; i++) {\n *     const s = site(b, closes[b]! * (1 + 0.01 * i), 7);\n *   }\n * }\n * ```\n */\nexport function sum(): (barIndex: number, value: number, length: number) => number {\n  const site = loopSumSite('sum', false);\n  return (barIndex, value, length) => site(barIndex, value, length)[0];\n}\n\n/**\n * One `ta.sma(source, length)` call site inside a `for` / `while` loop, called with `(barIndex, value, length)` on\n * each call: {@link sum} divided by the length (same rules).\n *\n * @example\n * ```typescript\n * // Pine:  evaluate(ratio) => ta.sma(gann(ratio), n)   // called once per ratio in a while loop\n * const site = callsite.sma();\n * for (let b = 0; b < closes.length; b++) {\n *   for (const ratio of ratios) {\n *     const avg = site(b, gann(b, ratio), n);\n *   }\n * }\n * ```\n */\nexport function sma(): (barIndex: number, value: number, length: number) => number {\n  const site = loopSumSite('sma', false);\n  return (barIndex, value, length) => site(barIndex, value, length)[0] / Math.floor(length);\n}\n\n/**\n * One `ta.stdev(source, length, biased)` call site inside a `for` / `while` loop, called with\n * `(barIndex, value, length, biased?)` on each call: the running sums of the values and of their squares follow the\n * rules of {@link sum}; the result is computed from them as `ta.stdev` (bit for bit).\n *\n * @example\n * ```typescript\n * // Pine:  for len in lengths\n * //            [mid, up, lo] = ta.bb(close, len, 2)\n * const avgSite = callsite.sma();\n * const devSite = callsite.stdev();\n * for (let b = 0; b < closes.length; b++) {\n *   for (const len of lengths) {\n *     const mid = avgSite(b, closes[b]!, len);\n *     const dev = devSite(b, closes[b]!, len);\n *   }\n * }\n * ```\n */\nexport function stdev(): (barIndex: number, value: number, length: number, biased?: boolean) => number {\n  const site = loopSumSite('stdev', true);\n  return (barIndex, value, length, biased = true) => {\n    const len = Math.floor(length);\n    const [s, sq] = site(barIndex, value, length);\n    const mean = s / len;\n    const variance = biased ? sq / len - mean * mean : sq / (len - 1) - (mean * s) / (len - 1);\n    if (!biased && len <= 1) return NaN;\n    return Number.isNaN(variance) ? NaN : variance > 0 ? Math.sqrt(variance) : 0;\n  };\n}\n\n/**\n * One `math.random(min, max, seed)` call site: PineScript keeps one generator per call site, so two call sites\n * with the same seed give the same sequence. Called with `(min?, max?)` once per bar.\n *\n * @example\n * ```typescript\n * // Pine: a = math.random(0, 1, 42), b = math.random(0, 1, 42)   // a == b on every bar\n * const a = callsite.random(42);\n * const b = callsite.random(42);\n * ```\n */\nexport function random(seed: number): (min?: number, max?: number) => number {\n  return seededRandom(seed);\n}\n"],
+  "mappings": "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",
   "names": ["linregSeries"]
 }

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

@@ -72,7 +72,10 @@ export declare function from_hex(hex: string, transp?: simple_float): string;
  * - 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
+ *   opaque); an `na` transparency is fully transparent (measured: the colour is not na, its RGB is kept)
+ * - an `na` colour (null / undefined) gives black with the new transparency: `color.new(na, 30)` is
+ *   `rgba(0, 0, 0, 0.7)`, as PineScript does for an na colour variable (measured, #150). In PineScript, the constant
+ *   `color.new(color(na), 30)` is computed at compile time and stays na; a JS function cannot tell the two apart.
  *
  * @example
  * ```typescript
@@ -82,7 +85,7 @@ export declare function from_hex(hex: string, transp?: simple_float): string;
  * color.new_color(red, 100) // Returns: "rgba(255, 0, 0, 0)" - Fully transparent
  * ```
  */
-export declare function new_color(baseColor: color, transp: simple_float): string;
+export declare function new_color(baseColor: color | null | undefined, transp: simple_float): string;
 /**
  * Extracts the red component from a color.
  *
@@ -136,6 +139,7 @@ export declare function b(clr: color): int;
  * - 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
+ * - an `na` colour (null / undefined) is fully transparent: 100
  *
  * @example
  * ```typescript
@@ -144,7 +148,7 @@ export declare function b(clr: color): int;
  * color.t(color.rgb(255, 0, 0, 100)) // Returns: 100 (fully transparent)
  * ```
  */
-export declare function t(clr: color): float;
+export declare function t(clr: color | null | undefined): float;
 /**
  * Aqua/Cyan color constant
  * @constant {string} #00BCD4 - RGB(0, 188, 212)

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

@@ -1 +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"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,SAAS,CAAC,SAAS,EAAE,KAAK,GAAG,IAAI,GAAG,SAAS,EAAE,MAAM,EAAE,YAAY,GAAG,MAAM,CAK3F;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;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,CAAC,CAAC,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,SAAS,GAAG,KAAK,CAGtD;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,CA8BR;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAAE,SAAS,IAAI,GAAG,EAAE,CAAC"}

package/dist/cjs/color/index.js

@@ -67,6 +67,7 @@ function from_hex(hex, transp) {
   return rgb(r2, g2, b2, transp);
 }
 function new_color(baseColor, transp) {
+  if (baseColor === null || baseColor === void 0) return rgb(0, 0, 0, transp);
   const rgba = (0, import_parse.parseColor)(baseColor);
   return rgb(rgba.r, rgba.g, rgba.b, transp);
 }
@@ -80,6 +81,7 @@ function b(clr) {
   return (0, import_parse.parseColor)(clr).b;
 }
 function t(clr) {
+  if (clr === null || clr === void 0) return 100;
   return Math.round((1 - (0, import_parse.alphaByte)((0, import_parse.parseColor)(clr).a) / 255) * 100);
 }
 const aqua = "#00BCD4";
@@ -114,7 +116,10 @@ function from_gradient(value, bottom_value, top_value, bottom_color, top_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 scale = a / 255;
+  const w1 = c1.a / 255;
+  const w2 = c2.a / 255;
+  const mix = (x1, x2) => Math.floor((w1 * x1 * (1 - k) + w2 * x2 * k) / scale);
   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})`;