oakscriptjs 0.10.1 → 0.11.1

package/dist/cjs/str/floatingdecimal.js

@@ -0,0 +1,298 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var floatingdecimal_exports = {};
+__export(floatingdecimal_exports, {
+  convertDouble: () => convertDouble,
+  javaFixedDigits: () => javaFixedDigits
+});
+module.exports = __toCommonJS(floatingdecimal_exports);
+const EXP_SHIFT = 52;
+const MAX_SMALL_BIN_EXP = 62;
+const MIN_SMALL_BIN_EXP = -21;
+const N_5_BITS = [0, 3, 5, 7, 10, 12, 14, 17, 19, 21, 24, 26, 28, 31, 33, 35, 38, 40, 42, 45, 47, 49, 52, 54, 56, 59, 61];
+const INSIGNIFICANT_DIGITS = [
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  2,
+  2,
+  2,
+  3,
+  3,
+  3,
+  3,
+  4,
+  4,
+  4,
+  5,
+  5,
+  5,
+  6,
+  6,
+  6,
+  6,
+  7,
+  7,
+  7,
+  8,
+  8,
+  8,
+  9,
+  9,
+  9,
+  9,
+  10,
+  10,
+  10,
+  11,
+  11,
+  11,
+  12,
+  12,
+  12,
+  12,
+  13,
+  13,
+  13,
+  14,
+  14,
+  14,
+  15,
+  15,
+  15,
+  15,
+  16,
+  16,
+  16,
+  17,
+  17,
+  17,
+  18,
+  18,
+  18,
+  19
+];
+const LONG_5_POW_LENGTH = 27;
+const view = new DataView(new ArrayBuffer(8));
+const int32 = (v) => BigInt.asIntN(32, v);
+const int64 = (v) => BigInt.asIntN(64, v);
+function trailingZeros(v) {
+  let n = 0;
+  while ((v & 1n) === 0n) {
+    v >>= 1n;
+    n++;
+  }
+  return n;
+}
+function estimateDecExp(fractBits, binExp) {
+  view.setBigUint64(0, 1023n << 52n | fractBits & 0xfffffffffffffn);
+  const d2 = view.getFloat64(0);
+  const d = (d2 - 1.5) * 0.289529654 + 0.176091259 + binExp * 0.301029995663981;
+  const r = Math.trunc(d);
+  return d < 0 && r !== d ? r - 1 : r;
+}
+function convertDouble(x) {
+  view.setFloat64(0, Math.abs(x));
+  const bits = view.getBigUint64(0);
+  let fractBits = bits & 0xfffffffffffffn;
+  let binExp = Number(bits >> 52n & 0x7ffn);
+  if (binExp === 0 && fractBits === 0n) return { digits: "0", decExponent: 1, roundedUp: false, exact: false };
+  let nSignificantBits;
+  if (binExp === 0) {
+    const leadingZeros = 64 - fractBits.toString(2).length;
+    const shift = leadingZeros - (63 - EXP_SHIFT);
+    fractBits <<= BigInt(shift);
+    binExp = 1 - shift;
+    nSignificantBits = 64 - leadingZeros;
+  } else {
+    fractBits |= 1n << 52n;
+    nSignificantBits = EXP_SHIFT + 1;
+  }
+  binExp -= 1023;
+  const tailZeros = trailingZeros(fractBits);
+  const nFractBits = EXP_SHIFT + 1 - tailZeros;
+  const nTinyBits = Math.max(0, nFractBits - binExp - 1);
+  if (binExp <= MAX_SMALL_BIN_EXP && binExp >= MIN_SMALL_BIN_EXP && nTinyBits < LONG_5_POW_LENGTH && nFractBits + N_5_BITS[nTinyBits] < 64 && nTinyBits === 0) {
+    const p2 = binExp - nSignificantBits - 1;
+    const insignificant = binExp > nSignificantBits && p2 > 1 && p2 < INSIGNIFICANT_DIGITS.length ? INSIGNIFICANT_DIGITS[p2] : 0;
+    let lvalue = binExp >= EXP_SHIFT ? fractBits << BigInt(binExp - EXP_SHIFT) : fractBits >> BigInt(EXP_SHIFT - binExp);
+    if (insignificant !== 0) {
+      const pow10 = 10n ** BigInt(insignificant);
+      const residue = lvalue % pow10;
+      lvalue /= pow10;
+      if (residue >= pow10 >> 1n) lvalue++;
+    }
+    const s = lvalue.toString();
+    return { digits: s.replace(/0+$/, ""), decExponent: insignificant + s.length, roundedUp: false, exact: false };
+  }
+  let decExp = estimateDecExp(fractBits, binExp);
+  const B5 = Math.max(0, -decExp);
+  let B2 = B5 + nTinyBits + binExp;
+  const S5 = Math.max(0, decExp);
+  let S2 = S5 + nTinyBits;
+  const M5 = B5;
+  let M2 = B2 - nSignificantBits;
+  fractBits >>= BigInt(tailZeros);
+  B2 -= nFractBits - 1;
+  const common2factor = Math.min(B2, S2);
+  B2 -= common2factor;
+  S2 -= common2factor;
+  M2 -= common2factor;
+  if (nFractBits === 1) M2 -= 1;
+  if (M2 < 0) {
+    B2 -= M2;
+    S2 -= M2;
+    M2 = 0;
+  }
+  const digits = [];
+  let low;
+  let high;
+  let lowDigitDifference;
+  let exact;
+  const Bbits = nFractBits + B2 + (B5 < N_5_BITS.length ? N_5_BITS[B5] : B5 * 3);
+  const tenSbits = S2 + 1 + (S5 + 1 < N_5_BITS.length ? N_5_BITS[S5 + 1] : (S5 + 1) * 3);
+  const minTwo = decExp < -3 || decExp >= 8;
+  if (Bbits < 64 && tenSbits < 64) {
+    const wrap = Bbits < 32 && tenSbits < 32 ? int32 : int64;
+    let b = wrap(fractBits * 5n ** BigInt(B5) << BigInt(B2));
+    const s = wrap(5n ** BigInt(S5) << BigInt(S2));
+    let m = wrap(5n ** BigInt(M5) << BigInt(M2));
+    const tens = wrap(s * 10n);
+    let q = Number(b / s);
+    b = wrap(10n * (b % s));
+    m = wrap(m * 10n);
+    low = b < m;
+    high = wrap(b + m) > tens;
+    if (q === 0 && !high) decExp--;
+    else digits.push(q);
+    if (minTwo) high = low = false;
+    while (!low && !high) {
+      q = Number(b / s);
+      b = wrap(10n * (b % s));
+      m = wrap(m * 10n);
+      if (m > 0n) {
+        low = b < m;
+        high = wrap(b + m) > tens;
+      } else {
+        low = true;
+        high = true;
+      }
+      digits.push(q);
+    }
+    lowDigitDifference = wrap((b << 1n) - tens);
+    exact = b === 0n;
+  } else {
+    let b = fractBits * 5n ** BigInt(B5) << BigInt(B2);
+    const s = 5n ** BigInt(S5) << BigInt(S2);
+    let m = 5n ** BigInt(M5 + 1) << BigInt(M2 + 1);
+    const tens = s * 10n;
+    let q = Number(b / s);
+    b = b % s * 10n;
+    low = b < m;
+    high = b + m >= tens;
+    if (q === 0 && !high) decExp--;
+    else digits.push(q);
+    if (minTwo) high = low = false;
+    while (!low && !high) {
+      q = Number(b / s);
+      b = b % s * 10n;
+      m *= 10n;
+      low = b < m;
+      high = b + m >= tens;
+      digits.push(q);
+    }
+    lowDigitDifference = high && low ? (b << 1n) - tens : 0n;
+    exact = b === 0n;
+  }
+  let decExponent = decExp + 1;
+  let roundedUp = false;
+  const roundup = () => {
+    let i = digits.length - 1;
+    while (digits[i] === 9 && i > 0) digits[i--] = 0;
+    if (digits[i] === 9) {
+      decExponent += 1;
+      digits[0] = 1;
+      return;
+    }
+    digits[i] += 1;
+    roundedUp = true;
+  };
+  if (high) {
+    if (!low) roundup();
+    else if (lowDigitDifference === 0n) {
+      if (digits[digits.length - 1] % 2 !== 0) roundup();
+    } else if (lowDigitDifference > 0n) roundup();
+  }
+  const text = digits.join("").replace(/0+$/, "");
+  return { digits: text || "0", decExponent, roundedUp, exact };
+}
+function javaFixedDigits(x, maxFrac) {
+  if (x === 0) return { digits: "", intLen: 0 };
+  const c = convertDouble(x);
+  const digits = [...c.digits].map(Number);
+  let decimalAt = c.decExponent;
+  const n = digits.length;
+  if (decimalAt > 0 && decimalAt < 8) {
+    if (n <= decimalAt) digits.push(...Array(decimalAt - n + 1).fill(0));
+  } else if (decimalAt <= -3 || decimalAt >= 8) {
+    if (n === 1) digits.push(0);
+  }
+  let count = digits.length;
+  const shouldRoundUp = (keep2) => {
+    if (keep2 >= count) return false;
+    if (digits[keep2] > 5) return true;
+    if (digits[keep2] !== 5) return false;
+    if (keep2 === count - 1) {
+      if (c.exact) return keep2 > 0 && digits[keep2 - 1] % 2 !== 0;
+      return !c.roundedUp;
+    }
+    for (let i = keep2 + 1; i < count; i++) if (digits[i] !== 0) return true;
+    return false;
+  };
+  if (-decimalAt > maxFrac) return { digits: "", intLen: 0 };
+  if (-decimalAt === maxFrac) {
+    return shouldRoundUp(0) ? { digits: "1", intLen: decimalAt + 1 } : { digits: "", intLen: 0 };
+  }
+  while (count > 1 && digits[count - 1] === 0) count--;
+  let keep = maxFrac + decimalAt;
+  if (keep >= 0 && keep < count) {
+    if (shouldRoundUp(keep)) {
+      do {
+        keep--;
+        if (keep < 0) {
+          digits[0] = 1;
+          decimalAt++;
+          keep = 0;
+          break;
+        }
+        digits[keep] += 1;
+      } while (digits[keep] > 9);
+      keep++;
+    }
+    count = keep;
+    while (count > 1 && digits[count - 1] === 0) count--;
+  }
+  const text = digits.slice(0, count).join("").replace(/0+$/, "");
+  return { digits: text, intLen: text ? decimalAt : 0 };
+}
+//# sourceMappingURL=floatingdecimal.js.map

