oakscriptjs 0.3.0 → 0.6.0

package/dist/index.mjs

@@ -1,7 +1,7 @@
 var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+var __export = (target, all7) => {
+  for (var name in all7)
+    __defProp(target, name, { get: all7[name], enumerable: true });
 };
 
 // src/types/index.ts
@@ -15,6 +15,7 @@ var xloc = {
 // src/ta/index.ts
 var ta_exports = {};
 __export(ta_exports, {
+  accdist: () => accdist,
   alma: () => alma,
   atr: () => atr,
   barssince: () => barssince,
@@ -37,6 +38,7 @@ __export(ta_exports, {
   highestbars: () => highestbars,
   hma: () => hma,
   ichimoku: () => ichimoku,
+  iii: () => iii,
   kc: () => kc,
   kcw: () => kcw,
   linreg: () => linreg,
@@ -49,12 +51,16 @@ __export(ta_exports, {
   min: () => min,
   mode: () => mode,
   mom: () => mom,
+  nvi: () => nvi,
+  obv: () => obv,
   percentile_linear_interpolation: () => percentile_linear_interpolation,
   percentile_nearest_rank: () => percentile_nearest_rank,
   percentrank: () => percentrank,
   pivot_point_levels: () => pivot_point_levels,
   pivothigh: () => pivothigh,
   pivotlow: () => pivotlow,
+  pvi: () => pvi,
+  pvt: () => pvt,
   range: () => range,
   rci: () => rci,
   rising: () => rising,
@@ -73,8 +79,10 @@ __export(ta_exports, {
   variance: () => variance,
   vwap: () => vwap,
   vwma: () => vwma,
+  wad: () => wad,
   wma: () => wma,
   wpr: () => wpr,
+  wvad: () => wvad,
   zigzag: () => zigzag
 });
 function sma(source, length2) {
@@ -174,23 +182,42 @@ function bb(series, length2, mult2) {
   }
   return [basis, upper2, lower2];
 }
-function stdev(source, length2) {
-  const result = [];
+function stdev(source, length2, biased = true) {
   const len = Math.floor(length2);
-  const avg4 = sma(source, len);
-  for (let i = 0; i < source.length; i++) {
-    if (i < len - 1) {
-      result.push(NaN);
-    } else {
-      let sumSquares = 0;
-      for (let j = 0; j < len; j++) {
-        const diff2 = source[i - j] - avg4[i];
-        sumSquares += diff2 * diff2;
-      }
-      result.push(Math.sqrt(sumSquares / len));
-    }
-  }
-  return result;
+  return source.map((_, i) => {
+    const values2 = lastValues(source, i, len);
+    if (!values2) return NaN;
+    const mean = values2.reduce((a, b2) => a + b2, 0) / len;
+    const squares = values2.reduce((a, b2) => a + (b2 - mean) * (b2 - mean), 0);
+    return Math.sqrt(squares / (biased ? len : len - 1));
+  });
+}
+function lastValues(source, i, length2) {
+  const values2 = [];
+  for (let j = i; j >= 0 && values2.length < length2; j--) {
+    const x = source[j];
+    if (!Number.isNaN(x)) values2.push(x);
+  }
+  return values2.length === length2 ? values2 : null;
+}
+function windowUntilNa(source, i, length2) {
+  const values2 = [];
+  for (let j = 0; j < length2 && i - j >= 0; j++) {
+    const x = source[i - j];
+    if (Number.isNaN(x)) break;
+    values2.push([x, -j]);
+  }
+  return values2;
+}
+function extremeOffset(source, length2, isHigher) {
+  return source.map((_, i) => {
+    if (i < length2 - 1) return NaN;
+    const w = windowUntilNa(source, i, length2);
+    if (w.length === 0) return 0;
+    let best = w[0];
+    for (const item of w) if (isHigher(item[0], best[0])) best = item;
+    return best[1];
+  });
 }
 function crossover(series1, series2) {
   const result = [];
@@ -369,47 +396,26 @@ function wma(source, length2) {
   return result;
 }
 function highest(source, length2) {
-  const result = [];
-  for (let i = 0; i < source.length; i++) {
-    if (i < length2 - 1) {
-      result.push(NaN);
-    } else {
-      let max6 = -Infinity;
-      for (let j = 0; j < length2; j++) {
-        if (!isNaN(source[i - j])) {
-          max6 = Math.max(max6, source[i - j]);
-        }
-      }
-      result.push(max6 === -Infinity ? NaN : max6);
-    }
-  }
-  return result;
+  return source.map((_, i) => {
+    if (i < length2 - 1) return NaN;
+    const w = windowUntilNa(source, i, length2);
+    return w.length ? Math.max(...w.map((x) => x[0])) : NaN;
+  });
 }
 function lowest(source, length2) {
-  const result = [];
-  for (let i = 0; i < source.length; i++) {
-    if (i < length2 - 1) {
-      result.push(NaN);
-    } else {
-      let min6 = Infinity;
-      for (let j = 0; j < length2; j++) {
-        if (!isNaN(source[i - j])) {
-          min6 = Math.min(min6, source[i - j]);
-        }
-      }
-      result.push(min6 === Infinity ? NaN : min6);
-    }
-  }
-  return result;
+  return source.map((_, i) => {
+    if (i < length2 - 1) return NaN;
+    const w = windowUntilNa(source, i, length2);
+    return w.length ? Math.min(...w.map((x) => x[0])) : NaN;
+  });
 }
 function cum(source) {
-  const result = [];
   let sum4 = 0;
-  for (let i = 0; i < source.length; i++) {
-    sum4 += source[i];
-    result.push(sum4);
-  }
-  return result;
+  return source.map((v) => {
+    if (Number.isNaN(v)) return NaN;
+    sum4 += v;
+    return sum4;
+  });
 }
 function cross(source1, source2) {
   const result = [];
@@ -538,21 +544,21 @@ function median(source, length2) {
     if (i < length2 - 1) {
       result.push(NaN);
     } else {
-      const values = [];
+      const values2 = [];
       for (let j = 0; j < length2; j++) {
         if (!isNaN(source[i - j])) {
-          values.push(source[i - j]);
+          values2.push(source[i - j]);
         }
       }
-      if (values.length === 0) {
+      if (values2.length === 0) {
         result.push(NaN);
       } else {
-        values.sort((a, b2) => a - b2);
-        const mid = Math.floor(values.length / 2);
-        if (values.length % 2 === 0) {
-          result.push((values[mid - 1] + values[mid]) / 2);
+        values2.sort((a, b2) => a - b2);
+        const mid = Math.floor(values2.length / 2);
+        if (values2.length % 2 === 0) {
+          result.push((values2[mid - 1] + values2[mid]) / 2);
         } else {
-          result.push(values[mid]);
+          result.push(values2[mid]);
         }
       }
     }
@@ -882,89 +888,44 @@ function sar(start, inc, max6, high, low, close) {
   }
   return result;
 }
+function pivot(source, leftbars, rightbars, isHigh) {
+  const beatsLeft = isHigh ? (x, v) => x > v : (x, v) => x < v;
+  const beatsRight = isHigh ? (x, v) => x >= v : (x, v) => x <= v;
+  return source.map((_, i) => {
+    const center = i - rightbars;
+    if (center - leftbars < 0) return NaN;
+    const v = source[center];
+    if (Number.isNaN(v)) return NaN;
+    for (let j = 1; j <= leftbars; j++) {
+      const x = source[center - j];
+      if (Number.isNaN(x)) break;
+      if (beatsLeft(x, v)) return NaN;
+    }
+    for (let j = 1; j <= rightbars; j++) {
+      const x = source[center + j];
+      if (Number.isNaN(x)) break;
+      if (beatsRight(x, v)) return NaN;
+    }
+    return v;
+  });
+}
 function pivothigh(sourceOrLeftbars, leftbarsOrRightbars, rightbars, high) {
-  let source;
-  let leftbars;
-  let right;
   if (rightbars === void 0) {
     if (!high) {
       throw new Error("ta.pivothigh() requires high series when using two-parameter version.");
     }
-    source = high;
-    leftbars = sourceOrLeftbars;
-    right = leftbarsOrRightbars;
-  } else {
-    source = sourceOrLeftbars;
-    leftbars = leftbarsOrRightbars;
-    right = rightbars;
+    return pivot(high, sourceOrLeftbars, leftbarsOrRightbars, true);
   }
-  const result = [];
-  for (let i = 0; i < source.length; i++) {
-    if (i < leftbars || i + right >= source.length) {
-      result.push(NaN);
-      continue;
-    }
-    const centerValue = source[i];
-    let isPivot = true;
-    for (let j = 1; j <= leftbars; j++) {
-      if (source[i - j] >= centerValue) {
-        isPivot = false;
-        break;
-      }
-    }
-    if (isPivot) {
-      for (let j = 1; j <= right; j++) {
-        if (source[i + j] >= centerValue) {
-          isPivot = false;
-          break;
-        }
-      }
-    }
-    result.push(isPivot ? centerValue : NaN);
-  }
-  return result;
+  return pivot(sourceOrLeftbars, leftbarsOrRightbars, rightbars, true);
 }
 function pivotlow(sourceOrLeftbars, leftbarsOrRightbars, rightbars, low) {
-  let source;
-  let leftbars;
-  let right;
   if (rightbars === void 0) {
     if (!low) {
       throw new Error("ta.pivotlow() requires low series when using two-parameter version.");
     }
-    source = low;
-    leftbars = sourceOrLeftbars;
-    right = leftbarsOrRightbars;
-  } else {
-    source = sourceOrLeftbars;
-    leftbars = leftbarsOrRightbars;
-    right = rightbars;
+    return pivot(low, sourceOrLeftbars, leftbarsOrRightbars, false);
   }
-  const result = [];
-  for (let i = 0; i < source.length; i++) {
-    if (i < leftbars || i + right >= source.length) {
-      result.push(NaN);
-      continue;
-    }
-    const centerValue = source[i];
-    let isPivot = true;
-    for (let j = 1; j <= leftbars; j++) {
-      if (source[i - j] <= centerValue) {
-        isPivot = false;
-        break;
-      }
-    }
-    if (isPivot) {
-      for (let j = 1; j <= right; j++) {
-        if (source[i + j] <= centerValue) {
-          isPivot = false;
-          break;
-        }
-      }
-    }
-    result.push(isPivot ? centerValue : NaN);
-  }
-  return result;
+  return pivot(sourceOrLeftbars, leftbarsOrRightbars, rightbars, false);
 }
 function barssince(condition) {
   const result = [];
@@ -1158,27 +1119,38 @@ function wpr(high, low, close, length2 = 14) {
   }
   return result;
 }
-function vwap(source, volume) {
+function vwap(source, volume, anchor, stdev_mult) {
   if (source.length !== volume.length) {
     throw new Error("ta.vwap: source and volume must have the same length");
   }
-  const result = [];
-  let cumulativePV = 0;
-  let cumulativeVolume = 0;
+  const mid = [];
+  const upper2 = [];
+  const lower2 = [];
+  let sumPV = 0;
+  let sumV = 0;
+  let sumPPV = 0;
   for (let i = 0; i < source.length; i++) {
-    if (isNaN(source[i]) || isNaN(volume[i])) {
-      result.push(NaN);
-      continue;
+    if (anchor && anchor[i]) {
+      sumPV = 0;
+      sumV = 0;
+      sumPPV = 0;
     }
-    cumulativePV += source[i] * volume[i];
-    cumulativeVolume += volume[i];
-    if (cumulativeVolume === 0) {
-      result.push(NaN);
-    } else {
-      result.push(cumulativePV / cumulativeVolume);
+    const s = source[i];
+    const v = volume[i];
+    if (!Number.isNaN(s) && !Number.isNaN(v)) {
+      sumPV += s * v;
+      sumV += v;
+      sumPPV += s * s * v;
+    }
+    const m = sumV === 0 ? NaN : sumPV / sumV;
+    mid.push(m);
+    if (stdev_mult !== void 0) {
+      const sd = Math.sqrt(Math.max(0, sumPPV / sumV - m * m));
+      upper2.push(m + stdev_mult * sd);
+      lower2.push(m - stdev_mult * sd);
     }
   }
-  return result;
+  return stdev_mult === void 0 ? mid : [mid, upper2, lower2];
 }
 function alma(source, length2 = 9, offset = 0.85, sigma = 6, floor2 = false) {
   const result = [];
@@ -1220,85 +1192,31 @@ function kcw(source, length2 = 20, mult2 = 2, useTrueRange = true, high, low, cl
   }
   return result;
 }
-function range(high, low) {
-  if (high.length !== low.length) {
-    throw new Error("ta.range: high and low must have the same length");
-  }
-  const result = [];
-  for (let i = 0; i < high.length; i++) {
-    if (isNaN(high[i]) || isNaN(low[i])) {
-      result.push(NaN);
-    } else {
-      result.push(high[i] - low[i]);
-    }
-  }
-  return result;
+function range(source, length2) {
+  return source.map((_, i) => {
+    const values2 = lastValues(source, i, length2);
+    return values2 ? Math.max(...values2) - Math.min(...values2) : NaN;
+  });
 }
 function highestbars(source, length2) {
-  const result = [];
-  for (let i = 0; i < source.length; i++) {
-    if (i < length2 - 1) {
-      result.push(NaN);
-      continue;
-    }
-    let highestValue = source[i - length2 + 1];
-    let highestOffset = length2 - 1;
-    for (let j = i - length2 + 2; j <= i; j++) {
-      if (source[j] > highestValue) {
-        highestValue = source[j];
-        highestOffset = i - j;
-      }
-    }
-    result.push(highestOffset);
-  }
-  return result;
+  return extremeOffset(source, length2, (a, b2) => a >= b2);
 }
 function lowestbars(source, length2) {
-  const result = [];
-  for (let i = 0; i < source.length; i++) {
-    if (i < length2 - 1) {
-      result.push(NaN);
-      continue;
-    }
-    let lowestValue = source[i - length2 + 1];
-    let lowestOffset = length2 - 1;
-    for (let j = i - length2 + 2; j <= i; j++) {
-      if (source[j] < lowestValue) {
-        lowestValue = source[j];
-        lowestOffset = i - j;
-      }
-    }
-    result.push(lowestOffset);
-  }
-  return result;
+  return extremeOffset(source, length2, (a, b2) => a <= b2);
 }
-function max(source1, source2) {
-  if (source1.length !== source2.length) {
-    throw new Error("ta.max: source1 and source2 must have the same length");
-  }
-  const result = [];
-  for (let i = 0; i < source1.length; i++) {
-    if (isNaN(source1[i]) || isNaN(source2[i])) {
-      result.push(NaN);
-    } else {
-      result.push(Math.max(source1[i], source2[i]));
-    }
-  }
-  return result;
+function max(source) {
+  let best = NaN;
+  return source.map((x) => {
+    if (!Number.isNaN(x) && !(x <= best)) best = x;
+    return best;
+  });
 }
-function min(source1, source2) {
-  if (source1.length !== source2.length) {
-    throw new Error("ta.min: source1 and source2 must have the same length");
-  }
-  const result = [];
-  for (let i = 0; i < source1.length; i++) {
-    if (isNaN(source1[i]) || isNaN(source2[i])) {
-      result.push(NaN);
-    } else {
-      result.push(Math.min(source1[i], source2[i]));
-    }
-  }
-  return result;
+function min(source) {
+  let best = NaN;
+  return source.map((x) => {
+    if (!Number.isNaN(x) && !(x >= best)) best = x;
+    return best;
+  });
 }
 function cog(source, length2 = 10) {
   const result = [];
@@ -1331,19 +1249,19 @@ function mode(source, length2) {
       result.push(NaN);
       continue;
     }
-    const values = [];
+    const values2 = [];
     for (let j = 0; j < length2; j++) {
       const value = source[i - j];
       if (!isNaN(value)) {
-        values.push(value);
+        values2.push(value);
       }
     }
-    if (values.length === 0) {
+    if (values2.length === 0) {
       result.push(NaN);
       continue;
     }
     const frequencyMap = /* @__PURE__ */ new Map();
-    for (const value of values) {
+    for (const value of values2) {
       frequencyMap.set(value, (frequencyMap.get(value) || 0) + 1);
     }
     let maxFrequency = 0;
@@ -1369,16 +1287,16 @@ function percentile_linear_interpolation(source, length2, percentage) {
       result.push(NaN);
       continue;
     }
-    const values = [];
+    const values2 = [];
     for (let j = 0; j < length2; j++) {
       const value = source[i - j];
-      values.push(value);
+      values2.push(value);
     }
-    if (values.some((v) => isNaN(v))) {
+    if (values2.some((v) => isNaN(v))) {
       result.push(NaN);
       continue;
     }
-    const sorted = [...values].sort((a, b2) => a - b2);
+    const sorted = [...values2].sort((a, b2) => a - b2);
     const position = percentage / 100 * (sorted.length - 1);
     const lowerIndex = Math.floor(position);
     const upperIndex = Math.ceil(position);
@@ -1399,18 +1317,18 @@ function percentile_nearest_rank(source, length2, percentage) {
       result.push(NaN);
       continue;
     }
-    const values = [];
+    const values2 = [];
     for (let j = 0; j < length2; j++) {
       const value = source[i - j];
       if (!isNaN(value)) {
-        values.push(value);
+        values2.push(value);
       }
     }
-    if (values.length === 0) {
+    if (values2.length === 0) {
       result.push(NaN);
       continue;
     }
-    const sorted = [...values].sort((a, b2) => a - b2);
+    const sorted = [...values2].sort((a, b2) => a - b2);
     if (percentage >= 100) {
       result.push(sorted[sorted.length - 1]);
       continue;
@@ -1428,15 +1346,15 @@ function rci(source, length2) {
       result.push(NaN);
       continue;
     }
-    const values = [];
+    const values2 = [];
     for (let j = 0; j < length2; j++) {
-      values.push(source[i - length2 + 1 + j]);
+      values2.push(source[i - length2 + 1 + j]);
     }
-    if (values.some((v) => isNaN(v))) {
+    if (values2.some((v) => isNaN(v))) {
       result.push(NaN);
       continue;
     }
-    const indexed = values.map((value, index) => ({ value, index }));
+    const indexed = values2.map((value, index) => ({ value, index }));
     const sorted = [...indexed].sort((a, b2) => a.value - b2.value);
     const ranks = new Array(length2).fill(0);
     let currentRank = 1;
@@ -1800,23 +1718,86 @@ function zigzag(deviation = 5, depth = 10, backstep = 3, source, high, low) {
   if (potentialPivot) {
     confirmedPivots.push(potentialPivot);
   }
-  for (const pivot of confirmedPivots) {
-    zigzagValues[pivot.index] = pivot.price;
-    isPivot[pivot.index] = true;
+  for (const pivot2 of confirmedPivots) {
+    zigzagValues[pivot2.index] = pivot2.price;
+    isPivot[pivot2.index] = true;
   }
   let currentDir = 0;
   let pivotIdx = 0;
   const numConfirmed = lastPotentialWasAdded ? confirmedPivots.length - 1 : confirmedPivots.length;
   for (let i = 0; i < length2; i++) {
     while (pivotIdx < numConfirmed && confirmedPivots[pivotIdx].index <= i) {
-      const pivot = confirmedPivots[pivotIdx];
-      currentDir = pivot.type === "low" ? 1 : -1;
+      const pivot2 = confirmedPivots[pivotIdx];
+      currentDir = pivot2.type === "low" ? 1 : -1;
       pivotIdx++;
     }
     directions[i] = currentDir;
   }
   return [zigzagValues, directions, isPivot];
 }
+function obv(close, volume) {
+  return cum(close.map((c, i) => i === 0 ? NaN : Math.sign(c - close[i - 1]) * volume[i]));
+}
+function pvt(close, volume) {
+  return cum(
+    close.map((c, i) => i === 0 ? NaN : (c - close[i - 1]) / close[i - 1] * volume[i])
+  );
+}
+function accdist(high, low, close, volume) {
+  return cum(
+    close.map((c, i) => {
+      const h = high[i];
+      const l = low[i];
+      return h === l ? 0 : (2 * c - l - h) / (h - l) * volume[i];
+    })
+  );
+}
+function iii(high, low, close, volume) {
+  return close.map((c, i) => {
+    const range4 = high[i] - low[i];
+    return range4 === 0 ? NaN : (2 * c - high[i] - low[i]) / range4 * volume[i];
+  });
+}
+function wvad(open, high, low, close, volume) {
+  return close.map((c, i) => {
+    const range4 = high[i] - low[i];
+    return range4 === 0 ? NaN : (c - open[i]) / range4 * volume[i];
+  });
+}
+function wad(high, low, close) {
+  return cum(
+    close.map((c, i) => {
+      const prev = i === 0 ? NaN : close[i - 1];
+      const mom3 = c - prev;
+      if (mom3 > 0) return c - Math.min(low[i], prev);
+      if (mom3 < 0) return c - Math.max(high[i], prev);
+      return 0;
+    })
+  );
+}
+function volumeIndex(close, volume, use) {
+  const result = [];
+  let prevIndex = NaN;
+  for (let i = 0; i < close.length; i++) {
+    const prev = !prevIndex ? 1 : prevIndex;
+    const c = close[i];
+    const prevC = i === 0 ? NaN : close[i - 1];
+    let value = prev;
+    if (c && prevC) {
+      const prevV = i === 0 || Number.isNaN(volume[i - 1]) ? 0 : volume[i - 1];
+      if (use(volume[i], prevV)) value = prev + (c - prevC) / prevC * prev;
+    }
+    result.push(value);
+    prevIndex = value;
+  }
+  return result;
+}
+function nvi(close, volume) {
+  return volumeIndex(close, volume, (v, prevV) => v < prevV);
+}
+function pvi(close, volume) {
+  return volumeIndex(close, volume, (v, prevV) => v > prevV);
+}
 
 // src/math/index.ts
 var math_exports = {};
@@ -1993,8 +1974,8 @@ var Series = class _Series {
    * @param field - Field to extract ('open', 'high', 'low', 'close', 'volume')
    * @returns Series with extracted field values
    */
-  static fromBars(bars, field) {
-    return new _Series(bars, (bar) => bar[field] ?? NaN);
+  static fromBars(bars, field2) {
+    return new _Series(bars, (bar) => bar[field2] ?? NaN);
   }
   /**
    * Create a constant series (same value for all bars)
@@ -2011,8 +1992,8 @@ var Series = class _Series {
    * @param values - Array of values
    * @returns Series
    */
-  static fromArray(bars, values) {
-    return new _Series(bars, (_bar, i) => values[i] ?? NaN);
+  static fromArray(bars, values2) {
+    return new _Series(bars, (_bar, i) => values2[i] ?? NaN);
   }
   // ============================================
   // Arithmetic Operations
@@ -2053,6 +2034,18 @@ var Series = class _Series {
       return a * b2;
     });
   }
+  /**
+   * Raise the series to a power (PineScript math.pow on a series)
+   * @param exponent - Series or number exponent
+   * @returns New Series representing base ** exponent
+   */
+  pow(exponent) {
+    return new _Series(this.dataSource, (bar, i, data) => {
+      const a = this.extractor(bar, i, data);
+      const b2 = typeof exponent === "number" ? exponent : exponent.extractor(bar, i, data);
+      return Math.pow(a, b2);
+    });
+  }
   /**
    * Divide two series or a series by a number
    * @param other - Series or number to divide by
@@ -2290,8 +2283,8 @@ var Series = class _Series {
    * @returns New Series with computed values and no closure dependencies
    */
   materialize() {
-    const values = this.toArray();
-    const valuesCopy = [...values];
+    const values2 = this.toArray();
+    const valuesCopy = [...values2];
     return _Series.fromArray(this.dataSource, valuesCopy);
   }
   /**
@@ -2321,16 +2314,16 @@ var Series = class _Series {
    * @returns Value at that index
    */
   get(index) {
-    const values = this.toArray();
-    return values[index] ?? NaN;
+    const values2 = this.toArray();
+    return values2[index] ?? NaN;
   }
   /**
    * Get the last value (most recent bar)
    * @returns Most recent value
    */
   last() {
-    const values = this.toArray();
-    return values[values.length - 1] ?? NaN;
+    const values2 = this.toArray();
+    return values2[values2.length - 1] ?? NaN;
   }
   /**
    * Get number of values
@@ -2344,11 +2337,11 @@ var Series = class _Series {
    * @returns Array of { time, value } objects
    */
   toTimeValuePairs() {
-    const values = this.toArray();
+    const values2 = this.toArray();
     const bars = this.dataSource.bars;
     return bars.map((bar, i) => ({
       time: bar.time,
-      value: values[i]
+      value: values2[i]
     })).filter((point) => !Number.isNaN(point.value));
   }
 };
@@ -2422,60 +2415,60 @@ function round(value, precision) {
   const multiplier = Math.pow(10, precision);
   return Math.round(value * multiplier) / multiplier;
 }
-function max2(...values) {
-  const hasSeries = values.some((v) => v instanceof Series);
+function max2(...values2) {
+  const hasSeries = values2.some((v) => v instanceof Series);
   if (!hasSeries) {
-    return Math.max(...values);
+    return Math.max(...values2);
   }
-  const firstSeries = values.find((v) => v instanceof Series);
+  const firstSeries = values2.find((v) => v instanceof Series);
   const bars = firstSeries.bars;
   const length2 = bars.length;
-  const valueArrays = values.map(
+  const valueArrays = values2.map(
     (v) => v instanceof Series ? v.toArray() : null
   );
   const result = [];
   for (let i = 0; i < length2; i++) {
-    const nums = values.map(
+    const nums = values2.map(
       (v, idx) => valueArrays[idx] ? valueArrays[idx][i] ?? NaN : v
     );
     result.push(Math.max(...nums));
   }
   return Series.fromArray(bars, result);
 }
-function min2(...values) {
-  const hasSeries = values.some((v) => v instanceof Series);
+function min2(...values2) {
+  const hasSeries = values2.some((v) => v instanceof Series);
   if (!hasSeries) {
-    return Math.min(...values);
+    return Math.min(...values2);
   }
-  const firstSeries = values.find((v) => v instanceof Series);
+  const firstSeries = values2.find((v) => v instanceof Series);
   const bars = firstSeries.bars;
   const length2 = bars.length;
-  const valueArrays = values.map(
+  const valueArrays = values2.map(
     (v) => v instanceof Series ? v.toArray() : null
   );
   const result = [];
   for (let i = 0; i < length2; i++) {
-    const nums = values.map(
+    const nums = values2.map(
       (v, idx) => valueArrays[idx] ? valueArrays[idx][i] ?? NaN : v
     );
     result.push(Math.min(...nums));
   }
   return Series.fromArray(bars, result);
 }
-function avg(...values) {
-  const hasSeries = values.some((v) => v instanceof Series);
+function avg(...values2) {
+  const hasSeries = values2.some((v) => v instanceof Series);
   if (!hasSeries) {
-    return values.reduce((a, b2) => a + b2, 0) / values.length;
+    return values2.reduce((a, b2) => a + b2, 0) / values2.length;
   }
-  const firstSeries = values.find((v) => v instanceof Series);
+  const firstSeries = values2.find((v) => v instanceof Series);
   const bars = firstSeries.bars;
   const length2 = bars.length;
-  const valueArrays = values.map(
+  const valueArrays = values2.map(
     (v) => v instanceof Series ? v.toArray() : null
   );
   const result = [];
   for (let i = 0; i < length2; i++) {
-    const nums = values.map(
+    const nums = values2.map(
       (v, idx) => valueArrays[idx] ? valueArrays[idx][i] ?? NaN : v
     );
     const sum4 = nums.reduce((a, b2) => a + b2, 0);
@@ -2709,10 +2702,10 @@ function sign(value) {
   }
   return value > 0 ? 1 : value < 0 ? -1 : 0;
 }
-function round_to_mintick(number, mintick) {
-  if (number instanceof Series) {
-    const bars = number.bars;
-    const valueArray = number.toArray();
+function round_to_mintick(number2, mintick) {
+  if (number2 instanceof Series) {
+    const bars = number2.bars;
+    const valueArray = number2.toArray();
     const length2 = bars.length;
     if (mintick === void 0) {
       throw new Error(
@@ -2736,7 +2729,7 @@ function round_to_mintick(number, mintick) {
     }
     return Series.fromArray(bars, result);
   }
-  if (isNaN(number)) {
+  if (isNaN(number2)) {
     return NaN;
   }
   if (mintick === void 0) {
@@ -2745,9 +2738,9 @@ function round_to_mintick(number, mintick) {
     );
   }
   if (mintick === 0) {
-    return number;
+    return number2;
   }
-  return Math.round(number / mintick) * mintick;
+  return Math.round(number2 / mintick) * mintick;
 }
 var pi = Math.PI;
 var e = Math.E;
@@ -2813,9 +2806,9 @@ __export(array_exports, {
   unshift: () => unshift,
   variance: () => variance2
 });
-function new_array(size2 = 0, initial_value) {
+function new_array(size3 = 0, initial_value) {
   const arr = [];
-  for (let i = 0; i < size2; i++) {
+  for (let i = 0; i < size3; i++) {
     arr.push(initial_value);
   }
   return arr;
@@ -2889,11 +2882,13 @@ function sum2(id) {
 function avg2(id) {
   return sum2(id) / size(id);
 }
-function min3(id) {
-  return Math.min(...id);
+function min3(id, nth = 0) {
+  const values2 = id.filter((v) => !Number.isNaN(v)).sort((a, b2) => a - b2);
+  return values2.length ? values2[Math.min(nth, values2.length - 1)] : NaN;
 }
-function max3(id) {
-  return Math.max(...id);
+function max3(id, nth = 0) {
+  const values2 = id.filter((v) => !Number.isNaN(v)).sort((a, b2) => b2 - a);
+  return values2.length ? values2[Math.min(nth, values2.length - 1)] : NaN;
 }
 function median2(id) {
   const sorted = [...id].sort((a, b2) => a - b2);
@@ -2914,16 +2909,15 @@ function mode2(id) {
   }
   return mode5;
 }
-function stdev2(id) {
-  const mean = avg2(id);
-  const squareDiffs = id.map((value) => Math.pow(value - mean, 2));
-  const avgSquareDiff = sum2(squareDiffs) / size(id);
-  return Math.sqrt(avgSquareDiff);
+function stdev2(id, biased = true) {
+  return Math.sqrt(variance2(id, biased));
 }
-function variance2(id) {
-  const mean = avg2(id);
-  const squareDiffs = id.map((value) => Math.pow(value - mean, 2));
-  return sum2(squareDiffs) / size(id);
+function variance2(id, biased = true) {
+  const values2 = id.filter((v) => !Number.isNaN(v));
+  if (!values2.length) return NaN;
+  const mean = values2.reduce((a, b2) => a + b2, 0) / values2.length;
+  const squares = values2.reduce((a, b2) => a + (b2 - mean) * (b2 - mean), 0);
+  return squares / (biased ? values2.length : values2.length - 1);
 }
 function fill(id, value, index_from = 0, index_to) {
   const end = index_to ?? id.length;
@@ -2931,8 +2925,8 @@ function fill(id, value, index_from = 0, index_to) {
     id[i] = value;
   }
 }
-function from(id) {
-  return copy(id);
+function from(...values2) {
+  return [...values2];
 }
 function first(id) {
   return id[0];
@@ -2940,38 +2934,38 @@ function first(id) {
 function last(id) {
   return id[id.length - 1];
 }
-function some(id, predicate) {
-  return id.some(predicate);
+function some(id) {
+  return id.some((v) => v === true);
 }
-function every(id, predicate) {
-  return id.every(predicate);
+function every(id) {
+  return id.length > 0 && id.every((v) => v === true);
 }
-function new_bool(size2 = 0, initial_value = false) {
-  return new_array(size2, initial_value);
+function new_bool(size3 = 0, initial_value = false) {
+  return new_array(size3, initial_value);
 }
-function new_float(size2 = 0, initial_value = NaN) {
-  return new_array(size2, initial_value);
+function new_float(size3 = 0, initial_value = NaN) {
+  return new_array(size3, initial_value);
 }
-function new_int(size2 = 0, initial_value = NaN) {
-  return new_array(size2, initial_value);
+function new_int(size3 = 0, initial_value = NaN) {
+  return new_array(size3, initial_value);
 }
-function new_string(size2 = 0, initial_value) {
-  return new_array(size2, initial_value);
+function new_string(size3 = 0, initial_value) {
+  return new_array(size3, initial_value);
 }
-function new_color(size2 = 0, initial_value) {
-  return new_array(size2, initial_value);
+function new_color(size3 = 0, initial_value) {
+  return new_array(size3, initial_value);
 }
-function new_line(size2 = 0, initial_value) {
-  return new_array(size2, initial_value);
+function new_line(size3 = 0, initial_value) {
+  return new_array(size3, initial_value);
 }
-function new_box(size2 = 0, initial_value) {
-  return new_array(size2, initial_value);
+function new_box(size3 = 0, initial_value) {
+  return new_array(size3, initial_value);
 }
-function new_label(size2 = 0, initial_value) {
-  return new_array(size2, initial_value);
+function new_label(size3 = 0, initial_value) {
+  return new_array(size3, initial_value);
 }
-function new_linefill(size2 = 0, initial_value) {
-  return new_array(size2, initial_value);
+function new_linefill(size3 = 0, initial_value) {
+  return new_array(size3, initial_value);
 }
 function abs2(id) {
   return id.map((x) => Math.abs(x));
@@ -3111,8 +3105,70 @@ function standardize(id) {
   }
   return id.map((value) => (value - mean) / stdDev);
 }
-function newtype(size2 = 0, initial_value) {
-  return new_array(size2, initial_value);
+function newtype(size3 = 0, initial_value) {
+  return new_array(size3, initial_value);
+}
+
+// src/map/index.ts
+var map_exports = {};
+__export(map_exports, {
+  MAX_SIZE: () => MAX_SIZE,
+  clear: () => clear2,
+  contains: () => contains,
+  copy: () => copy2,
+  get: () => get2,
+  keys: () => keys,
+  new_map: () => new_map,
+  put: () => put,
+  put_all: () => put_all,
+  remove: () => remove2,
+  size: () => size2,
+  values: () => values
+});
+var MAX_SIZE = 5e4;
+function tooLarge(size3) {
+  return new RangeError(`A map cannot have more than ${MAX_SIZE} key-value pairs. The current size is ${size3}.`);
+}
+function new_map() {
+  return /* @__PURE__ */ new Map();
+}
+function put(id, key, value) {
+  const previous = id.get(key);
+  if (!id.has(key) && id.size >= MAX_SIZE) throw tooLarge(id.size + 1);
+  id.set(key, value);
+  return previous;
+}
+function put_all(id, id2) {
+  let size3 = id.size;
+  for (const key of id2.keys()) if (!id.has(key)) size3++;
+  if (size3 > MAX_SIZE) throw tooLarge(size3);
+  for (const [key, value] of id2) id.set(key, value);
+}
+function get2(id, key) {
+  return id.get(key);
+}
+function contains(id, key) {
+  return id.has(key);
+}
+function remove2(id, key) {
+  const value = id.get(key);
+  id.delete(key);
+  return value;
+}
+function size2(id) {
+  return id.size;
+}
+function clear2(id) {
+  id.clear();
+}
+function keys(id) {
+  return [...id.keys()];
+}
+function values(id) {
+  return [...id.values()];
+}
+function copy2(id) {
+  return new Map(id);
 }
 
 // src/str/index.ts
@@ -3120,7 +3176,7 @@ var str_exports = {};
 __export(str_exports, {
   charAt: () => charAt,
   concat: () => concat2,
-  contains: () => contains,
+  contains: () => contains2,
   endswith: () => endswith,
   format: () => format,
   format_time: () => format_time,
@@ -3141,15 +3197,486 @@ __export(str_exports, {
   trimRight: () => trimRight,
   upper: () => upper
 });
+
+// src/str/numberformat.ts
+var patterns = /* @__PURE__ */ new Map();
+function parsePattern(pattern) {
+  const cached = patterns.get(pattern);
+  if (cached) return cached;
+  let prefix = "";
+  let suffix = "";
+  let number2 = "";
+  let percent = false;
+  let phase = "prefix";
+  for (let i = 0; i < pattern.length; i++) {
+    const ch = pattern[i];
+    let literal;
+    if (ch === "'") {
+      const end = pattern.indexOf("'", i + 1);
+      if (end === i + 1) {
+        literal = "'";
+        i = end;
+      } else {
+        literal = pattern.slice(i + 1, end === -1 ? void 0 : end);
+        i = end === -1 ? pattern.length : end;
+      }
+    } else if (phase !== "suffix" && ("#0,.".includes(ch) || phase === "number" && ch === "E")) {
+      phase = "number";
+      number2 += ch;
+      continue;
+    } else {
+      if (ch === "%") percent = true;
+      literal = ch;
+    }
+    if (phase === "number") phase = "suffix";
+    if (phase === "prefix") prefix += literal;
+    else suffix += literal;
+  }
+  const [mantissa = "", exp2] = number2.split("E");
+  const [intPart = "", fracPart = ""] = mantissa.split(".");
+  const lastComma = intPart.lastIndexOf(",");
+  const parsed = {
+    prefix,
+    suffix,
+    // as in Java, a pattern with a decimal point and no '0' at all ("#.##") shows one integer digit
+    minInt: !mantissa.includes("0") && mantissa.includes(".") ? 1 : [...intPart].filter((c) => c === "0").length,
+    minFrac: [...fracPart].filter((c) => c === "0").length,
+    maxFrac: [...fracPart].filter((c) => c === "0" || c === "#").length,
+    grouping: lastComma === -1 ? 0 : intPart.length - lastComma - 1,
+    percent,
+    exponent: exp2 === void 0 ? null : exp2.length,
+    hasDigits: /[0#]/.test(mantissa)
+  };
+  patterns.set(pattern, parsed);
+  return parsed;
+}
+function shortestDigits(x) {
+  const m = /^(\d+)(?:\.(\d+))?(?:e([+-]\d+))?$/.exec(String(Math.abs(x)));
+  const all7 = m[1] + (m[2] ?? "");
+  let intLen = m[1].length + Number(m[3] ?? 0);
+  const lead = all7.length - all7.replace(/^0+/, "").length;
+  intLen -= lead;
+  const digits = all7.slice(lead).replace(/0+$/, "");
+  return { digits, intLen: digits ? intLen : 0 };
+}
+function exactDigits(x) {
+  const abs3 = Math.abs(x);
+  if (abs3 === 0) return { digits: "", intLen: 0 };
+  const view = new DataView(new ArrayBuffer(8));
+  view.setFloat64(0, abs3);
+  const bits = view.getBigUint64(0);
+  const expBits = Number(bits >> 52n & 0x7ffn);
+  let mant = bits & 0xfffffffffffffn;
+  const e2 = expBits === 0 ? -1074 : expBits - 1075;
+  if (expBits !== 0) mant |= 1n << 52n;
+  let str;
+  let fracDigits;
+  if (e2 >= 0) {
+    str = (mant << BigInt(e2)).toString();
+    fracDigits = 0;
+  } else {
+    str = (mant * 5n ** BigInt(-e2)).toString();
+    fracDigits = -e2;
+  }
+  const intLen = str.length - fracDigits;
+  const lead = str.length - str.replace(/^0+/, "").length;
+  const digits = str.slice(lead).replace(/0+$/, "");
+  return { digits, intLen: intLen - lead };
+}
+function roundDigits(d, frac, mode5) {
+  const keep = d.intLen + frac;
+  if (keep >= d.digits.length) return d;
+  if (keep < 0) return { digits: "", intLen: 0 };
+  const first2 = d.digits.charCodeAt(keep) - 48;
+  let up;
+  if (mode5 === "halfUpShortest") up = first2 >= 5;
+  else if (first2 !== 5) up = first2 > 5;
+  else if (d.digits.length > keep + 1) up = true;
+  else up = keep > 0 && (d.digits.charCodeAt(keep - 1) - 48) % 2 === 1;
+  let kept = d.digits.slice(0, keep);
+  let intLen = d.intLen;
+  if (up) {
+    const n = (BigInt(kept || "0") + 1n).toString();
+    if (n.length > kept.length) intLen += 1;
+    kept = n;
+  }
+  kept = kept.replace(/0+$/, "");
+  return { digits: kept, intLen: kept ? intLen : 0 };
+}
+function group(int, size3) {
+  if (!size3 || int.length <= size3) return int;
+  const parts = [];
+  for (let end = int.length; end > 0; end -= size3) parts.unshift(int.slice(Math.max(0, end - size3), end));
+  return parts.join(",");
+}
+function layout(d, p) {
+  let int = d.intLen > 0 ? d.digits.slice(0, d.intLen).padEnd(d.intLen, "0") : "";
+  int = int.replace(/^0+/, "").padStart(p.minInt, "0");
+  let frac = d.intLen < 0 ? "0".repeat(-d.intLen) + d.digits : d.digits.slice(Math.max(0, d.intLen));
+  frac = frac.slice(0, p.maxFrac).replace(/0+$/, "").padEnd(p.minFrac, "0");
+  if (!int && !frac) int = "0";
+  return group(int, p.grouping) + (frac ? "." + frac : "");
+}
+function formatNumber(value, pattern, mode5) {
+  if (Number.isNaN(value)) return "NaN";
+  const p = parsePattern(pattern);
+  if (!Number.isFinite(value)) return (value < 0 ? "-" : "") + p.prefix + "\u221E" + p.suffix;
+  const x = p.percent ? value * 100 : value;
+  const toDigits = mode5 === "halfUpShortest" ? shortestDigits : exactDigits;
+  let body;
+  let isZero;
+  if (p.exponent !== null) {
+    const rounded = roundDigits(toDigits(x), p.maxFrac, mode5);
+    const intDigits = Math.max(p.minInt, 1);
+    isZero = rounded.digits === "";
+    let exponent = isZero ? 0 : rounded.intLen - intDigits;
+    let mant = roundDigits({ digits: rounded.digits, intLen: isZero ? 0 : intDigits }, p.maxFrac, mode5);
+    if (mant.intLen > intDigits) {
+      exponent += 1;
+      mant = { digits: mant.digits, intLen: intDigits };
+    }
+    const e2 = String(Math.abs(exponent)).padStart(p.exponent, "0");
+    body = layout(mant, p) + "E" + (exponent < 0 ? "-" : "") + e2;
+  } else {
+    const rounded = roundDigits(toDigits(x), p.hasDigits ? p.maxFrac : 0, mode5);
+    isZero = rounded.digits === "";
+    body = p.hasDigits ? layout(rounded, p) : layout(rounded, { ...p, minInt: 0, maxFrac: 0, minFrac: 0 });
+  }
+  const negative = x < 0 && (!isZero || !p.hasDigits);
+  return (negative ? "-" : "") + p.prefix + body + p.suffix;
+}
+
+// src/time/timezone.ts
+var MS_PER_SECOND = 1e3;
+var MS_PER_DAY = 864e5;
+var MAX_OFFSET_SECONDS = 18 * 3600;
+var OFFSET_NOTATION = /^(?:UTC|GMT)(?:([+-])(\d{1,2})(?::?(\d{2})(?::?(\d{2}))?)?)?$/;
+var REJECTED_NAMES = /* @__PURE__ */ new Set(["EST", "MST", "HST"]);
+var canonicalNames;
+function hasTimeZoneCase(name) {
+  if (name.split("/").some((segment) => !/^[A-Z]/.test(segment))) return false;
+  canonicalNames ??= new Map(Intl.supportedValuesOf("timeZone").map((n) => [n.toLowerCase(), n]));
+  const canonical = canonicalNames.get(name.toLowerCase());
+  return canonical === void 0 || canonical === name;
+}
+var zones = /* @__PURE__ */ new Map();
+function resolveZone(timezone) {
+  let zone = zones.get(timezone);
+  if (zone) return zone;
+  const invalid = () => new RangeError(
+    `Invalid time zone "${timezone}": use UTC/GMT offset notation ("UTC-5", "GMT+0530") or an IANA name ("America/New_York")`
+  );
+  const m = OFFSET_NOTATION.exec(timezone);
+  if (m) {
+    const [, sign2, h = "0", mi = "0", s] = m;
+    const minutes = Number(mi);
+    const seconds = s === void 0 ? 0 : Number(s);
+    if (minutes > 59 || seconds > 59 || s !== void 0 && h.length !== 2) throw invalid();
+    const offsetSeconds = Number(h) * 3600 + minutes * 60 + seconds;
+    if (offsetSeconds > MAX_OFFSET_SECONDS) throw invalid();
+    zone = { kind: "fixed", offsetMs: (sign2 === "-" ? -offsetSeconds : offsetSeconds) * MS_PER_SECOND };
+  } else {
+    if (REJECTED_NAMES.has(timezone) || !hasTimeZoneCase(timezone)) throw invalid();
+    let format2;
+    try {
+      format2 = new Intl.DateTimeFormat("en-US", {
+        timeZone: timezone,
+        hourCycle: "h23",
+        year: "numeric",
+        month: "numeric",
+        day: "numeric",
+        hour: "numeric",
+        minute: "numeric",
+        second: "numeric"
+      });
+    } catch {
+      throw invalid();
+    }
+    zone = { kind: "iana", format: format2 };
+  }
+  zones.set(timezone, zone);
+  return zone;
+}
+function offsetAt(zone, time) {
+  if (zone.kind === "fixed") return zone.offsetMs;
+  const wholeSecond = Math.floor(time / 1e3) * 1e3;
+  const f = {};
+  for (const part of zone.format.formatToParts(wholeSecond)) {
+    if (part.type !== "literal") f[part.type] = Number(part.value);
+  }
+  const local = Date.UTC(f.year, f.month - 1, f.day, f.hour, f.minute, f.second);
+  return local - wholeSecond;
+}
+function zoneOffset(time, timezone) {
+  return offsetAt(resolveZone(timezone), time);
+}
+function zonedFields(time, timezone) {
+  const local = new Date(time + offsetAt(resolveZone(timezone), time));
+  return {
+    year: local.getUTCFullYear(),
+    month: local.getUTCMonth() + 1,
+    day: local.getUTCDate(),
+    hour: local.getUTCHours(),
+    minute: local.getUTCMinutes(),
+    second: local.getUTCSeconds(),
+    dayOfWeek: local.getUTCDay() + 1
+  };
+}
+function zonedToUnix(timezone, year2, month2, day, hour2 = 0, minute2 = 0, second2 = 0) {
+  const zone = resolveZone(timezone);
+  const local = Date.UTC(year2, month2 - 1, day, hour2, minute2, second2);
+  if (zone.kind === "fixed") return local - zone.offsetMs;
+  const before = offsetAt(zone, local - MS_PER_DAY);
+  const after = offsetAt(zone, local + MS_PER_DAY);
+  const candidates = [local - before, local - after].filter((t2) => local - offsetAt(zone, t2) === t2);
+  if (candidates.length) return Math.max(...candidates);
+  return local - before;
+}
+
+// src/str/dateformat.ts
+var MONTHS = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+var DAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+var pad = (n, width) => String(n).padStart(width, "0");
+function zoneName(time, timezone, offsetMs) {
+  if (timezone === "Etc/UTC") return "UTC";
+  if (/^(UTC|GMT)/.test(timezone)) {
+    if (offsetMs === 0) return "GMT";
+    const minutes = Math.abs(offsetMs) / 6e4;
+    return `GMT${offsetMs < 0 ? "-" : "+"}${pad(Math.floor(minutes / 60), 2)}:${pad(minutes % 60, 2)}`;
+  }
+  const part = new Intl.DateTimeFormat("en-US", { timeZone: timezone, timeZoneName: "short" }).formatToParts(time).find((p) => p.type === "timeZoneName");
+  return part?.value ?? timezone;
+}
+function weekOfYear(year2, month2, day) {
+  const date = Date.UTC(year2, month2 - 1, day);
+  const dow = new Date(date).getUTCDay();
+  const weekStart = date - dow * 864e5;
+  if (weekStart + 6 * 864e5 >= Date.UTC(year2 + 1, 0, 1)) return 1;
+  const jan1 = Date.UTC(year2, 0, 1);
+  const jan1Dow = new Date(jan1).getUTCDay();
+  return Math.floor((date - jan1 + jan1Dow * 864e5) / (7 * 864e5)) + 1;
+}
+function formatDate(time, pattern, timezone) {
+  if (Number.isNaN(time)) return "NaN";
+  const f = zonedFields(time, timezone);
+  const offset = zoneOffset(time, timezone);
+  const ms = (time % 1e3 + 1e3) % 1e3;
+  const dayOfYear = (Date.UTC(f.year, f.month - 1, f.day) - Date.UTC(f.year, 0, 1)) / 864e5 + 1;
+  let out = "";
+  for (let i = 0; i < pattern.length; ) {
+    const ch = pattern[i];
+    if (ch === "'") {
+      const end = pattern.indexOf("'", i + 1);
+      if (end === i + 1) {
+        out += "'";
+        i += 2;
+      } else {
+        out += pattern.slice(i + 1, end === -1 ? void 0 : end);
+        i = end === -1 ? pattern.length : end + 1;
+      }
+      continue;
+    }
+    if (!/[A-Za-z]/.test(ch)) {
+      out += ch;
+      i++;
+      continue;
+    }
+    let n = 1;
+    while (pattern[i + n] === ch) n++;
+    i += n;
+    const hour12 = f.hour % 12;
+    switch (ch) {
+      case "y":
+        out += n === 2 ? pad(f.year % 100, 2) : pad(f.year, n);
+        break;
+      case "M":
+        out += n >= 4 ? MONTHS[f.month - 1] : n === 3 ? MONTHS[f.month - 1].slice(0, 3) : pad(f.month, n);
+        break;
+      case "d":
+        out += pad(f.day, n);
+        break;
+      case "E":
+        out += n >= 4 ? DAYS[f.dayOfWeek - 1] : DAYS[f.dayOfWeek - 1].slice(0, 3);
+        break;
+      case "u":
+        out += pad(f.dayOfWeek === 1 ? 7 : f.dayOfWeek - 1, n);
+        break;
+      case "D":
+        out += pad(dayOfYear, n);
+        break;
+      case "w":
+        out += pad(weekOfYear(f.year, f.month, f.day), n);
+        break;
+      case "H":
+        out += pad(f.hour, n);
+        break;
+      case "k":
+        out += pad(f.hour === 0 ? 24 : f.hour, n);
+        break;
+      case "K":
+        out += pad(hour12, n);
+        break;
+      case "h":
+        out += pad(hour12 === 0 ? 12 : hour12, n);
+        break;
+      case "a":
+        out += f.hour < 12 ? "AM" : "PM";
+        break;
+      case "m":
+        out += pad(f.minute, n);
+        break;
+      case "s":
+        out += pad(f.second, n);
+        break;
+      case "S":
+        out += pad(ms, n);
+        break;
+      case "Z": {
+        const minutes = Math.abs(offset) / 6e4;
+        out += (offset < 0 ? "-" : "+") + pad(Math.floor(minutes / 60), 2) + pad(minutes % 60, 2);
+        break;
+      }
+      case "z":
+        out += zoneName(time, timezone, offset);
+        break;
+      default:
+        throw new SyntaxError(`Unsupported date pattern letter "${ch}" in "${pattern}"`);
+    }
+  }
+  return out;
+}
+
+// src/str/messageformat.ts
+var DATE_STYLES = {
+  short: "M/d/yy",
+  medium: "MMM d, yyyy",
+  long: "MMMM d, yyyy",
+  full: "EEEE, MMMM d, yyyy"
+};
+var TIME_STYLES = {
+  short: "h:mm\u202Fa",
+  medium: "h:mm:ss\u202Fa",
+  long: "h:mm:ss\u202Fa z",
+  full: "h:mm:ss\u202Fa z"
+};
+function number(value, pattern) {
+  return typeof value === "number" ? formatNumber(value, pattern, "halfEvenExact") : String(value);
+}
+function choice(value, spec) {
+  const options = spec.split("|").map((part) => {
+    const m = /^\s*(-?[\d.]+|-?∞)\s*([#<≤])(.*)$/.exec(part);
+    if (!m) throw new SyntaxError(`Invalid choice format "${spec}"`);
+    const limit = m[1].includes("\u221E") ? m[1].startsWith("-") ? -Infinity : Infinity : Number(m[1]);
+    return { limit: m[2] === "<" ? limit + Number.EPSILON * Math.max(1, Math.abs(limit)) : limit, text: m[3] };
+  });
+  let chosen = options[0];
+  for (const o of options) if (value >= o.limit) chosen = o;
+  return chosen.text;
+}
+function formatArgument(value, type, style, timezone) {
+  if (value === void 0) return "";
+  if (!type) return typeof value === "number" ? number(value, "#,##0.###") : String(value);
+  switch (type.trim()) {
+    case "number": {
+      const s = style?.trim();
+      if (!s) return number(value, "#,##0.###");
+      if (s === "integer") return number(value, "#,##0");
+      if (s === "percent") return number(value, "#,##0%");
+      if (s === "currency") return number(value, "'$'#,##0.00");
+      return number(value, style);
+    }
+    case "date":
+    case "time": {
+      const styles = type.trim() === "date" ? DATE_STYLES : TIME_STYLES;
+      const s = style?.trim() ?? "medium";
+      return formatDate(Number(value), styles[s] ?? style, typeof timezone === "function" ? timezone() : timezone);
+    }
+    case "choice":
+      return choice(Number(value), style ?? "");
+    default:
+      throw new SyntaxError(`Unknown format type "${type}"`);
+  }
+}
+function formatMessage(pattern, args, timezone) {
+  let out = "";
+  for (let i = 0; i < pattern.length; ) {
+    const ch = pattern[i];
+    if (ch === "'") {
+      if (pattern[i + 1] === "'") {
+        out += "'";
+        i += 2;
+        continue;
+      }
+      const end = pattern.indexOf("'", i + 1);
+      out += pattern.slice(i + 1, end === -1 ? void 0 : end);
+      i = end === -1 ? pattern.length : end + 1;
+      continue;
+    }
+    if (ch !== "{") {
+      out += ch;
+      i++;
+      continue;
+    }
+    let depth = 1;
+    let j = i + 1;
+    let inQuote = false;
+    for (; j < pattern.length && depth > 0; j++) {
+      const c = pattern[j];
+      if (c === "'") inQuote = !inQuote;
+      else if (!inQuote && c === "{") depth++;
+      else if (!inQuote && c === "}") depth--;
+    }
+    const inner = pattern.slice(i + 1, j - 1);
+    const [index = "", type, ...rest] = inner.split(",");
+    const style = rest.length ? rest.join(",") : void 0;
+    const n = Number(index.trim());
+    out += n < args.length ? formatArgument(args[n], type, style, timezone) : `{${inner}}`;
+    i = j;
+  }
+  return out;
+}
+
+// src/str/index.ts
 function length(str) {
   return str.length;
 }
 function tostring(value, format2) {
-  if (typeof value === "number" && format2) {
-    const decimals = format2.split(".")[1]?.length || 0;
-    return value.toFixed(decimals);
+  if (typeof value !== "number") return String(value);
+  if (!Number.isFinite(value)) return String(value);
+  if (format2 === void 0 || format2 === "") {
+    if (Math.abs(value) >= 1e21 && Number.isFinite(value)) {
+      return String(value).replace("e+", "E").replace(/\.0+E/, "E");
+    }
+    return formatNumber(value, "#.##########", "halfUpShortest");
+  }
+  switch (format2) {
+    case "percent":
+      return formatNumber(value, "0.00", "halfUpShortest") + "%";
+    case "volume": {
+      const abs3 = Math.abs(value);
+      for (const [size3, unit] of [[1e12, "T"], [1e9, "B"], [1e6, "M"], [1e3, "K"]]) {
+        if (abs3 >= size3) return formatNumber(value / size3, "#.###", "halfUpShortest") + unit;
+      }
+      return formatNumber(value, "#", "halfUpShortest");
+    }
+    case "mintick":
+      throw new Error("str.tostring(x, format.mintick) needs the symbol tick size (syminfo.mintick), which is not known here");
+    default:
+      return formatNumber(value, format2, "halfUpShortest");
   }
-  return String(value);
 }
 function tonumber(str) {
   const num = parseFloat(str);
@@ -3164,7 +3691,7 @@ function upper(str) {
 function lower(str) {
   return str.toLowerCase();
 }
-function contains(source, str) {
+function contains2(source, str) {
   return source.includes(str);
 }
 function pos(source, str) {
@@ -3187,11 +3714,7 @@ function concat2(...strings) {
   return strings.join("");
 }
 function format(formatStr, ...args) {
-  let result = formatStr;
-  args.forEach((arg, index) => {
-    result = result.replaceAll(`{${index}}`, String(arg));
-  });
-  return result;
+  return formatMessage(formatStr, args, "Etc/UTC");
 }
 function startswith(source, str) {
   return source.startsWith(str);
@@ -3219,84 +3742,8 @@ function repeat(source, count, separator = "") {
   if (count <= 0) return "";
   return Array(count).fill(source).join(separator);
 }
-function format_time(time, format2) {
-  const date = new Date(time);
-  const monthNames = [
-    "January",
-    "February",
-    "March",
-    "April",
-    "May",
-    "June",
-    "July",
-    "August",
-    "September",
-    "October",
-    "November",
-    "December"
-  ];
-  const monthNamesShort = [
-    "Jan",
-    "Feb",
-    "Mar",
-    "Apr",
-    "May",
-    "Jun",
-    "Jul",
-    "Aug",
-    "Sep",
-    "Oct",
-    "Nov",
-    "Dec"
-  ];
-  const year = date.getUTCFullYear();
-  const month = date.getUTCMonth();
-  const day = date.getUTCDate();
-  const hours = date.getUTCHours();
-  const minutes = date.getUTCMinutes();
-  const seconds = date.getUTCSeconds();
-  const pad = (num, len = 2) => num.toString().padStart(len, "0");
-  const hours12 = hours % 12 || 12;
-  const ampm = hours < 12 ? "AM" : "PM";
-  const replacements = [
-    // Year (process yyyy before yy)
-    [/yyyy/g, year.toString()],
-    [/yy/g, year.toString().slice(-2)],
-    // Month (process MMMM before MMM before MM before M)
-    [/MMMM/g, monthNames[month]],
-    [/MMM/g, monthNamesShort[month]],
-    [/MM/g, pad(month + 1)],
-    [/M/g, (month + 1).toString()],
-    // Day (process dd before d)
-    [/dd/g, pad(day)],
-    [/d/g, day.toString()],
-    // Hours 24-hour (process HH before H)
-    [/HH/g, pad(hours)],
-    [/H/g, hours.toString()],
-    // Hours 12-hour (process hh before h)
-    [/hh/g, pad(hours12)],
-    [/h/g, hours12.toString()],
-    // Minutes (process mm before m)
-    [/mm/g, pad(minutes)],
-    [/m/g, minutes.toString()],
-    // Seconds (process ss before s)
-    [/ss/g, pad(seconds)],
-    [/s/g, seconds.toString()],
-    // AM/PM
-    [/a/g, ampm]
-  ];
-  let result = format2;
-  const tokens = [];
-  replacements.forEach(([pattern, value], index) => {
-    const token = `\uFFF0${index}\uFFF1`;
-    result = result.replace(pattern, token);
-    tokens[index] = value;
-  });
-  tokens.forEach((value, index) => {
-    const token = `\uFFF0${index}\uFFF1`;
-    result = result.replaceAll(token, value);
-  });
-  return result;
+function format_time(time, format2 = "yyyy-MM-dd'T'HH:mm:ssZ", timezone = "Etc/UTC") {
+  return formatDate(time, format2, timezone);
 }
 
 // src/color/index.ts
@@ -3394,16 +3841,16 @@ var teal = "#008080";
 var white = "#FFFFFF";
 var yellow = "#FFFF00";
 function from_gradient(value, bottom_value, top_value, bottom_color, top_color) {
-  const parseColor2 = (col2) => {
-    if (typeof col2 === "string") {
-      if (col2.startsWith("#")) {
-        const hex = col2.slice(1);
+  const parseColor2 = (col3) => {
+    if (typeof col3 === "string") {
+      if (col3.startsWith("#")) {
+        const hex = col3.slice(1);
         const r4 = parseInt(hex.slice(0, 2), 16);
         const g4 = parseInt(hex.slice(2, 4), 16);
         const b4 = parseInt(hex.slice(4, 6), 16);
         return [r4, g4, b4, 1];
       }
-      const match2 = col2.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)(?:,\s*([\d.]+))?\)/);
+      const match2 = col3.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)(?:,\s*([\d.]+))?\)/);
       if (match2) {
         return [
           parseInt(match2[1]),
@@ -3438,21 +3885,260 @@ function from_gradient(value, bottom_value, top_value, bottom_color, top_color)
 // src/time/index.ts
 var time_exports = {};
 __export(time_exports, {
+  dayofmonth: () => dayofmonth,
+  dayofweek: () => dayofweek,
+  hour: () => hour,
+  inSession: () => inSession2,
+  minute: () => minute,
+  month: () => month,
   now: () => now,
-  timestamp: () => timestamp
+  second: () => second,
+  timestamp: () => timestamp,
+  weekofyear: () => weekofyear,
+  year: () => year
 });
+
+// src/time/datestring.ts
+var MONTHS2 = ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"];
+var FULL_MONTHS = [
+  "january",
+  "february",
+  "march",
+  "april",
+  "may",
+  "june",
+  "july",
+  "august",
+  "september",
+  "october",
+  "november",
+  "december"
+];
+var ZONE_NAMES = {
+  ut: 0,
+  utc: 0,
+  gmt: 0,
+  est: -5,
+  edt: -4,
+  cst: -6,
+  cdt: -5,
+  mst: -7,
+  mdt: -6,
+  pst: -8,
+  pdt: -7
+};
+var TIME = String.raw`(\d{1,2}):(\d{2})(?::(\d{2})(?:\.(\d{1,3})\d*)?)?`;
+var ZONE = String.raw`(ut|utc|gmt|[ecmp][sd]t|(?:utc|gmt)?\s*[+-]\d{1,2}(?::?\d{2})?)`;
+var NUMERIC_ZONE = String.raw`([+-]\d{2}(?::?\d{2})?)`;
+var DATE = String.raw`(\d{4})([-/])(\d{1,2})\2(\d{1,2})`;
+var WEEKDAY = String.raw`(?:[a-z]{3,9},?\s+)?`;
+var ISO_T = new RegExp(String.raw`^${DATE}t${TIME}\s*${NUMERIC_ZONE}?$`, "i");
+var ISO = new RegExp(String.raw`^${DATE}(?:\s+${TIME})?\s*${ZONE}?$`, "i");
+var DAY_FIRST = new RegExp(String.raw`^${WEEKDAY}(\d{1,2})(?:\s+|-)([a-z]+)\.?,?(?:\s+|-)(\d{4})(?:,?\s+${TIME})?\s*${ZONE}?$`, "i");
+var MONTH_FIRST = new RegExp(String.raw`^${WEEKDAY}([a-z]+)\.?\s+(\d{1,2}),?\s+(\d{4})(?:,?\s+${TIME})?\s*${ZONE}?$`, "i");
+function monthNumber(name) {
+  const lower2 = name.toLowerCase();
+  const i = FULL_MONTHS.findIndex((full, k) => lower2.startsWith(MONTHS2[k]) && full.startsWith(lower2));
+  return i + 1;
+}
+function zoneMinutes(zone) {
+  if (!zone) return 0;
+  const lower2 = zone.toLowerCase().replace(/\s+/g, "");
+  const named = ZONE_NAMES[lower2];
+  if (named !== void 0) return named * 60;
+  const m = /^(?:utc|gmt)?([+-])(\d{1,2})(?::?(\d{2}))?$/.exec(lower2);
+  if (!m) return NaN;
+  const minutes = Number(m[2]) * 60 + (m[3] ? Number(m[3]) : 0);
+  return m[1] === "-" ? -minutes : minutes;
+}
+function parseDateString(dateString) {
+  const text = dateString.trim();
+  let year2, month2, day;
+  let rest;
+  let m;
+  if (m = ISO_T.exec(text) ?? ISO.exec(text)) {
+    [year2, month2, day] = [m[1], Number(m[3]), m[4]];
+    rest = m.slice(5);
+  } else if (m = DAY_FIRST.exec(text)) {
+    [day, month2, year2] = [m[1], monthNumber(m[2]), m[3]];
+    rest = m.slice(4);
+  } else if (m = MONTH_FIRST.exec(text)) {
+    [month2, day, year2] = [monthNumber(m[1]), m[2], m[3]];
+    rest = m.slice(4);
+  } else {
+    throw new SyntaxError(`Invalid date string "${dateString}": use RFC 2822 or ISO 8601 ("20 Feb 2020", "2020-02-20T14:48:00")`);
+  }
+  const [hour2 = "0", minute2 = "0", second2 = "0", millis = "0", zone] = rest;
+  const d = Number(day);
+  const h = Number(hour2);
+  const mi = Number(minute2);
+  const s = Number(second2);
+  const offset = zoneMinutes(zone);
+  const endOfDay = h === 24 && mi === 0 && s === 0 && Number(millis) === 0;
+  if (month2 < 1 || month2 > 12 || d < 1 || d > 31 || h > 23 && !endOfDay || mi > 59 || s > 59 || Number.isNaN(offset)) {
+    throw new SyntaxError(`Invalid date string "${dateString}": a field is out of range`);
+  }
+  const ms = Number(millis.padEnd(3, "0"));
+  return Date.UTC(Number(year2), month2 - 1, d, h, mi, s, ms) - offset * 6e4;
+}
+
+// src/time/session.ts
+var PERIOD = /^(\d{2})(\d{2})-(\d{2})(\d{2})$/;
+var sessions = /* @__PURE__ */ new Map();
+function parseSession(session) {
+  let parsed = sessions.get(session);
+  if (parsed) return parsed;
+  const invalid = () => new SyntaxError(`Invalid session "${session}": expected "HHmm-HHmm[,HHmm-HHmm...][:days]"`);
+  const text = session.trim() === "24x7" ? "0000-0000" : session.replace(/\s+/g, "");
+  const [periodText = "", dayText, extra] = text.split(":");
+  if (extra !== void 0 || periodText === "") throw invalid();
+  const periods = periodText.split(",").map((p) => {
+    const m = PERIOD.exec(p);
+    if (!m) throw invalid();
+    const [h1, m1, h2, m2] = [m[1], m[2], m[3], m[4]].map(Number);
+    if (h1 > 23 || h2 > 23 || m1 > 59 || m2 > 59) throw invalid();
+    return { start: h1 * 60 + m1, end: h2 * 60 + m2 };
+  });
+  const dayDigits = dayText ?? (periods.length > 1 ? "23456" : "1234567");
+  if (!/^[1-7]+$/.test(dayDigits)) throw invalid();
+  const days = new Array(8).fill(false);
+  for (const d of dayDigits) days[Number(d)] = true;
+  parsed = { periods, days };
+  sessions.set(session, parsed);
+  return parsed;
+}
+function inSession(time, session, timezone) {
+  if (Number.isNaN(time)) return false;
+  const { periods, days } = parseSession(session);
+  const f = zonedFields(time, timezone);
+  const minute2 = f.hour * 60 + f.minute;
+  const nextDay = f.dayOfWeek % 7 + 1;
+  for (const { start, end } of periods) {
+    if (start < end || start === 0 && end === 0) {
+      if (minute2 >= start && (minute2 < end || end === 0) && days[f.dayOfWeek]) return true;
+    } else {
+      if (minute2 >= start && days[nextDay]) return true;
+      if (minute2 < end && days[f.dayOfWeek]) return true;
+    }
+  }
+  return false;
+}
+
+// src/time/index.ts
 function now() {
   return Date.now();
 }
-function timestamp(year, month, day, hour, minute, second) {
-  return new Date(
-    year,
-    month - 1,
-    day,
-    hour || 0,
-    minute || 0,
-    second || 0
-  ).getTime();
+function timestamp(first2, ...rest) {
+  if (typeof first2 === "string") {
+    if (rest.length === 0) return parseDateString(first2);
+    const [year2, month3, day2, hour3, minute3, second3] = rest;
+    return zonedToUnix(first2, year2, month3, day2, hour3 ?? 0, minute3 ?? 0, second3 ?? 0);
+  }
+  const [month2, day, hour2, minute2, second2] = rest;
+  return new Date(first2, month2 - 1, day, hour2 || 0, minute2 || 0, second2 || 0).getTime();
+}
+function field(time, timezone, pick) {
+  return Number.isNaN(time) ? NaN : pick(zonedFields(time, timezone));
+}
+function year(time, timezone) {
+  return field(time, timezone, (f) => f.year);
+}
+function month(time, timezone) {
+  return field(time, timezone, (f) => f.month);
+}
+function dayofmonth(time, timezone) {
+  return field(time, timezone, (f) => f.day);
+}
+function dayofweek(time, timezone) {
+  return field(time, timezone, (f) => f.dayOfWeek);
+}
+function weekofyear(time, timezone) {
+  return field(time, timezone, (f) => {
+    const date = Date.UTC(f.year, f.month - 1, f.day);
+    const mondayBased = (f.dayOfWeek + 5) % 7;
+    const thursday = new Date(date + (3 - mondayBased) * 864e5);
+    const yearStart = Date.UTC(thursday.getUTCFullYear(), 0, 1);
+    return 1 + Math.floor((thursday.getTime() - yearStart) / (7 * 864e5));
+  });
+}
+function hour(time, timezone) {
+  return field(time, timezone, (f) => f.hour);
+}
+function minute(time, timezone) {
+  return field(time, timezone, (f) => f.minute);
+}
+function second(time, timezone) {
+  return field(time, timezone, (f) => f.second);
+}
+function inSession2(time, session, timezone) {
+  return inSession(time, session, timezone);
+}
+
+// src/timeframe/index.ts
+var timeframe_exports = {};
+__export(timeframe_exports, {
+  from_seconds: () => from_seconds,
+  in_seconds: () => in_seconds,
+  info: () => info
+});
+var SECONDS_PER_MINUTE = 60;
+var SECONDS_PER_DAY = 86400;
+var SECONDS_PER_WEEK = 604800;
+var SECONDS_PER_MONTH = 2628003;
+var SECONDS_365_DAYS = 365 * SECONDS_PER_DAY;
+var UNIT_SECONDS = {
+  S: 1,
+  "": SECONDS_PER_MINUTE,
+  D: SECONDS_PER_DAY,
+  W: SECONDS_PER_WEEK,
+  M: SECONDS_PER_MONTH
+};
+var SECOND_TIMEFRAMES = [1, 5, 10, 15, 30];
+function in_seconds(timeframe) {
+  const text = timeframe.trim();
+  if (text === "") {
+    throw new RangeError("timeframe.in_seconds() needs a timeframe: the chart timeframe is not known here");
+  }
+  const before = /^(\d*)([SDWMT]?)$/.exec(text);
+  const after = before ? null : /^([SDWMT])(\d+)$/.exec(text);
+  if (!before && !after) throw new RangeError(`Invalid timeframe "${timeframe}"`);
+  const [digits, unit] = before ? [before[1], before[2]] : [after[2], after[1]];
+  if (unit === "T") return NaN;
+  const multiplier = digits === "" ? 1 : Number(digits);
+  return multiplier * UNIT_SECONDS[unit];
+}
+function from_seconds(seconds) {
+  if (Number.isNaN(seconds)) throw new RangeError("timeframe.from_seconds() needs a number of seconds");
+  if (seconds >= SECONDS_365_DAYS) return "12M";
+  if (seconds > 0) {
+    if (seconds % SECONDS_PER_MONTH === 0) return `${seconds / SECONDS_PER_MONTH}M`;
+    if (seconds % SECONDS_PER_WEEK === 0) return `${seconds / SECONDS_PER_WEEK}W`;
+    if (seconds % SECONDS_PER_DAY === 0) return `${seconds / SECONDS_PER_DAY}D`;
+    if (seconds % SECONDS_PER_MINUTE === 0 && seconds < SECONDS_PER_DAY) return `${seconds / SECONDS_PER_MINUTE}`;
+  }
+  const second2 = SECOND_TIMEFRAMES.find((m) => seconds <= m);
+  if (second2 !== void 0) return `${second2}S`;
+  if (seconds < SECONDS_PER_DAY) return `${Math.ceil(seconds / SECONDS_PER_MINUTE)}`;
+  return `${Math.ceil(seconds / SECONDS_PER_DAY)}D`;
+}
+function info(timeframe) {
+  const text = timeframe.trim();
+  const m = /^(\d*)([SDWMT]?)$/.exec(text);
+  if (!m || text === "") throw new RangeError(`Invalid timeframe "${timeframe}"`);
+  const unit = m[2];
+  const multiplier = m[1] === "" ? 1 : Number(m[1]);
+  return {
+    period: unit === "" ? String(multiplier) : `${multiplier}${unit}`,
+    multiplier,
+    isintraday: unit === "" || unit === "S" || unit === "T",
+    isdaily: unit === "D",
+    isweekly: unit === "W",
+    ismonthly: unit === "M",
+    isminutes: unit === "",
+    isseconds: unit === "S",
+    isticks: unit === "T",
+    isdwm: unit === "D" || unit === "W" || unit === "M"
+  };
 }
 
 // src/matrix/index.ts
@@ -3464,14 +4150,14 @@ __export(matrix_exports, {
   col: () => col,
   columns: () => columns,
   concat: () => concat3,
-  copy: () => copy2,
+  copy: () => copy3,
   det: () => det,
   diff: () => diff,
   eigenvalues: () => eigenvalues,
   eigenvectors: () => eigenvectors,
   elements_count: () => elements_count,
   fill: () => fill2,
-  get: () => get2,
+  get: () => get3,
   inv: () => inv,
   is_antidiagonal: () => is_antidiagonal,
   is_antisymmetric: () => is_antisymmetric,
@@ -3520,7 +4206,7 @@ function new_matrix(rows2, columns2, initial_value) {
   }
   return { rows: rows2, columns: columns2, data };
 }
-function get2(id, row2, column) {
+function get3(id, row2, column) {
   if (row2 < 0 || row2 >= id.rows || column < 0 || column >= id.columns) {
     throw new Error(`Matrix index out of bounds: [${row2}, ${column}] for matrix of size [${id.rows}, ${id.columns}]`);
   }
@@ -3553,7 +4239,7 @@ function col(id, column_index) {
   }
   return id.data.map((r2) => r2[column_index]);
 }
-function copy2(id) {
+function copy3(id) {
   const newData = id.data.map((r2) => [...r2]);
   return {
     rows: id.rows,
@@ -3905,24 +4591,24 @@ function median3(id) {
   if (id.rows === 0 || id.columns === 0) {
     return NaN;
   }
-  const values = [];
+  const values2 = [];
   for (let i = 0; i < id.rows; i++) {
     for (let j = 0; j < id.columns; j++) {
       const val = id.data[i][j];
       if (val !== null && val !== void 0 && !isNaN(val)) {
-        values.push(val);
+        values2.push(val);
       }
     }
   }
-  if (values.length === 0) {
+  if (values2.length === 0) {
     return NaN;
   }
-  values.sort((a, b2) => a - b2);
-  const mid = Math.floor(values.length / 2);
-  if (values.length % 2 === 0) {
-    return (values[mid - 1] + values[mid]) / 2;
+  values2.sort((a, b2) => a - b2);
+  const mid = Math.floor(values2.length / 2);
+  if (values2.length % 2 === 0) {
+    return (values2[mid - 1] + values2[mid]) / 2;
   } else {
-    return values[mid];
+    return values2[mid];
   }
 }
 function mode3(id) {
@@ -4168,7 +4854,7 @@ function pow2(id, power) {
     base = inverse;
     p = -power;
   } else {
-    base = copy2(id);
+    base = copy3(id);
   }
   let result = createIdentity(n);
   while (p > 0) {
@@ -4197,31 +4883,31 @@ function det(id) {
   const a = id.data.map((row2) => [...row2]);
   let determinant = 1;
   let swapCount = 0;
-  for (let col2 = 0; col2 < n; col2++) {
-    let maxRow = col2;
-    let maxVal = Math.abs(a[col2][col2]);
-    for (let row2 = col2 + 1; row2 < n; row2++) {
-      const absVal = Math.abs(a[row2][col2]);
+  for (let col3 = 0; col3 < n; col3++) {
+    let maxRow = col3;
+    let maxVal = Math.abs(a[col3][col3]);
+    for (let row2 = col3 + 1; row2 < n; row2++) {
+      const absVal = Math.abs(a[row2][col3]);
       if (absVal > maxVal) {
         maxVal = absVal;
         maxRow = row2;
       }
     }
-    if (maxRow !== col2) {
-      const temp = a[col2];
-      a[col2] = a[maxRow];
+    if (maxRow !== col3) {
+      const temp = a[col3];
+      a[col3] = a[maxRow];
       a[maxRow] = temp;
       swapCount++;
     }
-    const pivot = a[col2][col2];
-    if (Math.abs(pivot) < EPSILON) {
+    const pivot2 = a[col3][col3];
+    if (Math.abs(pivot2) < EPSILON) {
       return 0;
     }
-    determinant *= pivot;
-    for (let row2 = col2 + 1; row2 < n; row2++) {
-      const factor = a[row2][col2] / pivot;
-      for (let j = col2; j < n; j++) {
-        a[row2][j] = a[row2][j] - factor * a[col2][j];
+    determinant *= pivot2;
+    for (let row2 = col3 + 1; row2 < n; row2++) {
+      const factor = a[row2][col3] / pivot2;
+      for (let j = col3; j < n; j++) {
+        a[row2][j] = a[row2][j] - factor * a[col3][j];
       }
     }
   }
@@ -4249,33 +4935,33 @@ function inv(id) {
     }
     aug.push(row2);
   }
-  for (let col2 = 0; col2 < n; col2++) {
-    let maxRow = col2;
-    let maxVal = Math.abs(aug[col2][col2]);
-    for (let row2 = col2 + 1; row2 < n; row2++) {
-      const absVal = Math.abs(aug[row2][col2]);
+  for (let col3 = 0; col3 < n; col3++) {
+    let maxRow = col3;
+    let maxVal = Math.abs(aug[col3][col3]);
+    for (let row2 = col3 + 1; row2 < n; row2++) {
+      const absVal = Math.abs(aug[row2][col3]);
       if (absVal > maxVal) {
         maxVal = absVal;
         maxRow = row2;
       }
     }
-    if (maxRow !== col2) {
-      const temp = aug[col2];
-      aug[col2] = aug[maxRow];
+    if (maxRow !== col3) {
+      const temp = aug[col3];
+      aug[col3] = aug[maxRow];
       aug[maxRow] = temp;
     }
-    const pivot = aug[col2][col2];
-    if (Math.abs(pivot) < EPSILON) {
+    const pivot2 = aug[col3][col3];
+    if (Math.abs(pivot2) < EPSILON) {
       return null;
     }
     for (let j = 0; j < 2 * n; j++) {
-      aug[col2][j] = aug[col2][j] / pivot;
+      aug[col3][j] = aug[col3][j] / pivot2;
     }
     for (let row2 = 0; row2 < n; row2++) {
-      if (row2 !== col2) {
-        const factor = aug[row2][col2];
+      if (row2 !== col3) {
+        const factor = aug[row2][col3];
         for (let j = 0; j < 2 * n; j++) {
-          aug[row2][j] = aug[row2][j] - factor * aug[col2][j];
+          aug[row2][j] = aug[row2][j] - factor * aug[col3][j];
         }
       }
     }
@@ -4338,11 +5024,11 @@ function rank(id) {
   const m = id.rows;
   const n = id.columns;
   let r2 = 0;
-  for (let col2 = 0; col2 < n && r2 < m; col2++) {
+  for (let col3 = 0; col3 < n && r2 < m; col3++) {
     let maxRow = r2;
-    let maxVal = Math.abs(a[r2][col2]);
+    let maxVal = Math.abs(a[r2][col3]);
     for (let row2 = r2 + 1; row2 < m; row2++) {
-      const absVal = Math.abs(a[row2][col2]);
+      const absVal = Math.abs(a[row2][col3]);
       if (absVal > maxVal) {
         maxVal = absVal;
         maxRow = row2;
@@ -4356,10 +5042,10 @@ function rank(id) {
       a[r2] = a[maxRow];
       a[maxRow] = temp;
     }
-    const pivot = a[r2][col2];
+    const pivot2 = a[r2][col3];
     for (let row2 = r2 + 1; row2 < m; row2++) {
-      const factor = a[row2][col2] / pivot;
-      for (let j = col2; j < n; j++) {
+      const factor = a[row2][col3] / pivot2;
+      for (let j = col3; j < n; j++) {
         a[row2][j] = a[row2][j] - factor * a[r2][j];
       }
     }
@@ -4567,29 +5253,29 @@ function inverseIteration(m, lambda) {
 function solveLinearSystem(a, b2) {
   const n = a.length;
   const aug = a.map((row2, i) => [...row2, b2[i]]);
-  for (let col2 = 0; col2 < n; col2++) {
-    let maxRow = col2;
-    let maxVal = Math.abs(aug[col2][col2]);
-    for (let row2 = col2 + 1; row2 < n; row2++) {
-      const absVal = Math.abs(aug[row2][col2]);
+  for (let col3 = 0; col3 < n; col3++) {
+    let maxRow = col3;
+    let maxVal = Math.abs(aug[col3][col3]);
+    for (let row2 = col3 + 1; row2 < n; row2++) {
+      const absVal = Math.abs(aug[row2][col3]);
       if (absVal > maxVal) {
         maxVal = absVal;
         maxRow = row2;
       }
     }
-    if (maxRow !== col2) {
-      const temp = aug[col2];
-      aug[col2] = aug[maxRow];
+    if (maxRow !== col3) {
+      const temp = aug[col3];
+      aug[col3] = aug[maxRow];
       aug[maxRow] = temp;
     }
-    const pivot = aug[col2][col2];
-    if (Math.abs(pivot) < EPSILON) {
+    const pivot2 = aug[col3][col3];
+    if (Math.abs(pivot2) < EPSILON) {
       continue;
     }
-    for (let row2 = col2 + 1; row2 < n; row2++) {
-      const factor = aug[row2][col2] / pivot;
-      for (let j = col2; j <= n; j++) {
-        aug[row2][j] = aug[row2][j] - factor * aug[col2][j];
+    for (let row2 = col3 + 1; row2 < n; row2++) {
+      const factor = aug[row2][col3] / pivot2;
+      for (let j = col3; j <= n; j++) {
+        aug[row2][j] = aug[row2][j] - factor * aug[col3][j];
       }
     }
   }
@@ -4621,8 +5307,8 @@ function kron(id1, id2) {
       for (let i2 = 0; i2 < m2; i2++) {
         for (let j2 = 0; j2 < n2; j2++) {
           const row2 = i1 * m2 + i2;
-          const col2 = j1 * n2 + j2;
-          data[row2][col2] = a * id2.data[i2][j2];
+          const col3 = j1 * n2 + j2;
+          data[row2][col3] = a * id2.data[i2][j2];
         }
       }
     }
@@ -4640,7 +5326,9 @@ function newtype2(rows2 = 0, columns2 = 0, initial_value) {
 // src/line/index.ts
 var line_exports = {};
 __export(line_exports, {
-  copy: () => copy3,
+  all: () => all2,
+  copy: () => copy4,
+  delete: () => delete_line,
   delete_line: () => delete_line,
   get_price: () => get_price,
   get_x1: () => get_x1,
@@ -4651,6 +5339,8 @@ __export(line_exports, {
   new_line: () => new_line2,
   set_color: () => set_color,
   set_extend: () => set_extend,
+  set_first_point: () => set_first_point,
+  set_second_point: () => set_second_point,
   set_style: () => set_style,
   set_width: () => set_width,
   set_x1: () => set_x1,
@@ -4661,18 +5351,78 @@ __export(line_exports, {
   set_y1: () => set_y1,
   set_y2: () => set_y2
 });
-function new_line2(x1, y1, x2, y2, xloc2 = "bar_index", extend = "none", lineColor, style, width) {
-  return {
+
+// src/drawing/registry.ts
+var DEFAULT_MAX_COUNT = 50;
+var SLACK = 5;
+var live = { line: [], label: [], box: [], polyline: [], linefill: [] };
+var limits = {
+  line: DEFAULT_MAX_COUNT,
+  label: DEFAULT_MAX_COUNT,
+  box: DEFAULT_MAX_COUNT,
+  polyline: DEFAULT_MAX_COUNT
+};
+var deleted = /* @__PURE__ */ new WeakSet();
+var COORDINATES = {
+  line: ["x1", "y1", "x2", "y2"],
+  label: ["x", "y"],
+  box: ["left", "top", "right", "bottom"],
+  polyline: [],
+  linefill: []
+};
+function markDeleted(kind, obj, explicit) {
+  deleted.add(obj);
+  for (const field2 of COORDINATES[kind]) obj[field2] = NaN;
+  if (kind === "line" && explicit) {
+    for (const fill3 of live.linefill.filter((f) => f.line1 === obj || f.line2 === obj)) remove3("linefill", fill3);
+  }
+}
+function register(kind, obj) {
+  const list = live[kind];
+  list.push(obj);
+  const max6 = limits[kind === "linefill" ? "line" : kind];
+  if (list.length > max6 + SLACK) {
+    for (const old of list.splice(0, list.length - max6)) markDeleted(kind, old, false);
+  }
+  return obj;
+}
+function remove3(kind, obj) {
+  const list = live[kind];
+  const index = list.indexOf(obj);
+  if (index !== -1) list.splice(index, 1);
+  if (!deleted.has(obj)) markDeleted(kind, obj, true);
+}
+function isDeleted(obj) {
+  return typeof obj === "object" && obj !== null && deleted.has(obj);
+}
+function all(kind) {
+  return [...live[kind]];
+}
+
+// src/line/index.ts
+function new_line2(...args) {
+  let x1, y1, x2, y2, rest;
+  if (typeof args[0] === "object" && args[0] !== null) {
+    const [p1, p2, ...others] = args;
+    const xloc3 = others[0] ?? "bar_index";
+    [x1, y1, x2, y2, rest] = [pointX(p1, xloc3), p1.price, pointX(p2, xloc3), p2.price, others];
+  } else {
+    [x1, y1, x2, y2] = args;
+    rest = args.slice(4);
+  }
+  const [xloc2, extend, lineColor, style, width, force_overlay] = rest;
+  return register("line", {
     x1,
     y1,
     x2,
     y2,
-    xloc: xloc2,
-    extend,
+    xloc: xloc2 ?? "bar_index",
+    extend: extend ?? "none",
     color: lineColor,
     style: style || "solid",
-    width: width || 1
-  };
+    width: width || 1,
+    force_overlay: force_overlay ?? false
+  });
 }
 function get_price(id, x) {
   const { x1, y1, x2, y2, extend, xloc: xloc2 } = id;
@@ -4711,64 +5461,97 @@ function get_y1(id) {
 function get_y2(id) {
   return id.y2;
 }
-function copy3(id) {
-  return { ...id };
+function copy4(id) {
+  return register("line", { ...id });
 }
 function set_x1(id, x) {
+  if (isDeleted(id)) return id;
   id.x1 = x;
   return id;
 }
 function set_x2(id, x) {
+  if (isDeleted(id)) return id;
   id.x2 = x;
   return id;
 }
 function set_y1(id, y) {
+  if (isDeleted(id)) return id;
   id.y1 = y;
   return id;
 }
 function set_y2(id, y) {
+  if (isDeleted(id)) return id;
   id.y2 = y;
   return id;
 }
 function set_xy1(id, x, y) {
+  if (isDeleted(id)) return id;
   id.x1 = x;
   id.y1 = y;
   return id;
 }
 function set_xy2(id, x, y) {
+  if (isDeleted(id)) return id;
   id.x2 = x;
   id.y2 = y;
   return id;
 }
 function set_xloc(id, x1, x2, xloc2) {
+  if (isDeleted(id)) return id;
   id.x1 = x1;
   id.x2 = x2;
   id.xloc = xloc2;
   return id;
 }
 function set_extend(id, extend) {
+  if (isDeleted(id)) return id;
   id.extend = extend;
   return id;
 }
 function set_color(id, lineColor) {
+  if (isDeleted(id)) return id;
   id.color = lineColor;
   return id;
 }
 function set_style(id, style) {
+  if (isDeleted(id)) return id;
   id.style = style;
   return id;
 }
 function set_width(id, width) {
+  if (isDeleted(id)) return id;
   id.width = width;
   return id;
 }
-function delete_line(_id) {
+function delete_line(id) {
+  remove3("line", id);
+}
+function pointX(point, xloc2) {
+  const x = xloc2 === "bar_time" ? point.time : point.index;
+  return x ?? NaN;
+}
+function all2() {
+  return all("line");
+}
+function set_first_point(id, point) {
+  if (isDeleted(id)) return id;
+  id.x1 = pointX(point, id.xloc);
+  id.y1 = point.price;
+  return id;
+}
+function set_second_point(id, point) {
+  if (isDeleted(id)) return id;
+  id.x2 = pointX(point, id.xloc);
+  id.y2 = point.price;
+  return id;
 }
 
 // src/box/index.ts
 var box_exports = {};
 __export(box_exports, {
-  copy: () => copy4,
+  all: () => all3,
+  copy: () => copy5,
+  delete: () => delete_box,
   delete_box: () => delete_box,
   get_bottom: () => get_bottom,
   get_left: () => get_left,
@@ -4781,6 +5564,7 @@ __export(box_exports, {
   set_border_style: () => set_border_style,
   set_border_width: () => set_border_width,
   set_bottom: () => set_bottom,
+  set_bottom_right_point: () => set_bottom_right_point,
   set_extend: () => set_extend2,
   set_left: () => set_left,
   set_lefttop: () => set_lefttop,
@@ -4789,21 +5573,49 @@ __export(box_exports, {
   set_text: () => set_text,
   set_text_color: () => set_text_color,
   set_text_font_family: () => set_text_font_family,
+  set_text_formatting: () => set_text_formatting,
   set_text_halign: () => set_text_halign,
   set_text_size: () => set_text_size,
   set_text_valign: () => set_text_valign,
   set_text_wrap: () => set_text_wrap,
   set_top: () => set_top,
+  set_top_left_point: () => set_top_left_point,
   set_xloc: () => set_xloc2
 });
-function new_box2(left, top, right, bottom, xloc2 = "bar_index", extend = "none", border_color, border_width, border_style, bgcolor, text, text_size, text_color, text_halign, text_valign, text_wrap, text_font_family) {
-  return {
+function new_box2(...args) {
+  let left, top, right, bottom, rest;
+  if (typeof args[0] === "object" && args[0] !== null) {
+    const [tl, br, ...others] = args;
+    const xloc3 = others[4] ?? "bar_index";
+    [left, top, right, bottom, rest] = [pointX2(tl, xloc3), tl.price, pointX2(br, xloc3), br.price, others];
+  } else {
+    [left, top, right, bottom] = args;
+    rest = args.slice(4);
+  }
+  const [
+    border_color,
+    border_width,
+    border_style,
+    extend,
+    xloc2,
+    bgcolor,
+    text,
+    text_size,
+    text_color,
+    text_halign,
+    text_valign,
+    text_wrap,
+    text_font_family,
+    force_overlay,
+    text_formatting
+  ] = rest;
+  return register("box", {
     left,
     top,
     right,
     bottom,
-    xloc: xloc2,
-    extend,
+    xloc: xloc2 ?? "bar_index",
+    extend: extend ?? "none",
     border_color,
     border_width: border_width || 1,
     border_style: border_style || "solid",
@@ -4814,8 +5626,10 @@ function new_box2(left, top, right, bottom, xloc2 = "bar_index", extend = "none"
     text_halign,
     text_valign,
     text_wrap,
-    text_font_family
-  };
+    text_font_family,
+    force_overlay: force_overlay ?? false,
+    text_formatting
+  });
 }
 function get_left(id) {
   return id.left;
@@ -4829,96 +5643,142 @@ function get_top(id) {
 function get_bottom(id) {
   return id.bottom;
 }
-function copy4(id) {
-  return { ...id };
+function copy5(id) {
+  return register("box", { ...id });
 }
 function set_left(id, left) {
+  if (isDeleted(id)) return id;
   id.left = left;
   return id;
 }
 function set_right(id, right) {
+  if (isDeleted(id)) return id;
   id.right = right;
   return id;
 }
 function set_top(id, top) {
+  if (isDeleted(id)) return id;
   id.top = top;
   return id;
 }
 function set_bottom(id, bottom) {
+  if (isDeleted(id)) return id;
   id.bottom = bottom;
   return id;
 }
 function set_lefttop(id, left, top) {
+  if (isDeleted(id)) return id;
   id.left = left;
   id.top = top;
   return id;
 }
 function set_rightbottom(id, right, bottom) {
+  if (isDeleted(id)) return id;
   id.right = right;
   id.bottom = bottom;
   return id;
 }
 function set_xloc2(id, left, right, xloc2) {
+  if (isDeleted(id)) return id;
   id.left = left;
   id.right = right;
   id.xloc = xloc2;
   return id;
 }
 function set_extend2(id, extend) {
+  if (isDeleted(id)) return id;
   id.extend = extend;
   return id;
 }
 function set_border_color(id, borderColor) {
+  if (isDeleted(id)) return id;
   id.border_color = borderColor;
   return id;
 }
 function set_border_width(id, width) {
+  if (isDeleted(id)) return id;
   id.border_width = width;
   return id;
 }
 function set_border_style(id, style) {
+  if (isDeleted(id)) return id;
   id.border_style = style;
   return id;
 }
 function set_bgcolor(id, bgColor) {
+  if (isDeleted(id)) return id;
   id.bgcolor = bgColor;
   return id;
 }
 function set_text(id, text) {
+  if (isDeleted(id)) return id;
   id.text = text;
   return id;
 }
 function set_text_color(id, textColor) {
+  if (isDeleted(id)) return id;
   id.text_color = textColor;
   return id;
 }
-function set_text_size(id, size2) {
-  id.text_size = size2;
+function set_text_size(id, size3) {
+  if (isDeleted(id)) return id;
+  id.text_size = size3;
   return id;
 }
 function set_text_halign(id, align) {
+  if (isDeleted(id)) return id;
   id.text_halign = align;
   return id;
 }
 function set_text_valign(id, align) {
+  if (isDeleted(id)) return id;
   id.text_valign = align;
   return id;
 }
 function set_text_wrap(id, wrap) {
+  if (isDeleted(id)) return id;
   id.text_wrap = wrap;
   return id;
 }
 function set_text_font_family(id, font) {
+  if (isDeleted(id)) return id;
   id.text_font_family = font;
   return id;
 }
-function delete_box(_id) {
+function delete_box(id) {
+  remove3("box", id);
+}
+function pointX2(point, xloc2) {
+  const x = xloc2 === "bar_time" ? point.time : point.index;
+  return x ?? NaN;
+}
+function all3() {
+  return all("box");
+}
+function set_top_left_point(id, point) {
+  if (isDeleted(id)) return id;
+  id.left = pointX2(point, id.xloc);
+  id.top = point.price;
+  return id;
+}
+function set_bottom_right_point(id, point) {
+  if (isDeleted(id)) return id;
+  id.right = pointX2(point, id.xloc);
+  id.bottom = point.price;
+  return id;
+}
+function set_text_formatting(id, formatting) {
+  if (isDeleted(id)) return id;
+  id.text_formatting = formatting;
+  return id;
 }
 
 // src/label/index.ts
 var label_exports = {};
 __export(label_exports, {
-  copy: () => copy5,
+  all: () => all4,
+  copy: () => copy6,
+  delete: () => delete_label,
   delete_label: () => delete_label,
   get_text: () => get_text,
   get_x: () => get_x,
@@ -4926,10 +5786,12 @@ __export(label_exports, {
   new: () => new_label2,
   new_label: () => new_label2,
   set_color: () => set_color2,
+  set_point: () => set_point,
   set_size: () => set_size,
   set_style: () => set_style2,
   set_text: () => set_text2,
   set_text_font_family: () => set_text_font_family2,
+  set_text_formatting: () => set_text_formatting2,
   set_textalign: () => set_textalign,
   set_textcolor: () => set_textcolor,
   set_tooltip: () => set_tooltip,
@@ -4939,21 +5801,47 @@ __export(label_exports, {
   set_y: () => set_y,
   set_yloc: () => set_yloc
 });
-function new_label2(x, y, text, xloc2 = "bar_index", yloc = "price", labelColor, style, textcolor, size2, textalign, tooltip, text_font_family) {
-  return {
+function new_label2(...args) {
+  let x, y, rest;
+  if (typeof args[0] === "object" && args[0] !== null) {
+    const point = args[0];
+    rest = args.slice(1);
+    x = pointX3(point, rest[1] ?? "bar_index");
+    y = point.price;
+  } else {
+    [x, y] = args;
+    rest = args.slice(2);
+  }
+  const [
+    text,
+    xloc2,
+    yloc,
+    labelColor,
+    style,
+    textcolor,
+    size3,
+    textalign,
+    tooltip,
+    text_font_family,
+    force_overlay,
+    text_formatting
+  ] = rest;
+  return register("label", {
     x,
     y,
-    xloc: xloc2,
-    yloc,
+    xloc: xloc2 ?? "bar_index",
+    yloc: yloc ?? "price",
     text,
     tooltip,
     color: labelColor,
     style,
     textcolor,
-    size: size2,
+    size: size3,
     textalign,
-    text_font_family
-  };
+    text_font_family,
+    force_overlay: force_overlay ?? false,
+    text_formatting
+  });
 }
 function get_x(id) {
   return id.x;
@@ -4964,70 +5852,103 @@ function get_y(id) {
 function get_text(id) {
   return id.text;
 }
-function copy5(id) {
-  return { ...id };
+function copy6(id) {
+  return register("label", { ...id });
 }
 function set_x(id, x) {
+  if (isDeleted(id)) return id;
   id.x = x;
   return id;
 }
 function set_y(id, y) {
+  if (isDeleted(id)) return id;
   id.y = y;
   return id;
 }
 function set_xy(id, x, y) {
+  if (isDeleted(id)) return id;
   id.x = x;
   id.y = y;
   return id;
 }
 function set_xloc3(id, x, xloc2) {
+  if (isDeleted(id)) return id;
   id.x = x;
   id.xloc = xloc2;
   return id;
 }
-function set_yloc(id, y, yloc) {
-  id.y = y;
+function set_yloc(id, yloc) {
+  if (isDeleted(id)) return id;
   id.yloc = yloc;
   return id;
 }
 function set_text2(id, text) {
+  if (isDeleted(id)) return id;
   id.text = text;
   return id;
 }
 function set_tooltip(id, tooltip) {
+  if (isDeleted(id)) return id;
   id.tooltip = tooltip;
   return id;
 }
 function set_color2(id, labelColor) {
+  if (isDeleted(id)) return id;
   id.color = labelColor;
   return id;
 }
 function set_textcolor(id, textColor) {
+  if (isDeleted(id)) return id;
   id.textcolor = textColor;
   return id;
 }
 function set_style2(id, style) {
+  if (isDeleted(id)) return id;
   id.style = style;
   return id;
 }
-function set_size(id, size2) {
-  id.size = size2;
+function set_size(id, size3) {
+  if (isDeleted(id)) return id;
+  id.size = size3;
   return id;
 }
 function set_textalign(id, align) {
+  if (isDeleted(id)) return id;
   id.textalign = align;
   return id;
 }
 function set_text_font_family2(id, font) {
+  if (isDeleted(id)) return id;
   id.text_font_family = font;
   return id;
 }
-function delete_label(_id) {
+function delete_label(id) {
+  remove3("label", id);
+}
+function pointX3(point, xloc2) {
+  const x = xloc2 === "bar_time" ? point.time : point.index;
+  return x ?? NaN;
+}
+function all4() {
+  return all("label");
+}
+function set_point(id, point) {
+  if (isDeleted(id)) return id;
+  id.x = pointX3(point, id.xloc);
+  id.y = point.price;
+  return id;
+}
+function set_text_formatting2(id, formatting) {
+  if (isDeleted(id)) return id;
+  id.text_formatting = formatting;
+  return id;
 }
 
 // src/linefill/index.ts
 var linefill_exports = {};
 __export(linefill_exports, {
+  all: () => all5,
+  delete: () => delete_linefill,
   delete_linefill: () => delete_linefill,
   get_line1: () => get_line1,
   get_line2: () => get_line2,
@@ -5036,11 +5957,11 @@ __export(linefill_exports, {
   set_color: () => set_color3
 });
 function new_linefill2(line1, line2, fillColor) {
-  return {
+  return register("linefill", {
     line1,
     line2,
     color: fillColor
-  };
+  });
 }
 function get_line1(id) {
   return id.line1;
@@ -5049,16 +5970,21 @@ function get_line2(id) {
   return id.line2;
 }
 function set_color3(id, fillColor) {
+  if (isDeleted(id)) return id;
   id.color = fillColor;
   return id;
 }
-function delete_linefill(_id) {
+function delete_linefill(id) {
+  remove3("linefill", id);
+}
+function all5() {
+  return all("linefill");
 }
 
 // src/chartpoint/index.ts
 var chartpoint_exports = {};
 __export(chartpoint_exports, {
-  copy: () => copy6,
+  copy: () => copy7,
   from_index: () => from_index,
   from_time: () => from_time,
   new: () => new_point,
@@ -5085,7 +6011,7 @@ function from_index(index, price) {
     price
   };
 }
-function copy6(point) {
+function copy7(point) {
   return {
     time: point.time,
     index: point.index,
@@ -5096,6 +6022,7 @@ function copy6(point) {
 // src/polyline/index.ts
 var polyline_exports = {};
 __export(polyline_exports, {
+  all: () => all6,
   clear_all: () => clear_all,
   delete: () => delete_polyline,
   delete_polyline: () => delete_polyline,
@@ -5105,7 +6032,6 @@ __export(polyline_exports, {
   reset_id_counter: () => reset_id_counter
 });
 var polylineIdCounter = 0;
-var allPolylines = [];
 function generateId() {
   return `polyline_${++polylineIdCounter}`;
 }
@@ -5132,28 +6058,39 @@ function new_polyline(points, curved = false, closed = false, xloc2 = "bar_index
     line_width,
     force_overlay
   };
-  allPolylines.push(polyline);
-  return polyline;
+  return register("polyline", polyline);
 }
 function delete_polyline(id) {
-  const index = allPolylines.findIndex((p) => p.id === id.id);
-  if (index !== -1) {
-    allPolylines.splice(index, 1);
-  }
+  remove3("polyline", id);
 }
 function get_all() {
-  return [...allPolylines];
+  return all("polyline");
+}
+function all6() {
+  return all("polyline");
 }
 function clear_all() {
-  allPolylines.length = 0;
+  for (const p of all("polyline")) remove3("polyline", p);
 }
 function reset_id_counter() {
   polylineIdCounter = 0;
 }
 
+// src/text/index.ts
+var text_exports = {};
+__export(text_exports, {
+  format_bold: () => format_bold,
+  format_italic: () => format_italic,
+  format_none: () => format_none
+});
+var format_none = 0;
+var format_bold = 1;
+var format_italic = 2;
+
 // src/ta-series.ts
 var ta_series_exports = {};
 __export(ta_series_exports, {
+  accdist: () => accdist2,
   alma: () => alma2,
   atr: () => atr2,
   barssince: () => barssince2,
@@ -5176,6 +6113,7 @@ __export(ta_series_exports, {
   highestbars: () => highestbars2,
   hma: () => hma2,
   ichimoku: () => ichimoku2,
+  iii: () => iii2,
   kc: () => kc2,
   kcw: () => kcw2,
   linreg: () => linreg2,
@@ -5188,11 +6126,15 @@ __export(ta_series_exports, {
   min: () => min5,
   mode: () => mode4,
   mom: () => mom2,
+  nvi: () => nvi2,
+  obv: () => obv2,
   percentile_linear_interpolation: () => percentile_linear_interpolation3,
   percentile_nearest_rank: () => percentile_nearest_rank3,
   percentrank: () => percentrank3,
   pivothigh: () => pivothigh2,
   pivotlow: () => pivotlow2,
+  pvi: () => pvi2,
+  pvt: () => pvt2,
   range: () => range3,
   rci: () => rci2,
   rising: () => rising2,
@@ -5211,9 +6153,12 @@ __export(ta_series_exports, {
   valuewhen: () => valuewhen2,
   variance: () => variance3,
   vwap: () => vwap2,
+  vwapBands: () => vwapBands,
   vwma: () => vwma2,
+  wad: () => wad2,
   wma: () => wma2,
   wpr: () => wpr2,
+  wvad: () => wvad2,
   zigzag: () => zigzag2
 });
 function sma2(source, length2) {
@@ -5264,11 +6209,9 @@ function bb2(source, length2, mult2) {
   const lowerSeries = Series.fromArray(bars, lowerVals);
   return [upperSeries, basisSeries, lowerSeries];
 }
-function stdev3(source, length2) {
+function stdev3(source, length2, biased = true) {
   const bars = source.bars;
-  const sourceValues = source.toArray();
-  const result = stdev(sourceValues, length2);
-  return Series.fromArray(bars, result);
+  return Series.fromArray(bars, stdev(source.toArray(), length2, biased));
 }
 function atr2(bars, length2) {
   const high = bars.map((b2) => b2.high);
@@ -5284,6 +6227,40 @@ function tr2(bars, handle_na = false) {
   const result = tr(handle_na, high, low, close);
   return Series.fromArray(bars, result);
 }
+var col2 = (bars, f) => bars.map((b2) => b2[f] ?? NaN);
+function obv2(bars) {
+  return Series.fromArray(bars, obv(col2(bars, "close"), col2(bars, "volume")));
+}
+function pvt2(bars) {
+  return Series.fromArray(bars, pvt(col2(bars, "close"), col2(bars, "volume")));
+}
+function accdist2(bars) {
+  return Series.fromArray(
+    bars,
+    accdist(col2(bars, "high"), col2(bars, "low"), col2(bars, "close"), col2(bars, "volume"))
+  );
+}
+function nvi2(bars) {
+  return Series.fromArray(bars, nvi(col2(bars, "close"), col2(bars, "volume")));
+}
+function pvi2(bars) {
+  return Series.fromArray(bars, pvi(col2(bars, "close"), col2(bars, "volume")));
+}
+function iii2(bars) {
+  return Series.fromArray(
+    bars,
+    iii(col2(bars, "high"), col2(bars, "low"), col2(bars, "close"), col2(bars, "volume"))
+  );
+}
+function wad2(bars) {
+  return Series.fromArray(bars, wad(col2(bars, "high"), col2(bars, "low"), col2(bars, "close")));
+}
+function wvad2(bars) {
+  return Series.fromArray(
+    bars,
+    wvad(col2(bars, "open"), col2(bars, "high"), col2(bars, "low"), col2(bars, "close"), col2(bars, "volume"))
+  );
+}
 function stoch2(source, high, low, length2) {
   const bars = source.bars;
   const sourceValues = source.toArray();
@@ -5375,12 +6352,14 @@ function supertrend2(bars, factor, atrLength) {
   const dirSeries = Series.fromArray(bars, dirVals);
   return [trendSeries, dirSeries];
 }
-function vwap2(source, volume) {
+function vwap2(source, volume, anchor) {
   const bars = source.bars;
-  const sourceValues = source.toArray();
-  const volumeValues = volume.toArray();
-  const result = vwap(sourceValues, volumeValues);
-  return Series.fromArray(bars, result);
+  return Series.fromArray(bars, vwap(source.toArray(), volume.toArray(), anchor?.toArray()));
+}
+function vwapBands(source, volume, anchor, stdev_mult) {
+  const bars = source.bars;
+  const [m, u, l] = vwap(source.toArray(), volume.toArray(), anchor?.toArray(), stdev_mult);
+  return [Series.fromArray(bars, m), Series.fromArray(bars, u), Series.fromArray(bars, l)];
 }
 function ichimoku2(bars, conversionPeriods, basePeriods, laggingSpan2Periods, displacement) {
   const high = bars.map((b2) => b2.high);
@@ -5565,10 +6544,9 @@ function kcw2(bars, source, length2 = 20, mult2 = 2, useTrueRange = true) {
   const result = kcw(source.toArray(), length2, mult2, useTrueRange, high, low, close);
   return Series.fromArray(bars, result);
 }
-function range3(high, low) {
-  const bars = high.bars;
-  const result = range(high.toArray(), low.toArray());
-  return Series.fromArray(bars, result);
+function range3(source, length2) {
+  const bars = source.bars;
+  return Series.fromArray(bars, range(source.toArray(), length2));
 }
 function highestbars2(source, length2) {
   const bars = source.bars;
@@ -5580,15 +6558,13 @@ function lowestbars2(source, length2) {
   const result = lowestbars(source.toArray(), length2);
   return Series.fromArray(bars, result);
 }
-function max5(source1, source2) {
-  const bars = source1.bars;
-  const result = max(source1.toArray(), source2.toArray());
-  return Series.fromArray(bars, result);
+function max5(source) {
+  const bars = source.bars;
+  return Series.fromArray(bars, max(source.toArray()));
 }
-function min5(source1, source2) {
-  const bars = source1.bars;
-  const result = min(source1.toArray(), source2.toArray());
-  return Series.fromArray(bars, result);
+function min5(source) {
+  const bars = source.bars;
+  return Series.fromArray(bars, min(source.toArray()));
 }
 function cog2(source, length2 = 10) {
   const bars = source.bars;
@@ -5671,6 +6647,15 @@ var ta = {
   lowestbars: lowestbars2,
   max: max5,
   min: min5,
+  vwapBands,
+  obv: obv2,
+  pvt: pvt2,
+  accdist: accdist2,
+  nvi: nvi2,
+  pvi: pvi2,
+  iii: iii2,
+  wad: wad2,
+  wvad: wvad2,
   cog: cog2,
   mode: mode4,
   percentile_linear_interpolation: percentile_linear_interpolation3,
@@ -5680,11 +6665,23 @@ var ta = {
 
 // src/utils/index.ts
 function isNA(value) {
-  return value === null || value === void 0 || Number.isNaN(value);
+  return value === null || value === void 0 || Number.isNaN(value) || isDeleted(value);
 }
 function nz(value, defaultValue = 0) {
   return isNA(value) ? defaultValue : value;
 }
+function fixnan(source) {
+  let last2;
+  let seen = false;
+  return source.map((v) => {
+    if (!isNA(v)) {
+      last2 = v;
+      seen = true;
+      return v;
+    }
+    return seen ? last2 : v;
+  });
+}
 function ohlcFromBars(bars) {
   return {
     open: bars.map((b2) => b2.open),
@@ -6076,16 +7073,78 @@ var input = {
       title: options.title,
       options: options.options
     };
+  },
+  /**
+   * Create a timeframe input parameter (PineScript `input.timeframe`)
+   * @param defaultValue - Default timeframe string ("60", "1D", "W"); "" means the chart timeframe
+   * @param options - Additional options (title, options for dropdown)
+   * @returns Input value object
+   *
+   * @example
+   * ```typescript
+   * const htf = input.timeframe('1D', { title: 'Higher timeframe' });
+   * console.log(htf.value); // '1D'
+   * ```
+   */
+  timeframe(defaultValue, options = {}) {
+    return {
+      type: "timeframe",
+      defaultValue,
+      value: defaultValue,
+      title: options.title,
+      options: options.options
+    };
+  },
+  /**
+   * Create a session input parameter (PineScript `input.session`)
+   * @param defaultValue - Default session string ("0930-1600", "0930-1600:23456")
+   * @param options - Additional options (title, options for dropdown)
+   * @returns Input value object
+   *
+   * @example
+   * ```typescript
+   * const rth = input.session('0930-1600', { title: 'Regular hours' });
+   * console.log(rth.value); // '0930-1600'
+   * ```
+   */
+  session(defaultValue, options = {}) {
+    return {
+      type: "session",
+      defaultValue,
+      value: defaultValue,
+      title: options.title,
+      options: options.options
+    };
+  },
+  /**
+   * Create a date/time input parameter (PineScript `input.time`)
+   * @param defaultValue - Default UNIX time in milliseconds, e.g. `time.timestamp('2024-01-01')`
+   * @param options - Additional options (title)
+   * @returns Input value object
+   *
+   * @example
+   * ```typescript
+   * const start = input.time(time.timestamp('2024-01-01'), { title: 'Start' });
+   * console.log(start.value); // 1704067200000
+   * ```
+   */
+  time(defaultValue, options = {}) {
+    return {
+      type: "time",
+      defaultValue,
+      value: defaultValue,
+      title: options.title
+    };
   }
 };
 Object.freeze(input);
 
 // src/plot.ts
-function plot(values, times, options = {}) {
+function plot(values2, times, options = {}) {
   const result = [];
   const offset = options.offset ?? 0;
-  for (let i = 0; i < values.length; i++) {
-    const value = values[i];
+  for (let i = 0; i < values2.length; i++) {
+    const value = values2[i];
     const timeIndex = i + offset;
     if (value === null || value === void 0 || Number.isNaN(value)) {
       continue;
@@ -6100,10 +7159,10 @@ function plot(values, times, options = {}) {
   }
   return result;
 }
-function createPlot(id, values, times, options = {}) {
+function createPlot(id, values2, times, options = {}) {
   return {
     id,
-    data: plot(values, times, options),
+    data: plot(values2, times, options),
     options
   };
 }
@@ -6344,6 +7403,42 @@ function input_string(defval, title, options) {
   const value = context2.inputs.getValue(id);
   return typeof value === "string" ? value : defval;
 }
+function registerOnce(config) {
+  const context2 = getContext();
+  if (!registeredInputs.has(config.id)) {
+    context2.inputs.registerInput(config);
+    registeredInputs.set(config.id, true);
+    if (autoRecalculateEnabled) {
+      context2.inputs.onInputChange((changedId) => {
+        if (changedId === config.id) {
+          recalculate();
+        }
+      });
+    }
+  }
+  return context2.inputs.getValue(config.id);
+}
+function input_timeframe(defval, title, options) {
+  if (!getContext()) {
+    return defval;
+  }
+  const value = registerOnce({ id: generateInputId(title, defval, "timeframe"), type: "timeframe", defval, title, options });
+  return typeof value === "string" ? value : defval;
+}
+function input_session(defval, title, options) {
+  if (!getContext()) {
+    return defval;
+  }
+  const value = registerOnce({ id: generateInputId(title, defval, "session"), type: "session", defval, title, options });
+  return typeof value === "string" ? value : defval;
+}
+function input_time(defval, title) {
+  if (!getContext()) {
+    return defval;
+  }
+  const value = registerOnce({ id: generateInputId(title, defval, "time"), type: "time", defval, title });
+  return typeof value === "number" ? value : defval;
+}
 function input_source(defval, title) {
   const context2 = getContext();
   if (!context2) {
@@ -6566,7 +7661,7 @@ var SimpleInputAdapter = class {
         validatedValue = Math.floor(validatedValue);
       }
     }
-    if (config.type === "string" && config.options && typeof value === "string") {
+    if ((config.type === "string" || config.type === "timeframe" || config.type === "session") && config.options && typeof value === "string") {
       if (!config.options.includes(value)) {
         return;
       }
@@ -6614,8 +7709,8 @@ var SimpleInputAdapter = class {
 };
 
 // src/index.ts
-var VERSION = "0.3.0";
-var info = {
+var VERSION = "0.6.0";
+var info2 = {
   name: "OakScriptJS",
   version: VERSION,
   description: "Simplified PineScript-like library - Series + TA functions",
@@ -6628,8 +7723,8 @@ var info = {
     minimal: "No DSL layer - complexity in transpiler"
   },
   namespaces: {
-    core: ["ta", "math", "array", "str", "color", "time", "matrix"],
-    drawing: ["line", "box", "label", "linefill", "chartPoint", "polyline"],
+    core: ["ta", "math", "array", "map", "str", "color", "time", "timeframe", "matrix"],
+    drawing: ["line", "box", "label", "linefill", "chartPoint", "polyline", "text"],
     runtime: ["setContext", "plot", "hline", "input_*"],
     indicator: ["indicator", "input", "plotHelper", "createPlot"]
   }
@@ -6665,6 +7760,7 @@ export {
   cum2 as cum,
   ema2 as ema,
   exp,
+  fixnan,
   floor,
   getClose,
   getContext,
@@ -6674,18 +7770,22 @@ export {
   getSourceSeries,
   hline,
   indicator,
-  info,
+  info2 as info,
   input,
   input_bool,
   input_float,
   input_int,
+  input_session,
   input_source,
   input_string,
+  input_time,
+  input_timeframe,
   label_exports as label,
   line_exports as line,
   linefill_exports as linefill,
   log,
   macd2 as macd,
+  map_exports as map,
   math_exports as math,
   matrix_exports as matrix,
   max2 as max,
@@ -6713,7 +7813,9 @@ export {
   ta_series_exports as ta,
   ta_exports as taCore,
   tan,
+  text_exports as text,
   time_exports as time,
+  timeframe_exports as timeframe,
   tr2 as tr,
   vwap2 as vwap,
   xloc,