package/dist/cjs/str/floatingdecimal.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/str/floatingdecimal.ts"],
+  "sourcesContent": ["/**\n * Decimal digits of a double as PineScript's plain `str.tostring` produces them.\n *\n * PineScript formats a number without a format with the digits of the classic binary to decimal conversion of the\n * JVM (the one `Double.toString` used before Java 19), then rounds them to 10 decimals half to even, with two\n * flags of the conversion deciding a tie on the last digit: digits that were rounded up are not rounded up again,\n * digits that were cut on a '5' are. These digits are not always the shortest ones: 78195689105219552 keeps all\n * its digits (the shortest form is 78195689105219550), and 1990736.000001111 has 16 digits where rounding the exact\n * value would give 1990736.0000011111 (#174).\n */\n\n/** Digits d1d2d3... of |x| = 0.d1d2d3... \u00D7 10^decExponent, with the flags of the conversion. */\nexport interface ConvertedDigits {\n  digits: string;\n  decExponent: number;\n  /** The last digit was rounded up */\n  roundedUp: boolean;\n  /** The digits are the exact value of the double */\n  exact: boolean;\n}\n\nconst EXP_SHIFT = 52;\nconst MAX_SMALL_BIN_EXP = 62;\nconst MIN_SMALL_BIN_EXP = -21;\n// approximately ceil(log2(5^i))\nconst N_5_BITS = [0, 3, 5, 7, 10, 12, 14, 17, 19, 21, 24, 26, 28, 31, 33, 35, 38, 40, 42, 45, 47, 49, 52, 54, 56, 59, 61];\n// number of decimal digits of 2^i minus one, for i < 64\nconst INSIGNIFICANT_DIGITS = [\n  0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 8, 8, 8, 9, 9, 9, 9, 10, 10, 10,\n  11, 11, 11, 12, 12, 12, 12, 13, 13, 13, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 17, 17, 17, 18, 18, 18, 19,\n];\nconst LONG_5_POW_LENGTH = 27;\nconst view = new DataView(new ArrayBuffer(8));\n\nconst int32 = (v: bigint): bigint => BigInt.asIntN(32, v);\nconst int64 = (v: bigint): bigint => BigInt.asIntN(64, v);\n\nfunction trailingZeros(v: bigint): number {\n  let n = 0;\n  while ((v & 1n) === 0n) {\n    v >>= 1n;\n    n++;\n  }\n  return n;\n}\n\n/** floor(log10(x)) estimate of the conversion (it can be one too high). */\nfunction estimateDecExp(fractBits: bigint, binExp: number): number {\n  view.setBigUint64(0, (1023n << 52n) | (fractBits & 0xfffffffffffffn));\n  const d2 = view.getFloat64(0);\n  const d = (d2 - 1.5) * 0.289529654 + 0.176091259 + binExp * 0.301029995663981;\n  // the conversion truncates toward zero and corrects negative non-integers down\n  const r = Math.trunc(d);\n  return d < 0 && r !== d ? r - 1 : r;\n}\n\n/** Digits of a positive finite double, as the JVM converter gives them. */\nexport function convertDouble(x: number): ConvertedDigits {\n  view.setFloat64(0, Math.abs(x));\n  const bits = view.getBigUint64(0);\n  let fractBits = bits & 0xfffffffffffffn;\n  let binExp = Number((bits >> 52n) & 0x7ffn);\n  if (binExp === 0 && fractBits === 0n) return { digits: '0', decExponent: 1, roundedUp: false, exact: false };\n  let nSignificantBits: number;\n  if (binExp === 0) {\n    const leadingZeros = 64 - fractBits.toString(2).length;\n    const shift = leadingZeros - (63 - EXP_SHIFT);\n    fractBits <<= BigInt(shift);\n    binExp = 1 - shift;\n    nSignificantBits = 64 - leadingZeros;\n  } else {\n    fractBits |= 1n << 52n;\n    nSignificantBits = EXP_SHIFT + 1;\n  }\n  binExp -= 1023;\n\n  const tailZeros = trailingZeros(fractBits);\n  const nFractBits = EXP_SHIFT + 1 - tailZeros;\n  const nTinyBits = Math.max(0, nFractBits - binExp - 1);\n\n  // an integer that fits in a long: its digits, the low ones rounded away when they are not significant\n  if (\n    binExp <= MAX_SMALL_BIN_EXP &&\n    binExp >= MIN_SMALL_BIN_EXP &&\n    nTinyBits < LONG_5_POW_LENGTH &&\n    nFractBits + N_5_BITS[nTinyBits]! < 64 &&\n    nTinyBits === 0\n  ) {\n    const p2 = binExp - nSignificantBits - 1;\n    const insignificant = binExp > nSignificantBits && p2 > 1 && p2 < INSIGNIFICANT_DIGITS.length ? INSIGNIFICANT_DIGITS[p2]! : 0;\n    let lvalue = binExp >= EXP_SHIFT ? fractBits << BigInt(binExp - EXP_SHIFT) : fractBits >> BigInt(EXP_SHIFT - binExp);\n    if (insignificant !== 0) {\n      const pow10 = 10n ** BigInt(insignificant);\n      const residue = lvalue % pow10;\n      lvalue /= pow10;\n      if (residue >= pow10 >> 1n) lvalue++;\n    }\n    const s = lvalue.toString();\n    return { digits: s.replace(/0+$/, ''), decExponent: insignificant + s.length, roundedUp: false, exact: false };\n  }\n\n  let decExp = estimateDecExp(fractBits, binExp);\n  const B5 = Math.max(0, -decExp);\n  let B2 = B5 + nTinyBits + binExp;\n  const S5 = Math.max(0, decExp);\n  let S2 = S5 + nTinyBits;\n  const M5 = B5;\n  let M2 = B2 - nSignificantBits;\n\n  fractBits >>= BigInt(tailZeros);\n  B2 -= nFractBits - 1;\n  const common2factor = Math.min(B2, S2);\n  B2 -= common2factor;\n  S2 -= common2factor;\n  M2 -= common2factor;\n  // an exact power of two: the next smaller double is half as far\n  if (nFractBits === 1) M2 -= 1;\n  if (M2 < 0) {\n    B2 -= M2;\n    S2 -= M2;\n    M2 = 0;\n  }\n\n  const digits: number[] = [];\n  let low: boolean;\n  let high: boolean;\n  let lowDigitDifference: bigint;\n  let exact: boolean;\n  const Bbits = nFractBits + B2 + (B5 < N_5_BITS.length ? N_5_BITS[B5]! : B5 * 3);\n  const tenSbits = S2 + 1 + (S5 + 1 < N_5_BITS.length ? N_5_BITS[S5 + 1]! : (S5 + 1) * 3);\n  // two digits at least in the exponent form\n  const minTwo = decExp < -3 || decExp >= 8;\n\n  if (Bbits < 64 && tenSbits < 64) {\n    // int or long arithmetic, with its overflows\n    const wrap = Bbits < 32 && tenSbits < 32 ? int32 : int64;\n    let b = wrap((fractBits * 5n ** BigInt(B5)) << BigInt(B2));\n    const s = wrap(5n ** BigInt(S5) << BigInt(S2));\n    let m = wrap(5n ** BigInt(M5) << BigInt(M2));\n    const tens = wrap(s * 10n);\n    let q = Number(b / s);\n    b = wrap(10n * (b % s));\n    m = wrap(m * 10n);\n    low = b < m;\n    high = wrap(b + m) > tens;\n    if (q === 0 && !high) decExp--;\n    else digits.push(q);\n    if (minTwo) high = low = false;\n    while (!low && !high) {\n      q = Number(b / s);\n      b = wrap(10n * (b % s));\n      m = wrap(m * 10n);\n      if (m > 0n) {\n        low = b < m;\n        high = wrap(b + m) > tens;\n      } else {\n        low = true;\n        high = true;\n      }\n      digits.push(q);\n    }\n    lowDigitDifference = wrap((b << 1n) - tens);\n    exact = b === 0n;\n  } else {\n    let b = (fractBits * 5n ** BigInt(B5)) << BigInt(B2);\n    const s = 5n ** BigInt(S5) << BigInt(S2);\n    let m = 5n ** BigInt(M5 + 1) << BigInt(M2 + 1);\n    const tens = s * 10n;\n    let q = Number(b / s);\n    b = (b % s) * 10n;\n    low = b < m;\n    high = b + m >= tens;\n    if (q === 0 && !high) decExp--;\n    else digits.push(q);\n    if (minTwo) high = low = false;\n    while (!low && !high) {\n      q = Number(b / s);\n      b = (b % s) * 10n;\n      m *= 10n;\n      low = b < m;\n      high = b + m >= tens;\n      digits.push(q);\n    }\n    lowDigitDifference = high && low ? (b << 1n) - tens : 0n;\n    exact = b === 0n;\n  }\n\n  let decExponent = decExp + 1;\n  let roundedUp = false;\n  const roundup = (): void => {\n    let i = digits.length - 1;\n    while (digits[i] === 9 && i > 0) digits[i--] = 0;\n    if (digits[i] === 9) {\n      decExponent += 1;\n      digits[0] = 1;\n      return;\n    }\n    digits[i]! += 1;\n    roundedUp = true;\n  };\n  if (high) {\n    if (!low) roundup();\n    else if (lowDigitDifference === 0n) {\n      if (digits[digits.length - 1]! % 2 !== 0) roundup();\n    } else if (lowDigitDifference > 0n) roundup();\n  }\n  const text = digits.join('').replace(/0+$/, '');\n  return { digits: text || '0', decExponent, roundedUp, exact };\n}\n\n/**\n * `|x|` with at most `maxFrac` decimals, as the JVM's decimal formatter rounds the converted digits (half to even;\n * a tie on the last converted digit is decided by the conversion flags). Returns the digits and the position of the\n * decimal point (value = 0.digits \u00D7 10^intLen); \"\" for zero.\n */\nexport function javaFixedDigits(x: number, maxFrac: number): { digits: string; intLen: number } {\n  if (x === 0) return { digits: '', intLen: 0 };\n  const c = convertDouble(x);\n  const digits = [...c.digits].map(Number);\n  let decimalAt = c.decExponent;\n  // the formatter reads the conversion's text, which ends in \".0\" when no digit follows the point (\"5.0E-11\",\n  // \"120.0\"): that zero is a digit for the tie test below (5e-11 to 10 decimals gives 0)\n  const n = digits.length;\n  if (decimalAt > 0 && decimalAt < 8) {\n    if (n <= decimalAt) digits.push(...Array<number>(decimalAt - n + 1).fill(0));\n  } else if (decimalAt <= -3 || decimalAt >= 8) {\n    if (n === 1) digits.push(0);\n  }\n  let count = digits.length;\n\n  const shouldRoundUp = (keep: number): boolean => {\n    if (keep >= count) return false;\n    if (digits[keep]! > 5) return true;\n    if (digits[keep] !== 5) return false;\n    if (keep === count - 1) {\n      if (c.exact) return keep > 0 && digits[keep - 1]! % 2 !== 0;\n      return !c.roundedUp;\n    }\n    for (let i = keep + 1; i < count; i++) if (digits[i] !== 0) return true;\n    return false;\n  };\n\n  if (-decimalAt > maxFrac) return { digits: '', intLen: 0 };\n  if (-decimalAt === maxFrac) {\n    return shouldRoundUp(0) ? { digits: '1', intLen: decimalAt + 1 } : { digits: '', intLen: 0 };\n  }\n  while (count > 1 && digits[count - 1] === 0) count--;\n  let keep = maxFrac + decimalAt;\n  if (keep >= 0 && keep < count) {\n    if (shouldRoundUp(keep)) {\n      do {\n        keep--;\n        if (keep < 0) {\n          digits[0] = 1;\n          decimalAt++;\n          keep = 0;\n          break;\n        }\n        digits[keep]! += 1;\n      } while (digits[keep]! > 9);\n      keep++;\n    }\n    count = keep;\n    while (count > 1 && digits[count - 1] === 0) count--;\n  }\n  const text = digits.slice(0, count).join('').replace(/0+$/, '');\n  return { digits: text, intLen: text ? decimalAt : 0 };\n}\n"],
+  "mappings": "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",
+  "names": ["keep"]
+}

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

@@ -37,7 +37,10 @@ export declare function length(str: simple_string): int;
  *
  * @remarks
  * As in PineScript:
- * - without format, numbers show up to 10 decimals ("0.3333333333"); 1e21 and more use "1E21"
+ * - without format, numbers show up to 10 decimals ("0.3333333333"): the digits of the JVM's binary to decimal
+ *   conversion, rounded half to even, a tie on the last converted digit decided by the conversion
+ *   (82325.10000000005 gives "82325.1", with the format "#.##########" "82325.1000000001"; 1791662400001 / 900000
+ *   gives "1990736.000001111"; 78195689105219552 keeps its 17 digits); 1e21 and more use "1E21"
  * - patterns round half away from zero on the shortest decimal form: 1.005 with "#.##" gives "1.01";
  *   at most 16 decimals from 1e-3 up (0.0012345678901234567 with 20 '#' decimals gives "0.0012345678901235")
  * - "pos;neg" patterns: a negative number takes the text of the negative subpattern ("#.##;(#.##)": "(3.5)")

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/str/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/str/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAKH,OAAO,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAErF;;;;;;;;;;;GAWG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,aAAa,GAAG,GAAG,CAE9C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,KAAK,EAAE,UAAU,CAAC,EAAE,KAAK,GAAG,MAAM,CAgDxG;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,aAAa,GAAG,KAAK,GAAG,IAAI,CASzD;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,aAAa,EAAE,KAAK,EAAE,UAAU,EAAE,GAAG,CAAC,EAAE,UAAU,GAAG,MAAM,CAGzF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CAEhD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CAEhD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,EAAE,aAAa,GAAG,IAAI,CAExE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,GAAG,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,EAAE,aAAa,GAAG,GAAG,CAGlE;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE,WAAW,EAAE,aAAa,EAAE,UAAU,GAAE,UAAc,GAAG,MAAM,CAcpI;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE,WAAW,EAAE,aAAa,GAAG,MAAM,CAE5G;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,aAAa,EAAE,SAAS,EAAE,aAAa,GAAG,MAAM,EAAE,CAG5E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,MAAM,CAAC,GAAG,OAAO,EAAE,aAAa,EAAE,GAAG,MAAM,CAE1D;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,MAAM,CAAC,SAAS,EAAE,aAAa,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,MAAM,CAEvE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,EAAE,aAAa,GAAG,IAAI,CAE1E;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,EAAE,aAAa,GAAG,IAAI,CAExE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,aAAa,EAAE,GAAG,EAAE,UAAU,GAAG,MAAM,CAElE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,IAAI,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CAE/C;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CAEnD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CAEpD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,KAAK,CAAC,MAAM,EAAE,aAAa,EAAE,KAAK,EAAE,aAAa,GAAG,aAAa,GAAG,IAAI,CAGvF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,MAAM,CAAC,MAAM,EAAE,aAAa,EAAE,KAAK,EAAE,UAAU,EAAE,SAAS,GAAE,aAAkB,GAAG,MAAM,GAAG,IAAI,CAI7G;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,GAAE,aAAwC,EAAE,QAAQ,GAAE,aAAyB,GAAG,MAAM,CAE3I"}

package/dist/cjs/str/index.js

@@ -49,6 +49,7 @@ function length(str) {
   return str.length;
 }
 function tostring(value, format2, mintick, pricescale) {
+  if (Array.isArray(value)) return "[" + value.map((v) => tostring(v, format2, mintick, pricescale)).join(", ") + "]";
   if (typeof value !== "number") return String(value);
   if (Number.isNaN(value)) return format2 === "percent" ? "NaN%" : "NaN";
   if (!Number.isFinite(value)) {
@@ -59,7 +60,7 @@ function tostring(value, format2, mintick, pricescale) {
     if (Math.abs(value) >= 1e21 && Number.isFinite(value)) {
       return String(value).replace("e+", "E").replace(/\.0+E/, "E");
     }
-    return (0, import_numberformat.formatNumber)(value, "#.##########", "halfUpShortest");
+    return (0, import_numberformat.formatNumber)(value, "#.##########", "halfEvenConverted");
   }
   switch (format2) {
     case "percent":

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/str/index.ts"],
-  "sourcesContent": ["/**\n * String namespace\n * Mirrors PineScript's str.* functions for string manipulation and analysis.\n *\n * @remarks\n * All string functions in this namespace follow PineScript v6 API specifications.\n * String operations are case-sensitive unless otherwise specified.\n *\n * @version 6\n */\n\nimport { formatNumber, tickScale } from './numberformat.js';\nimport { formatMessage } from './messageformat.js';\nimport { formatDate } from './dateformat.js';\nimport type { int, bool, float, simple_int, simple_string } from '../types/index.js';\n\n/**\n * Returns the length of a string.\n *\n * @param str - The string to measure\n * @returns The number of characters in the string\n *\n * @example\n * ```typescript\n * str.length(\"Hello\") // Returns: 5\n * str.length(\"\") // Returns: 0\n * ```\n */\nexport function length(str: simple_string): int {\n  return str.length;\n}\n\n/**\n * Converts a value to its string representation (PineScript `str.tostring`).\n *\n * @param value - The value to convert (number, boolean, string, etc.)\n * @param format - Optional number format: a pattern (\"#.##\", \"#,###.00\", \"0.00%\", \"0.00E0\", \"#.##;(#.##)\") or\n *   `format.percent` (\"percent\"), `format.volume` (\"volume\"), `format.mintick` (\"mintick\"),\n *   `format.price` / `format.inherit`\n * @param mintick - Tick size for `format.mintick` (PineScript `syminfo.mintick`, implicit there). Not part of the\n *   PineScript signature: the core function cannot see the chart, so pass it, as for `math.round_to_mintick`\n * @param pricescale - Price scale of the symbol for `format.mintick` (PineScript `syminfo.pricescale`), needed for a\n *   symbol priced in fractions (32 for a 1/32 tick). Default: 10^(decimals of `mintick`)\n * @returns String representation of the value\n *\n * @remarks\n * As in PineScript:\n * - without format, numbers show up to 10 decimals (\"0.3333333333\"); 1e21 and more use \"1E21\"\n * - patterns round half away from zero on the shortest decimal form: 1.005 with \"#.##\" gives \"1.01\";\n *   at most 16 decimals from 1e-3 up (0.0012345678901234567 with 20 '#' decimals gives \"0.0012345678901235\")\n * - \"pos;neg\" patterns: a negative number takes the text of the negative subpattern (\"#.##;(#.##)\": \"(3.5)\")\n * - \"#\" is an optional digit (\"1.5\" with \"#.##\"), \"0\" a required digit (\"1.50\" with \"0.00\"),\n *   \",\" groups thousands, \"%\" multiplies by 100, 'text' is literal text\n * - `format.percent` shows 2 decimals and \"%\" without multiplying; `format.volume` uses K, M, B, T\n * - `format.price` and `format.inherit` give \"price1\" / \"inherit1\" in PineScript: they are patterns\n *   without digit characters, and oakscriptjs does the same\n * - `format.mintick` shows floor(log10(pricescale)) decimals, zeros included (\"1.00\", \"0.40\" for tick 0.01), and\n *   rounds in two steps, with mintick = minmove / pricescale: the double quotient `|x| / (1 / pricescale)` half away\n *   from zero (140.355 / 0.01 = 14035.499999999998 gives \"140.35\", where `math.round_to_mintick` gives 140.36),\n *   then `floor(units / minmove + 0.5)` ticks (tick 0.02: 0.005 gives \"0.02\", -0.01 gives \"0.00\"). With a\n *   pricescale that is no power of 10 the tick value is then rounded half even to those decimals (1/32: 25.25 gives\n *   \"25.2\", -0.02 gives \"-0.0\"). It throws without `mintick`\n * - na gives \"NaN\" (\"NaN%\" with `format.percent`); an infinity gives \"NaN\" too (\"NaN%\" for `format.percent`,\n *   \"NaNT\" for `format.volume`), except `format.mintick`, which gives \"Infinity\" / \"-Infinity\"\n *\n * @example\n * ```typescript\n * str.tostring(123) // \"123\"\n * str.tostring(1.5, \"#.##\") // \"1.5\"\n * str.tostring(0.5, \"#.00\") // \".50\"\n * str.tostring(12345.678, format.volume) // \"12.346K\"\n * ```\n */\nexport function tostring(value: any, format?: simple_string, mintick?: float, pricescale?: float): string {\n  if (typeof value !== 'number') return String(value);\n  if (Number.isNaN(value)) return format === 'percent' ? 'NaN%' : 'NaN';\n  if (!Number.isFinite(value)) {\n    // the chart formatter has no infinity: NaN with the format's suffix\n    if (format === 'mintick') return String(value);\n    return format === 'percent' ? 'NaN%' : format === 'volume' ? 'NaNT' : 'NaN';\n  }\n  if (format === undefined || format === '') {\n    if (Math.abs(value) >= 1e21 && Number.isFinite(value)) {\n      return String(value).replace('e+', 'E').replace(/\\.0+E/, 'E');\n    }\n    return formatNumber(value, '#.##########', 'halfUpShortest');\n  }\n  switch (format) {\n    case 'percent':\n      return formatNumber(value, '0.00', 'halfUpShortest') + '%';\n    case 'volume': {\n      const abs = Math.abs(value);\n      for (const [size, unit] of [[1e12, 'T'], [1e9, 'B'], [1e6, 'M'], [1e3, 'K']] as const) {\n        if (abs >= size) return formatNumber(value / size, '#.###', 'halfUpShortest') + unit;\n      }\n      return formatNumber(value, '#', 'halfUpShortest');\n    }\n    case 'mintick': {\n      if (mintick === undefined) {\n        throw new Error('str.tostring(x, format.mintick) needs the tick size: pass it as str.tostring(x, format.mintick, syminfo.mintick)');\n      }\n      const [minmove, scale] = tickScale(mintick, pricescale);\n      const decimals = Math.floor(Math.log10(scale) + 1e-9);\n      const mask = decimals > 0 ? '0.' + '0'.repeat(decimals) : '0';\n      if (!(minmove >= 1)) return formatNumber(value, mask, 'halfUpShortest');\n      // 1. the double quotient |x| / (1 / pricescale), half away from zero (not math.round_to_mintick's exact decimal)\n      const scaled = Math.abs(value) / (1 / scale);\n      let units = Math.trunc(scaled);\n      if (scaled - units >= 0.5) units++;\n      // 2. to the tick, a half going up (minmove 2: -0.01 gives \"0.00\", 0.01 gives \"0.02\")\n      const ticks = Math.floor((value < 0 ? -units : units) / minmove + 0.5);\n      // 3. the tick value at the scale's decimals; a negative one keeps its sign when it prints as zero (\"-0.0\")\n      const text = formatNumber((Math.abs(ticks) * minmove) / scale, mask, 'halfEvenExact');\n      return ticks < 0 ? '-' + text : text;\n    }\n    default:\n      return formatNumber(value, format, 'halfUpShortest');\n  }\n}\n\n/**\n * Converts a string to a number (float).\n *\n * @param str - The string to convert\n * @returns The numeric value, or null (na) if conversion fails\n *\n * @remarks\n * As in PineScript:\n * - The whole text must be a number: a sign, digits and one optional \".\" (\"0.5\", \".5\", \"5.\", \"-12\"); \"12abc\" is na\n * - Scientific notation (\"1e3\"), \"Infinity\", \"NaN\", hexadecimal, \"1,000\" give na\n * - The characters U+0000 to U+0020 (space, tab, line feed...) around the number are ignored; other spaces\n *   (no-break space U+00A0, U+3000) give na\n *\n * @example\n * ```typescript\n * str.tonumber(\"123\") // Returns: 123\n * str.tonumber(\"45.67\") // Returns: 45.67\n * str.tonumber(\"abc\") // Returns: null\n * str.tonumber(\"12abc\") // Returns: null\n * str.tonumber(\"1e3\") // Returns: null\n * ```\n */\nexport function tonumber(str: simple_string): float | null {\n  // remove the characters U+0000..U+0020 at both ends\n  let start = 0;\n  let end = str.length;\n  while (start < end && str.charCodeAt(start) <= 0x20) start++;\n  while (end > start && str.charCodeAt(end - 1) <= 0x20) end--;\n  const text = str.slice(start, end);\n  if (!/^[+-]?(?:\\d+\\.?\\d*|\\.\\d+)$/.test(text)) return null;\n  return parseFloat(text);\n}\n\n/**\n * Extracts a substring from a string.\n *\n * @param str - The source string\n * @param begin - Starting index (0-based, inclusive)\n * @param end - Ending index (0-based, exclusive). If omitted, extracts to end of string\n * @returns The extracted substring\n *\n * @remarks\n * - An na `end` (NaN / null) is a runtime error in PineScript: it throws\n * - If begin > end, indices are swapped (JavaScript behavior)\n * - Negative indices are treated as 0\n * - Indices beyond string length return empty string\n *\n * @example\n * ```typescript\n * str.substring(\"hello world\", 0, 5) // Returns: \"hello\"\n * str.substring(\"hello world\", 6) // Returns: \"world\"\n * str.substring(\"test\", 1, 3) // Returns: \"es\"\n * ```\n */\nexport function substring(str: simple_string, begin: simple_int, end?: simple_int): string {\n  if (end === null || Number.isNaN(end)) throw new Error('str.substring: the end position is na');\n  return str.substring(begin, end);\n}\n\n/**\n * Converts all characters in a string to uppercase.\n *\n * @param str - The string to convert\n * @returns The uppercase string\n *\n * @example\n * ```typescript\n * str.upper(\"hello\") // Returns: \"HELLO\"\n * str.upper(\"Hello World\") // Returns: \"HELLO WORLD\"\n * str.upper(\"test123\") // Returns: \"TEST123\"\n * ```\n */\nexport function upper(str: simple_string): string {\n  return str.toUpperCase();\n}\n\n/**\n * Converts all characters in a string to lowercase.\n *\n * @param str - The string to convert\n * @returns The lowercase string\n *\n * @example\n * ```typescript\n * str.lower(\"HELLO\") // Returns: \"hello\"\n * str.lower(\"Hello World\") // Returns: \"hello world\"\n * str.lower(\"TEST123\") // Returns: \"test123\"\n * ```\n */\nexport function lower(str: simple_string): string {\n  return str.toLowerCase();\n}\n\n/**\n * Checks if a string contains a substring.\n *\n * @param source - The string to search in\n * @param str - The substring to search for\n * @returns True if source contains str, false otherwise\n *\n * @remarks\n * - Search is case-sensitive\n * - Empty string is contained in any string\n *\n * @example\n * ```typescript\n * str.contains(\"hello world\", \"world\") // Returns: true\n * str.contains(\"hello world\", \"World\") // Returns: false (case-sensitive)\n * str.contains(\"test\", \"xyz\") // Returns: false\n * ```\n */\nexport function contains(source: simple_string, str: simple_string): bool {\n  return source.includes(str);\n}\n\n/**\n * Returns the position of the first occurrence of a substring.\n *\n * @param source - The string to search in\n * @param str - The substring to search for\n * @returns The 0-based index of the first occurrence, or na (NaN) if not found\n *\n * @remarks\n * - Search is case-sensitive\n * - Returns 0 for empty search string\n * - Returns na (NaN) if substring is not found, as in PineScript\n *\n * @example\n * ```typescript\n * str.pos(\"hello world\", \"world\") // Returns: 6\n * str.pos(\"hello world\", \"o\") // Returns: 4 (first occurrence)\n * str.pos(\"hello\", \"xyz\") // Returns: NaN (na)\n * ```\n */\nexport function pos(source: simple_string, str: simple_string): int {\n  const index = source.indexOf(str);\n  return index === -1 ? NaN : index;\n}\n\n/**\n * Replaces the Nth occurrence of a substring (PineScript `str.replace`).\n *\n * @param source - The source string\n * @param target - The substring to replace\n * @param replacement - The string to replace with\n * @param occurrence - 0-based occurrence to replace (default 0, the first one)\n * @returns The string with one occurrence replaced\n *\n * @remarks\n * PineScript rules:\n * - only the Nth occurrence is replaced; an na occurrence is 0 (`str.replace(\"aaa\", \"a\", \"-\", na)` is \"-aa\")\n * - occurrences overlap: \"aa\" occurs at 0 and 1 in \"aaa\" (`str.replace(\"aaa\", \"aa\", \"-\", 1)` is \"a-\")\n * - an empty target inserts the replacement at character N, at most at the end\n *   (`str.replace(\"abc\", \"\", \"-\", 2)` is \"ab-c\")\n * - fewer than N + 1 occurrences (or a negative N) leave the source unchanged\n *\n * @example\n * ```typescript\n * str.replace(\"hello world hello\", \"hello\", \"hi\") // Returns: \"hi world hello\"\n * str.replace(\"hello world hello\", \"hello\", \"hi\", 1) // Returns: \"hello world hi\"\n * str.replace(\"test\", \"xyz\", \"abc\") // Returns: \"test\"\n * ```\n */\nexport function replace(source: simple_string, target: simple_string, replacement: simple_string, occurrence: simple_int = 0): string {\n  const n = occurrence === null || Number.isNaN(occurrence) ? 0 : Math.trunc(occurrence);\n  if (n < 0) return source;\n  let index: number;\n  if (target === '') {\n    index = Math.min(n, source.length);\n  } else {\n    index = -1;\n    for (let k = 0; k <= n; k++) {\n      index = source.indexOf(target, index + 1);\n      if (index === -1) return source;\n    }\n  }\n  return source.slice(0, index) + replacement + source.slice(index + target.length);\n}\n\n/**\n * Replaces all occurrences of a target string with a replacement string.\n *\n * @param source - The source string\n * @param target - The substring to find\n * @param replacement - The replacement string\n * @returns String with all occurrences replaced\n *\n * @remarks\n * - Replaces all occurrences of the target string\n * - Case sensitive\n * - If target is empty string, returns original string\n * - This matches PineScript's `str.replace_all()` behavior\n *\n * @example\n * ```typescript\n * str.replace_all(\"hello world hello\", \"hello\", \"hi\") // Returns: \"hi world hi\"\n * str.replace_all(\"a-b-c\", \"-\", \"_\") // Returns: \"a_b_c\"\n * str.replace_all(\"test\", \"x\", \"y\") // Returns: \"test\" (no match)\n * ```\n */\nexport function replace_all(source: simple_string, target: simple_string, replacement: simple_string): string {\n  return source.replaceAll(target, replacement);\n}\n\n/**\n * Splits a string into an array of substrings using a separator.\n *\n * @param str - The string to split\n * @param separator - The separator string\n * @returns Array of substrings\n *\n * @remarks\n * - Empty separator splits into individual characters; an empty string gives [\"\"] (also with \"\")\n * - If separator is not found, returns array with original string\n * - Consecutive separators create empty strings in result\n *\n * @example\n * ```typescript\n * str.split(\"a,b,c\", \",\") // Returns: [\"a\", \"b\", \"c\"]\n * str.split(\"hello\", \"\") // Returns: [\"h\", \"e\", \"l\", \"l\", \"o\"]\n * str.split(\"a,,b\", \",\") // Returns: [\"a\", \"\", \"b\"]\n * ```\n */\nexport function split(str: simple_string, separator: simple_string): string[] {\n  // JavaScript gives [] for \"\".split(\"\"); PineScript gives [\"\"]\n  return str === '' ? [''] : str.split(separator);\n}\n\n/**\n * Concatenates multiple strings into one.\n *\n * @param strings - Variable number of strings to concatenate\n * @returns The concatenated string\n *\n * @example\n * ```typescript\n * str.concat(\"hello\", \" \", \"world\") // Returns: \"hello world\"\n * str.concat(\"a\", \"b\", \"c\") // Returns: \"abc\"\n * str.concat(\"test\") // Returns: \"test\"\n * ```\n */\nexport function concat(...strings: simple_string[]): string {\n  return strings.join('');\n}\n\n/**\n * Formats a string with placeholders (PineScript `str.format`, Java MessageFormat syntax).\n *\n * @param formatStr - Pattern with `{0}`, `{1,number,#.##}`, `{0,number,percent}`, `{0,date,yyyy-MM-dd}`...\n * @param args - Values for the placeholders\n * @returns Formatted string\n *\n * @remarks\n * As in PineScript: numbers in `{n}` use\n * \"#,##0.###\" (1234.5678 gives \"1,234.568\"); number patterns round half to even on the exact\n * value (16 decimals at most from 1e-3 up); an array gives \"[a, b]\"; `'...'` is literal text and `''` a quote;\n * a missing argument leaves `{n}` in the text.\n * Dates are formatted in UTC here; PineScript uses the exchange time zone.\n *\n * @example\n * ```typescript\n * str.format('Close: {0,number,#.##}', 101.456) // \"Close: 101.46\"\n * str.format('{0} and {1}', 'a', 2) // \"a and 2\"\n * ```\n */\nexport function format(formatStr: simple_string, ...args: any[]): string {\n  return formatMessage(formatStr, args, 'Etc/UTC');\n}\n\n/**\n * Checks if a string starts with a specific prefix.\n *\n * @param source - The string to check\n * @param str - The prefix to look for\n * @returns True if source starts with str, false otherwise\n *\n * @remarks\n * - Search is case-sensitive\n * - Empty string prefix always returns true\n *\n * @example\n * ```typescript\n * str.startswith(\"hello world\", \"hello\") // Returns: true\n * str.startswith(\"hello world\", \"Hello\") // Returns: false (case-sensitive)\n * str.startswith(\"test\", \"testing\") // Returns: false\n * ```\n */\nexport function startswith(source: simple_string, str: simple_string): bool {\n  return source.startsWith(str);\n}\n\n/**\n * Checks if a string ends with a specific suffix.\n *\n * @param source - The string to check\n * @param str - The suffix to look for\n * @returns True if source ends with str, false otherwise\n *\n * @remarks\n * - Search is case-sensitive\n * - Empty string suffix always returns true\n *\n * @example\n * ```typescript\n * str.endswith(\"hello world\", \"world\") // Returns: true\n * str.endswith(\"hello world\", \"World\") // Returns: false (case-sensitive)\n * str.endswith(\"testing\", \"test\") // Returns: false\n * ```\n */\nexport function endswith(source: simple_string, str: simple_string): bool {\n  return source.endsWith(str);\n}\n\n/**\n * Returns the character at a specific position in a string.\n *\n * @param str - The source string\n * @param pos - The 0-based position\n * @returns The character at the position, or empty string if out of bounds\n *\n * @remarks\n * - Returns empty string for negative or out-of-bounds positions\n * - Unicode characters may span multiple code units\n *\n * @example\n * ```typescript\n * str.charAt(\"hello\", 0) // Returns: \"h\"\n * str.charAt(\"hello\", 4) // Returns: \"o\"\n * str.charAt(\"hello\", 10) // Returns: \"\"\n * ```\n */\nexport function charAt(str: simple_string, pos: simple_int): string {\n  return str.charAt(pos);\n}\n\n/**\n * Removes whitespace from both ends of a string.\n *\n * @param str - The string to trim\n * @returns The trimmed string\n *\n * @remarks\n * - Removes spaces, tabs, newlines, and other whitespace characters\n * - Preserves internal whitespace\n *\n * @example\n * ```typescript\n * str.trim(\"  hello  \") // Returns: \"hello\"\n * str.trim(\"  hello world  \") // Returns: \"hello world\"\n * str.trim(\"\\thello\\n\") // Returns: \"hello\"\n * ```\n */\nexport function trim(str: simple_string): string {\n  return str.trim();\n}\n\n/**\n * Removes whitespace from the left (start) of a string.\n *\n * @param str - The string to trim\n * @returns The trimmed string\n *\n * @remarks\n * - Only removes leading whitespace\n * - Preserves trailing and internal whitespace\n *\n * @example\n * ```typescript\n * str.trimLeft(\"  hello  \") // Returns: \"hello  \"\n * str.trimLeft(\"  hello\") // Returns: \"hello\"\n * str.trimLeft(\"\\thello\") // Returns: \"hello\"\n * ```\n */\nexport function trimLeft(str: simple_string): string {\n  return str.trimStart();\n}\n\n/**\n * Removes whitespace from the right (end) of a string.\n *\n * @param str - The string to trim\n * @returns The trimmed string\n *\n * @remarks\n * - Only removes trailing whitespace\n * - Preserves leading and internal whitespace\n *\n * @example\n * ```typescript\n * str.trimRight(\"  hello  \") // Returns: \"  hello\"\n * str.trimRight(\"hello  \") // Returns: \"hello\"\n * str.trimRight(\"hello\\t\") // Returns: \"hello\"\n * ```\n */\nexport function trimRight(str: simple_string): string {\n  return str.trimEnd();\n}\n\n/**\n * Returns the first substring of `source` that matches the `regex` (PineScript `str.match`).\n *\n * @param source - Source string\n * @param regex - Regular expression\n * @returns The first match (searched anywhere in the string), or na (null) when nothing matches or the match is empty\n *\n * @remarks\n * - As PineScript: \"Hello World!\" with \"o\" gives \"o\", with \"[a-z]+\" gives \"ello\"; no match gives na\n * - Uses JavaScript regex syntax\n *\n * @example\n * ```typescript\n * str.match(\"abc123def\", \"[0-9]+\") // Returns: \"123\"\n * str.match(\"abc\", \"[0-9]+\") // Returns: null (na)\n * ```\n */\nexport function match(source: simple_string, regex: simple_string): simple_string | null {\n  const found = new RegExp(regex).exec(source);\n  return found && found[0] !== '' ? found[0] : null;\n}\n\n/**\n * Formats a timestamp as a string according to the specified format.\n *\n * @param time - Unix timestamp in milliseconds\n * @param format - Format string using PineScript format specifiers\n * @returns Formatted date/time string\n *\n * @remarks\n * Supported format specifiers (case-sensitive):\n * - `yyyy` - 4-digit year (e.g., \"2024\")\n * - `yy` - 2-digit year (e.g., \"24\")\n * - `MMMM` - Full month name (e.g., \"January\")\n * - `MMM` - Abbreviated month name (e.g., \"Jan\")\n * - `MM` - 2-digit month (01-12)\n * - `M` - Month (1-12)\n * - `dd` - 2-digit day (01-31)\n * - `d` - Day (1-31)\n * - `HH` - 2-digit hour (00-23)\n * - `H` - Hour (0-23)\n * - `hh` - 2-digit hour (01-12)\n * - `h` - Hour (1-12)\n * - `mm` - 2-digit minute (00-59)\n * - `m` - Minute (0-59)\n * - `ss` - 2-digit second (00-59)\n * - `s` - Second (0-59)\n * - `a` - AM/PM\n *\n * @example\n * ```typescript\n * const timestamp = 1609459200000; // Jan 1, 2021 00:00:00 UTC\n * str.format_time(timestamp, \"dd MMM yyyy\") // Returns: \"01 Jan 2021\"\n * str.format_time(timestamp, \"yyyy-MM-dd HH:mm:ss\") // Returns: \"2021-01-01 00:00:00\"\n * str.format_time(timestamp, \"MMM d, yyyy\") // Returns: \"Jan 1, 2021\"\n * str.format_time(timestamp, \"hh:mm a\") // Returns: \"12:00 AM\"\n * ```\n */\n/**\n * Constructs a new string containing the source string repeated N times with an optional separator.\n *\n * @param source - The string to repeat\n * @param count - Number of times to repeat\n * @param separator - String to inject between repeated instances. Optional, defaults to empty string.\n * @returns The repeated string, or null (na) if source is na or count is 0 / negative / na, as in PineScript\n *\n * @example\n * ```typescript\n * str.repeat(\"ab\", 3) // Returns: \"ababab\"\n * str.repeat(\"?\", 3, \",\") // Returns: \"?,?,?\"\n * str.repeat(\"hello\", 0) // Returns: null (na)\n * str.repeat(\"x\", 1) // Returns: \"x\"\n * ```\n */\nexport function repeat(source: simple_string, count: simple_int, separator: simple_string = ''): string | null {\n  if (source == null) return null;\n  if (!(count > 0)) return null; // 0, negative or na: na\n  return Array(count).fill(source).join(separator);\n}\n\n/**\n * Formats a UNIX time (ms) with a date pattern (PineScript `str.format_time`).\n *\n * @param time - UNIX time in milliseconds\n * @param format - Java SimpleDateFormat pattern, e.g. \"yyyy-MM-dd HH:mm:ss\", \"dd MMM yyyy\", \"hh:mm a\"\n * @param timezone - UTC/GMT offset (\"UTC-5\") or IANA name (\"America/New_York\"). PineScript's default is\n *   the exchange time zone, which is not known here: the default is UTC\n * @returns Formatted date string\n *\n * @remarks\n * Letters: y, M, d, E, u, D, w,\n * H, k, K, h, a, m, s, S, Z, z; 'text' is literal text.\n */\nexport function format_time(time: simple_int, format: simple_string = \"yyyy-MM-dd'T'HH:mm:ssZ\", timezone: simple_string = 'Etc/UTC'): string {\n  return formatDate(time, format, timezone);\n}\n"],
-  "mappings": "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",
+  "sourcesContent": ["/**\n * String namespace\n * Mirrors PineScript's str.* functions for string manipulation and analysis.\n *\n * @remarks\n * All string functions in this namespace follow PineScript v6 API specifications.\n * String operations are case-sensitive unless otherwise specified.\n *\n * @version 6\n */\n\nimport { formatNumber, tickScale } from './numberformat.js';\nimport { formatMessage } from './messageformat.js';\nimport { formatDate } from './dateformat.js';\nimport type { int, bool, float, simple_int, simple_string } from '../types/index.js';\n\n/**\n * Returns the length of a string.\n *\n * @param str - The string to measure\n * @returns The number of characters in the string\n *\n * @example\n * ```typescript\n * str.length(\"Hello\") // Returns: 5\n * str.length(\"\") // Returns: 0\n * ```\n */\nexport function length(str: simple_string): int {\n  return str.length;\n}\n\n/**\n * Converts a value to its string representation (PineScript `str.tostring`).\n *\n * @param value - The value to convert (number, boolean, string, etc.)\n * @param format - Optional number format: a pattern (\"#.##\", \"#,###.00\", \"0.00%\", \"0.00E0\", \"#.##;(#.##)\") or\n *   `format.percent` (\"percent\"), `format.volume` (\"volume\"), `format.mintick` (\"mintick\"),\n *   `format.price` / `format.inherit`\n * @param mintick - Tick size for `format.mintick` (PineScript `syminfo.mintick`, implicit there). Not part of the\n *   PineScript signature: the core function cannot see the chart, so pass it, as for `math.round_to_mintick`\n * @param pricescale - Price scale of the symbol for `format.mintick` (PineScript `syminfo.pricescale`), needed for a\n *   symbol priced in fractions (32 for a 1/32 tick). Default: 10^(decimals of `mintick`)\n * @returns String representation of the value\n *\n * @remarks\n * As in PineScript:\n * - without format, numbers show up to 10 decimals (\"0.3333333333\"): the digits of the JVM's binary to decimal\n *   conversion, rounded half to even, a tie on the last converted digit decided by the conversion\n *   (82325.10000000005 gives \"82325.1\", with the format \"#.##########\" \"82325.1000000001\"; 1791662400001 / 900000\n *   gives \"1990736.000001111\"; 78195689105219552 keeps its 17 digits); 1e21 and more use \"1E21\"\n * - patterns round half away from zero on the shortest decimal form: 1.005 with \"#.##\" gives \"1.01\";\n *   at most 16 decimals from 1e-3 up (0.0012345678901234567 with 20 '#' decimals gives \"0.0012345678901235\")\n * - \"pos;neg\" patterns: a negative number takes the text of the negative subpattern (\"#.##;(#.##)\": \"(3.5)\")\n * - \"#\" is an optional digit (\"1.5\" with \"#.##\"), \"0\" a required digit (\"1.50\" with \"0.00\"),\n *   \",\" groups thousands, \"%\" multiplies by 100, 'text' is literal text\n * - `format.percent` shows 2 decimals and \"%\" without multiplying; `format.volume` uses K, M, B, T\n * - `format.price` and `format.inherit` give \"price1\" / \"inherit1\" in PineScript: they are patterns\n *   without digit characters, and oakscriptjs does the same\n * - `format.mintick` shows floor(log10(pricescale)) decimals, zeros included (\"1.00\", \"0.40\" for tick 0.01), and\n *   rounds in two steps, with mintick = minmove / pricescale: the double quotient `|x| / (1 / pricescale)` half away\n *   from zero (140.355 / 0.01 = 14035.499999999998 gives \"140.35\", where `math.round_to_mintick` gives 140.36),\n *   then `floor(units / minmove + 0.5)` ticks (tick 0.02: 0.005 gives \"0.02\", -0.01 gives \"0.00\"). With a\n *   pricescale that is no power of 10 the tick value is then rounded half even to those decimals (1/32: 25.25 gives\n *   \"25.2\", -0.02 gives \"-0.0\"). It throws without `mintick`\n * - na gives \"NaN\" (\"NaN%\" with `format.percent`); an infinity gives \"NaN\" too (\"NaN%\" for `format.percent`,\n *   \"NaNT\" for `format.volume`), except `format.mintick`, which gives \"Infinity\" / \"-Infinity\"\n *\n * @example\n * ```typescript\n * str.tostring(123) // \"123\"\n * str.tostring(1.5, \"#.##\") // \"1.5\"\n * str.tostring(0.5, \"#.00\") // \".50\"\n * str.tostring(12345.678, format.volume) // \"12.346K\"\n * ```\n */\nexport function tostring(value: any, format?: simple_string, mintick?: float, pricescale?: float): string {\n  // an array: \"[a, b]\", each element as a single value\n  if (Array.isArray(value)) return '[' + value.map((v) => tostring(v, format, mintick, pricescale)).join(', ') + ']';\n  if (typeof value !== 'number') return String(value);\n  if (Number.isNaN(value)) return format === 'percent' ? 'NaN%' : 'NaN';\n  if (!Number.isFinite(value)) {\n    // the chart formatter has no infinity: NaN with the format's suffix\n    if (format === 'mintick') return String(value);\n    return format === 'percent' ? 'NaN%' : format === 'volume' ? 'NaNT' : 'NaN';\n  }\n  if (format === undefined || format === '') {\n    if (Math.abs(value) >= 1e21 && Number.isFinite(value)) {\n      return String(value).replace('e+', 'E').replace(/\\.0+E/, 'E');\n    }\n    // without a format: the digits of the JVM conversion, 10 decimals half to even (#171, #174)\n    return formatNumber(value, '#.##########', 'halfEvenConverted');\n  }\n  switch (format) {\n    case 'percent':\n      return formatNumber(value, '0.00', 'halfUpShortest') + '%';\n    case 'volume': {\n      const abs = Math.abs(value);\n      for (const [size, unit] of [[1e12, 'T'], [1e9, 'B'], [1e6, 'M'], [1e3, 'K']] as const) {\n        if (abs >= size) return formatNumber(value / size, '#.###', 'halfUpShortest') + unit;\n      }\n      return formatNumber(value, '#', 'halfUpShortest');\n    }\n    case 'mintick': {\n      if (mintick === undefined) {\n        throw new Error('str.tostring(x, format.mintick) needs the tick size: pass it as str.tostring(x, format.mintick, syminfo.mintick)');\n      }\n      const [minmove, scale] = tickScale(mintick, pricescale);\n      const decimals = Math.floor(Math.log10(scale) + 1e-9);\n      const mask = decimals > 0 ? '0.' + '0'.repeat(decimals) : '0';\n      if (!(minmove >= 1)) return formatNumber(value, mask, 'halfUpShortest');\n      // 1. the double quotient |x| / (1 / pricescale), half away from zero (not math.round_to_mintick's exact decimal)\n      const scaled = Math.abs(value) / (1 / scale);\n      let units = Math.trunc(scaled);\n      if (scaled - units >= 0.5) units++;\n      // 2. to the tick, a half going up (minmove 2: -0.01 gives \"0.00\", 0.01 gives \"0.02\")\n      const ticks = Math.floor((value < 0 ? -units : units) / minmove + 0.5);\n      // 3. the tick value at the scale's decimals; a negative one keeps its sign when it prints as zero (\"-0.0\")\n      const text = formatNumber((Math.abs(ticks) * minmove) / scale, mask, 'halfEvenExact');\n      return ticks < 0 ? '-' + text : text;\n    }\n    default:\n      return formatNumber(value, format, 'halfUpShortest');\n  }\n}\n\n/**\n * Converts a string to a number (float).\n *\n * @param str - The string to convert\n * @returns The numeric value, or null (na) if conversion fails\n *\n * @remarks\n * As in PineScript:\n * - The whole text must be a number: a sign, digits and one optional \".\" (\"0.5\", \".5\", \"5.\", \"-12\"); \"12abc\" is na\n * - Scientific notation (\"1e3\"), \"Infinity\", \"NaN\", hexadecimal, \"1,000\" give na\n * - The characters U+0000 to U+0020 (space, tab, line feed...) around the number are ignored; other spaces\n *   (no-break space U+00A0, U+3000) give na\n *\n * @example\n * ```typescript\n * str.tonumber(\"123\") // Returns: 123\n * str.tonumber(\"45.67\") // Returns: 45.67\n * str.tonumber(\"abc\") // Returns: null\n * str.tonumber(\"12abc\") // Returns: null\n * str.tonumber(\"1e3\") // Returns: null\n * ```\n */\nexport function tonumber(str: simple_string): float | null {\n  // remove the characters U+0000..U+0020 at both ends\n  let start = 0;\n  let end = str.length;\n  while (start < end && str.charCodeAt(start) <= 0x20) start++;\n  while (end > start && str.charCodeAt(end - 1) <= 0x20) end--;\n  const text = str.slice(start, end);\n  if (!/^[+-]?(?:\\d+\\.?\\d*|\\.\\d+)$/.test(text)) return null;\n  return parseFloat(text);\n}\n\n/**\n * Extracts a substring from a string.\n *\n * @param str - The source string\n * @param begin - Starting index (0-based, inclusive)\n * @param end - Ending index (0-based, exclusive). If omitted, extracts to end of string\n * @returns The extracted substring\n *\n * @remarks\n * - An na `end` (NaN / null) is a runtime error in PineScript: it throws\n * - If begin > end, indices are swapped (JavaScript behavior)\n * - Negative indices are treated as 0\n * - Indices beyond string length return empty string\n *\n * @example\n * ```typescript\n * str.substring(\"hello world\", 0, 5) // Returns: \"hello\"\n * str.substring(\"hello world\", 6) // Returns: \"world\"\n * str.substring(\"test\", 1, 3) // Returns: \"es\"\n * ```\n */\nexport function substring(str: simple_string, begin: simple_int, end?: simple_int): string {\n  if (end === null || Number.isNaN(end)) throw new Error('str.substring: the end position is na');\n  return str.substring(begin, end);\n}\n\n/**\n * Converts all characters in a string to uppercase.\n *\n * @param str - The string to convert\n * @returns The uppercase string\n *\n * @example\n * ```typescript\n * str.upper(\"hello\") // Returns: \"HELLO\"\n * str.upper(\"Hello World\") // Returns: \"HELLO WORLD\"\n * str.upper(\"test123\") // Returns: \"TEST123\"\n * ```\n */\nexport function upper(str: simple_string): string {\n  return str.toUpperCase();\n}\n\n/**\n * Converts all characters in a string to lowercase.\n *\n * @param str - The string to convert\n * @returns The lowercase string\n *\n * @example\n * ```typescript\n * str.lower(\"HELLO\") // Returns: \"hello\"\n * str.lower(\"Hello World\") // Returns: \"hello world\"\n * str.lower(\"TEST123\") // Returns: \"test123\"\n * ```\n */\nexport function lower(str: simple_string): string {\n  return str.toLowerCase();\n}\n\n/**\n * Checks if a string contains a substring.\n *\n * @param source - The string to search in\n * @param str - The substring to search for\n * @returns True if source contains str, false otherwise\n *\n * @remarks\n * - Search is case-sensitive\n * - Empty string is contained in any string\n *\n * @example\n * ```typescript\n * str.contains(\"hello world\", \"world\") // Returns: true\n * str.contains(\"hello world\", \"World\") // Returns: false (case-sensitive)\n * str.contains(\"test\", \"xyz\") // Returns: false\n * ```\n */\nexport function contains(source: simple_string, str: simple_string): bool {\n  return source.includes(str);\n}\n\n/**\n * Returns the position of the first occurrence of a substring.\n *\n * @param source - The string to search in\n * @param str - The substring to search for\n * @returns The 0-based index of the first occurrence, or na (NaN) if not found\n *\n * @remarks\n * - Search is case-sensitive\n * - Returns 0 for empty search string\n * - Returns na (NaN) if substring is not found, as in PineScript\n *\n * @example\n * ```typescript\n * str.pos(\"hello world\", \"world\") // Returns: 6\n * str.pos(\"hello world\", \"o\") // Returns: 4 (first occurrence)\n * str.pos(\"hello\", \"xyz\") // Returns: NaN (na)\n * ```\n */\nexport function pos(source: simple_string, str: simple_string): int {\n  const index = source.indexOf(str);\n  return index === -1 ? NaN : index;\n}\n\n/**\n * Replaces the Nth occurrence of a substring (PineScript `str.replace`).\n *\n * @param source - The source string\n * @param target - The substring to replace\n * @param replacement - The string to replace with\n * @param occurrence - 0-based occurrence to replace (default 0, the first one)\n * @returns The string with one occurrence replaced\n *\n * @remarks\n * PineScript rules:\n * - only the Nth occurrence is replaced; an na occurrence is 0 (`str.replace(\"aaa\", \"a\", \"-\", na)` is \"-aa\")\n * - occurrences overlap: \"aa\" occurs at 0 and 1 in \"aaa\" (`str.replace(\"aaa\", \"aa\", \"-\", 1)` is \"a-\")\n * - an empty target inserts the replacement at character N, at most at the end\n *   (`str.replace(\"abc\", \"\", \"-\", 2)` is \"ab-c\")\n * - fewer than N + 1 occurrences (or a negative N) leave the source unchanged\n *\n * @example\n * ```typescript\n * str.replace(\"hello world hello\", \"hello\", \"hi\") // Returns: \"hi world hello\"\n * str.replace(\"hello world hello\", \"hello\", \"hi\", 1) // Returns: \"hello world hi\"\n * str.replace(\"test\", \"xyz\", \"abc\") // Returns: \"test\"\n * ```\n */\nexport function replace(source: simple_string, target: simple_string, replacement: simple_string, occurrence: simple_int = 0): string {\n  const n = occurrence === null || Number.isNaN(occurrence) ? 0 : Math.trunc(occurrence);\n  if (n < 0) return source;\n  let index: number;\n  if (target === '') {\n    index = Math.min(n, source.length);\n  } else {\n    index = -1;\n    for (let k = 0; k <= n; k++) {\n      index = source.indexOf(target, index + 1);\n      if (index === -1) return source;\n    }\n  }\n  return source.slice(0, index) + replacement + source.slice(index + target.length);\n}\n\n/**\n * Replaces all occurrences of a target string with a replacement string.\n *\n * @param source - The source string\n * @param target - The substring to find\n * @param replacement - The replacement string\n * @returns String with all occurrences replaced\n *\n * @remarks\n * - Replaces all occurrences of the target string\n * - Case sensitive\n * - If target is empty string, returns original string\n * - This matches PineScript's `str.replace_all()` behavior\n *\n * @example\n * ```typescript\n * str.replace_all(\"hello world hello\", \"hello\", \"hi\") // Returns: \"hi world hi\"\n * str.replace_all(\"a-b-c\", \"-\", \"_\") // Returns: \"a_b_c\"\n * str.replace_all(\"test\", \"x\", \"y\") // Returns: \"test\" (no match)\n * ```\n */\nexport function replace_all(source: simple_string, target: simple_string, replacement: simple_string): string {\n  return source.replaceAll(target, replacement);\n}\n\n/**\n * Splits a string into an array of substrings using a separator.\n *\n * @param str - The string to split\n * @param separator - The separator string\n * @returns Array of substrings\n *\n * @remarks\n * - Empty separator splits into individual characters; an empty string gives [\"\"] (also with \"\")\n * - If separator is not found, returns array with original string\n * - Consecutive separators create empty strings in result\n *\n * @example\n * ```typescript\n * str.split(\"a,b,c\", \",\") // Returns: [\"a\", \"b\", \"c\"]\n * str.split(\"hello\", \"\") // Returns: [\"h\", \"e\", \"l\", \"l\", \"o\"]\n * str.split(\"a,,b\", \",\") // Returns: [\"a\", \"\", \"b\"]\n * ```\n */\nexport function split(str: simple_string, separator: simple_string): string[] {\n  // JavaScript gives [] for \"\".split(\"\"); PineScript gives [\"\"]\n  return str === '' ? [''] : str.split(separator);\n}\n\n/**\n * Concatenates multiple strings into one.\n *\n * @param strings - Variable number of strings to concatenate\n * @returns The concatenated string\n *\n * @example\n * ```typescript\n * str.concat(\"hello\", \" \", \"world\") // Returns: \"hello world\"\n * str.concat(\"a\", \"b\", \"c\") // Returns: \"abc\"\n * str.concat(\"test\") // Returns: \"test\"\n * ```\n */\nexport function concat(...strings: simple_string[]): string {\n  return strings.join('');\n}\n\n/**\n * Formats a string with placeholders (PineScript `str.format`, Java MessageFormat syntax).\n *\n * @param formatStr - Pattern with `{0}`, `{1,number,#.##}`, `{0,number,percent}`, `{0,date,yyyy-MM-dd}`...\n * @param args - Values for the placeholders\n * @returns Formatted string\n *\n * @remarks\n * As in PineScript: numbers in `{n}` use\n * \"#,##0.###\" (1234.5678 gives \"1,234.568\"); number patterns round half to even on the exact\n * value (16 decimals at most from 1e-3 up); an array gives \"[a, b]\"; `'...'` is literal text and `''` a quote;\n * a missing argument leaves `{n}` in the text.\n * Dates are formatted in UTC here; PineScript uses the exchange time zone.\n *\n * @example\n * ```typescript\n * str.format('Close: {0,number,#.##}', 101.456) // \"Close: 101.46\"\n * str.format('{0} and {1}', 'a', 2) // \"a and 2\"\n * ```\n */\nexport function format(formatStr: simple_string, ...args: any[]): string {\n  return formatMessage(formatStr, args, 'Etc/UTC');\n}\n\n/**\n * Checks if a string starts with a specific prefix.\n *\n * @param source - The string to check\n * @param str - The prefix to look for\n * @returns True if source starts with str, false otherwise\n *\n * @remarks\n * - Search is case-sensitive\n * - Empty string prefix always returns true\n *\n * @example\n * ```typescript\n * str.startswith(\"hello world\", \"hello\") // Returns: true\n * str.startswith(\"hello world\", \"Hello\") // Returns: false (case-sensitive)\n * str.startswith(\"test\", \"testing\") // Returns: false\n * ```\n */\nexport function startswith(source: simple_string, str: simple_string): bool {\n  return source.startsWith(str);\n}\n\n/**\n * Checks if a string ends with a specific suffix.\n *\n * @param source - The string to check\n * @param str - The suffix to look for\n * @returns True if source ends with str, false otherwise\n *\n * @remarks\n * - Search is case-sensitive\n * - Empty string suffix always returns true\n *\n * @example\n * ```typescript\n * str.endswith(\"hello world\", \"world\") // Returns: true\n * str.endswith(\"hello world\", \"World\") // Returns: false (case-sensitive)\n * str.endswith(\"testing\", \"test\") // Returns: false\n * ```\n */\nexport function endswith(source: simple_string, str: simple_string): bool {\n  return source.endsWith(str);\n}\n\n/**\n * Returns the character at a specific position in a string.\n *\n * @param str - The source string\n * @param pos - The 0-based position\n * @returns The character at the position, or empty string if out of bounds\n *\n * @remarks\n * - Returns empty string for negative or out-of-bounds positions\n * - Unicode characters may span multiple code units\n *\n * @example\n * ```typescript\n * str.charAt(\"hello\", 0) // Returns: \"h\"\n * str.charAt(\"hello\", 4) // Returns: \"o\"\n * str.charAt(\"hello\", 10) // Returns: \"\"\n * ```\n */\nexport function charAt(str: simple_string, pos: simple_int): string {\n  return str.charAt(pos);\n}\n\n/**\n * Removes whitespace from both ends of a string.\n *\n * @param str - The string to trim\n * @returns The trimmed string\n *\n * @remarks\n * - Removes spaces, tabs, newlines, and other whitespace characters\n * - Preserves internal whitespace\n *\n * @example\n * ```typescript\n * str.trim(\"  hello  \") // Returns: \"hello\"\n * str.trim(\"  hello world  \") // Returns: \"hello world\"\n * str.trim(\"\\thello\\n\") // Returns: \"hello\"\n * ```\n */\nexport function trim(str: simple_string): string {\n  return str.trim();\n}\n\n/**\n * Removes whitespace from the left (start) of a string.\n *\n * @param str - The string to trim\n * @returns The trimmed string\n *\n * @remarks\n * - Only removes leading whitespace\n * - Preserves trailing and internal whitespace\n *\n * @example\n * ```typescript\n * str.trimLeft(\"  hello  \") // Returns: \"hello  \"\n * str.trimLeft(\"  hello\") // Returns: \"hello\"\n * str.trimLeft(\"\\thello\") // Returns: \"hello\"\n * ```\n */\nexport function trimLeft(str: simple_string): string {\n  return str.trimStart();\n}\n\n/**\n * Removes whitespace from the right (end) of a string.\n *\n * @param str - The string to trim\n * @returns The trimmed string\n *\n * @remarks\n * - Only removes trailing whitespace\n * - Preserves leading and internal whitespace\n *\n * @example\n * ```typescript\n * str.trimRight(\"  hello  \") // Returns: \"  hello\"\n * str.trimRight(\"hello  \") // Returns: \"hello\"\n * str.trimRight(\"hello\\t\") // Returns: \"hello\"\n * ```\n */\nexport function trimRight(str: simple_string): string {\n  return str.trimEnd();\n}\n\n/**\n * Returns the first substring of `source` that matches the `regex` (PineScript `str.match`).\n *\n * @param source - Source string\n * @param regex - Regular expression\n * @returns The first match (searched anywhere in the string), or na (null) when nothing matches or the match is empty\n *\n * @remarks\n * - As PineScript: \"Hello World!\" with \"o\" gives \"o\", with \"[a-z]+\" gives \"ello\"; no match gives na\n * - Uses JavaScript regex syntax\n *\n * @example\n * ```typescript\n * str.match(\"abc123def\", \"[0-9]+\") // Returns: \"123\"\n * str.match(\"abc\", \"[0-9]+\") // Returns: null (na)\n * ```\n */\nexport function match(source: simple_string, regex: simple_string): simple_string | null {\n  const found = new RegExp(regex).exec(source);\n  return found && found[0] !== '' ? found[0] : null;\n}\n\n/**\n * Formats a timestamp as a string according to the specified format.\n *\n * @param time - Unix timestamp in milliseconds\n * @param format - Format string using PineScript format specifiers\n * @returns Formatted date/time string\n *\n * @remarks\n * Supported format specifiers (case-sensitive):\n * - `yyyy` - 4-digit year (e.g., \"2024\")\n * - `yy` - 2-digit year (e.g., \"24\")\n * - `MMMM` - Full month name (e.g., \"January\")\n * - `MMM` - Abbreviated month name (e.g., \"Jan\")\n * - `MM` - 2-digit month (01-12)\n * - `M` - Month (1-12)\n * - `dd` - 2-digit day (01-31)\n * - `d` - Day (1-31)\n * - `HH` - 2-digit hour (00-23)\n * - `H` - Hour (0-23)\n * - `hh` - 2-digit hour (01-12)\n * - `h` - Hour (1-12)\n * - `mm` - 2-digit minute (00-59)\n * - `m` - Minute (0-59)\n * - `ss` - 2-digit second (00-59)\n * - `s` - Second (0-59)\n * - `a` - AM/PM\n *\n * @example\n * ```typescript\n * const timestamp = 1609459200000; // Jan 1, 2021 00:00:00 UTC\n * str.format_time(timestamp, \"dd MMM yyyy\") // Returns: \"01 Jan 2021\"\n * str.format_time(timestamp, \"yyyy-MM-dd HH:mm:ss\") // Returns: \"2021-01-01 00:00:00\"\n * str.format_time(timestamp, \"MMM d, yyyy\") // Returns: \"Jan 1, 2021\"\n * str.format_time(timestamp, \"hh:mm a\") // Returns: \"12:00 AM\"\n * ```\n */\n/**\n * Constructs a new string containing the source string repeated N times with an optional separator.\n *\n * @param source - The string to repeat\n * @param count - Number of times to repeat\n * @param separator - String to inject between repeated instances. Optional, defaults to empty string.\n * @returns The repeated string, or null (na) if source is na or count is 0 / negative / na, as in PineScript\n *\n * @example\n * ```typescript\n * str.repeat(\"ab\", 3) // Returns: \"ababab\"\n * str.repeat(\"?\", 3, \",\") // Returns: \"?,?,?\"\n * str.repeat(\"hello\", 0) // Returns: null (na)\n * str.repeat(\"x\", 1) // Returns: \"x\"\n * ```\n */\nexport function repeat(source: simple_string, count: simple_int, separator: simple_string = ''): string | null {\n  if (source == null) return null;\n  if (!(count > 0)) return null; // 0, negative or na: na\n  return Array(count).fill(source).join(separator);\n}\n\n/**\n * Formats a UNIX time (ms) with a date pattern (PineScript `str.format_time`).\n *\n * @param time - UNIX time in milliseconds\n * @param format - Java SimpleDateFormat pattern, e.g. \"yyyy-MM-dd HH:mm:ss\", \"dd MMM yyyy\", \"hh:mm a\"\n * @param timezone - UTC/GMT offset (\"UTC-5\") or IANA name (\"America/New_York\"). PineScript's default is\n *   the exchange time zone, which is not known here: the default is UTC\n * @returns Formatted date string\n *\n * @remarks\n * Letters: y, M, d, E, u, D, w,\n * H, k, K, h, a, m, s, S, Z, z; 'text' is literal text.\n */\nexport function format_time(time: simple_int, format: simple_string = \"yyyy-MM-dd'T'HH:mm:ssZ\", timezone: simple_string = 'Etc/UTC'): string {\n  return formatDate(time, format, timezone);\n}\n"],
+  "mappings": "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",
   "names": ["format", "pos"]
 }

package/dist/cjs/str/numberformat.d.ts

@@ -4,10 +4,14 @@
  * The pattern syntax is Java's DecimalFormat: `0` required digit, `#` optional digit, `,` grouping,
  * `.` decimal point, `E0` exponent, `%` multiplies by 100, `'...'` quoted literal text.
  * PineScript rules:
- * - `str.tostring` rounds half away from zero on the shortest decimal form of the number
+ * - `str.tostring` with a format rounds half away from zero on the shortest decimal form of the number
  *   (`1.005` with "#.##" gives "1.01", `2.5` with "#" gives "3")
+ * - `str.tostring` without a format rounds the digits of the JVM's binary to decimal conversion to 10 decimals,
+ *   half to even, the conversion flags deciding a tie (see `floatingdecimal.ts`): 12.34500000005 gives "12.345"
+ *   ("12.3450000001" with the format "#.##########"), 1791662400001 / 900000 gives "1990736.000001111"
  * - `str.format` rounds half to even on the exact binary value (`0.25` with "#.#" gives "0.2")
- * - a negative number that rounds to zero loses its sign; "#.00" writes `.50` (no leading zero),
+ * - a negative number that rounds to zero loses its sign, except with "%" ("#.#%": -0.0004 gives "-0%");
+ *   "#.00" writes `.50` (no leading zero),
  *   but "#.##" writes `0.5` (a pattern without any '0' shows one integer digit)
  * - with an exponent, the value is first rounded to the fraction digits ("0.00E0": 0.125 gives "1.30E-1")
  * - a pattern without digit characters (`format.price` is "price") formats like "#" after its text,
@@ -17,7 +21,7 @@
  * - at most 16 decimals when |x| >= 1e-3 (the shortest digits of a double never have more there):
  *   0.1 with 20 '#' decimals gives "0.1" in both rounding modes
  */
-export type Rounding = 'halfUpShortest' | 'halfEvenExact';
+export type Rounding = 'halfUpShortest' | 'halfUpExact' | 'halfEvenExact' | 'halfEvenConverted';
 /** Formats a number with a DecimalFormat pattern. */
 export declare function formatNumber(value: number, pattern: string, mode: Rounding): string;
 /**

package/dist/cjs/str/numberformat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"numberformat.d.ts","sourceRoot":"","sources":["../../../src/str/numberformat.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,MAAM,QAAQ,GAAG,gBAAgB,GAAG,eAAe,CAAC;AA8K1D,qDAAqD;AACrD,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,MAAM,CA6BnF;AASD;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAMhF"}
+{"version":3,"file":"numberformat.d.ts","sourceRoot":"","sources":["../../../src/str/numberformat.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAIH,MAAM,MAAM,QAAQ,GAAG,gBAAgB,GAAG,aAAa,GAAG,eAAe,GAAG,mBAAmB,CAAC;AA8KhG,qDAAqD;AACrD,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,MAAM,CA8BnF;AASD;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAMhF"}

package/dist/cjs/str/numberformat.js

@@ -22,6 +22,7 @@ __export(numberformat_exports, {
   tickScale: () => tickScale
 });
 module.exports = __toCommonJS(numberformat_exports);
+var import_floatingdecimal = require("./floatingdecimal.js");
 const patterns = /* @__PURE__ */ new Map();
 function subpatternSplit(pattern) {
   let quoted = false;
@@ -129,7 +130,7 @@ function roundDigits(d, frac, mode) {
   if (keep < 0) return { digits: "", intLen: 0 };
   const first = d.digits.charCodeAt(keep) - 48;
   let up;
-  if (mode === "halfUpShortest") up = first >= 5;
+  if (mode !== "halfEvenExact") up = first >= 5;
   else if (first !== 5) up = first > 5;
   else if (d.digits.length > keep + 1) up = true;
   else up = keep > 0 && (d.digits.charCodeAt(keep - 1) - 48) % 2 === 1;
@@ -179,11 +180,11 @@ function formatNumber(value, pattern, mode) {
     body = layout(mant, p) + "E" + (exponent < 0 ? "-" : "") + e;
   } else {
     const frac = !p.hasDigits ? 0 : Math.abs(x) >= 1e-3 ? Math.min(p.maxFrac, 16) : p.maxFrac;
-    const rounded = roundDigits(toDigits(x), frac, mode);
+    const rounded = mode === "halfEvenConverted" ? (0, import_floatingdecimal.javaFixedDigits)(x, frac) : roundDigits(toDigits(x), frac, mode);
     isZero = rounded.digits === "";
     body = p.hasDigits ? layout(rounded, p) : layout(rounded, { ...p, minInt: 0, maxFrac: 0, minFrac: 0 });
   }
-  return affixes(p, x < 0 && (!isZero || !p.hasDigits), body);
+  return affixes(p, x < 0 && (!isZero || !p.hasDigits || p.percent), body);
 }
 function affixes(p, negative, body) {
   if (!negative) return p.prefix + body + p.suffix;