oakscriptjs 0.8.1 → 0.9.0

package/dist/cjs/str/index.js

@@ -0,0 +1,143 @@
+"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 str_exports = {};
+__export(str_exports, {
+  charAt: () => charAt,
+  concat: () => concat,
+  contains: () => contains,
+  endswith: () => endswith,
+  format: () => format,
+  format_time: () => format_time,
+  length: () => length,
+  lower: () => lower,
+  match: () => match,
+  pos: () => pos,
+  repeat: () => repeat,
+  replace: () => replace,
+  replace_all: () => replace_all,
+  split: () => split,
+  startswith: () => startswith,
+  substring: () => substring,
+  tonumber: () => tonumber,
+  tostring: () => tostring,
+  trim: () => trim,
+  trimLeft: () => trimLeft,
+  trimRight: () => trimRight,
+  upper: () => upper
+});
+module.exports = __toCommonJS(str_exports);
+var import_numberformat = require("./numberformat.js");
+var import_messageformat = require("./messageformat.js");
+var import_dateformat = require("./dateformat.js");
+function length(str) {
+  return str.length;
+}
+function tostring(value, format2) {
+  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 (0, import_numberformat.formatNumber)(value, "#.##########", "halfUpShortest");
+  }
+  switch (format2) {
+    case "percent":
+      return (0, import_numberformat.formatNumber)(value, "0.00", "halfUpShortest") + "%";
+    case "volume": {
+      const abs = Math.abs(value);
+      for (const [size, unit] of [[1e12, "T"], [1e9, "B"], [1e6, "M"], [1e3, "K"]]) {
+        if (abs >= size) return (0, import_numberformat.formatNumber)(value / size, "#.###", "halfUpShortest") + unit;
+      }
+      return (0, import_numberformat.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 (0, import_numberformat.formatNumber)(value, format2, "halfUpShortest");
+  }
+}
+function tonumber(str) {
+  const num = parseFloat(str);
+  return isNaN(num) ? null : num;
+}
+function substring(str, begin, end) {
+  return str.substring(begin, end);
+}
+function upper(str) {
+  return str.toUpperCase();
+}
+function lower(str) {
+  return str.toLowerCase();
+}
+function contains(source, str) {
+  return source.includes(str);
+}
+function pos(source, str) {
+  return source.indexOf(str);
+}
+function replace(source, target, replacement, occurrence) {
+  if (occurrence === 0) {
+    return source.replace(target, replacement);
+  } else {
+    return source.replaceAll(target, replacement);
+  }
+}
+function replace_all(source, target, replacement) {
+  return source.replaceAll(target, replacement);
+}
+function split(str, separator) {
+  return str.split(separator);
+}
+function concat(...strings) {
+  return strings.join("");
+}
+function format(formatStr, ...args) {
+  return (0, import_messageformat.formatMessage)(formatStr, args, "Etc/UTC");
+}
+function startswith(source, str) {
+  return source.startsWith(str);
+}
+function endswith(source, str) {
+  return source.endsWith(str);
+}
+function charAt(str, pos2) {
+  return str.charAt(pos2);
+}
+function trim(str) {
+  return str.trim();
+}
+function trimLeft(str) {
+  return str.trimStart();
+}
+function trimRight(str) {
+  return str.trimEnd();
+}
+function match(source, regex) {
+  return new RegExp(regex).test(source);
+}
+function repeat(source, count, separator = "") {
+  if (source == null) return null;
+  if (count <= 0) return "";
+  return Array(count).fill(source).join(separator);
+}
+function format_time(time, format2 = "yyyy-MM-dd'T'HH:mm:ssZ", timezone = "Etc/UTC") {
+  return (0, import_dateformat.formatDate)(time, format2, timezone);
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +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 } 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.price` / `format.inherit`\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 * - \"#\" 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` needs the symbol's tick size and throws here\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): string {\n  if (typeof value !== 'number') return String(value);\n  if (!Number.isFinite(value)) return String(value); // NaN (na), Infinity\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      throw new Error('str.tostring(x, format.mintick) needs the symbol tick size (syminfo.mintick), which is not known here');\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 if conversion fails\n *\n * @remarks\n * - Returns null for invalid number strings\n * - Supports scientific notation (e.g., \"1e3\")\n * - Supports decimal numbers (e.g., \"0.5\", \".5\")\n * - Whitespace is ignored\n * - \"NaN\" string returns null\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(\"1e3\") // Returns: 1000\n * ```\n */\nexport function tonumber(str: simple_string): float | null {\n  const num = parseFloat(str);\n  return isNaN(num) ? null : num;\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 * - 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  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 -1 if not found\n *\n * @remarks\n * - Search is case-sensitive\n * - Returns 0 for empty search string\n * - Returns -1 if substring is not found\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: -1\n * ```\n */\nexport function pos(source: simple_string, str: simple_string): int {\n  return source.indexOf(str);\n}\n\n/**\n * Replaces occurrences of a substring with another string.\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 - If 0, replaces first occurrence only; otherwise replaces all occurrences (default: all)\n * @returns The string with replacements made\n *\n * @remarks\n * - Search is case-sensitive\n * - If target is not found, returns source unchanged\n * - occurrence parameter: 0 = first only, any other value = all occurrences\n *\n * @example\n * ```typescript\n * str.replace(\"hello world hello\", \"hello\", \"hi\", 0) // Returns: \"hi world hello\"\n * str.replace(\"hello world hello\", \"hello\", \"hi\") // Returns: \"hi 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): string {\n  if (occurrence === 0) {\n    return source.replace(target, replacement);\n  } else {\n    return source.replaceAll(target, replacement);\n  }\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\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  return 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; `'...'` is literal text and `''` a quote; 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 * Tests if a string matches a regular expression pattern.\n *\n * @param source - The string to test\n * @param regex - The regular expression pattern\n * @returns True if the pattern matches, false otherwise\n *\n * @remarks\n * - Uses JavaScript regex syntax\n * - Match is case-sensitive by default\n * - Pattern is tested against entire string\n *\n * @example\n * ```typescript\n * str.match(\"hello123\", \"\\\\d+\") // Returns: true\n * str.match(\"test@example.com\", \"^[a-z]+@[a-z]+\\\\.[a-z]+$\") // Returns: true\n * str.match(\"abc\", \"[A-Z]+\") // Returns: false\n * ```\n */\nexport function match(source: simple_string, regex: simple_string): bool {\n  return new RegExp(regex).test(source);\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 (must be >= 0)\n * @param separator - String to inject between repeated instances. Optional, defaults to empty string.\n * @returns The repeated string, or null if source is null/undefined\n *\n * @example\n * ```typescript\n * str.repeat(\"ab\", 3) // Returns: \"ababab\"\n * str.repeat(\"?\", 3, \",\") // Returns: \"?,?,?\"\n * str.repeat(\"hello\", 0) // Returns: \"\"\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 '';\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/messageformat.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `str.format` patterns as PineScript formats them (Java MessageFormat):
+ *
+ * - `{n}` inserts argument n; numbers use "#,##0.###" (1234.5678 gives "1,234.568")
+ * - `{n,number}`, `{n,number,integer}` ("#,##0"), `{n,number,percent}` ("#,##0%"),
+ *   `{n,number,currency}` ("$1,234.57", "-$7.00"), `{n,number,<pattern>}`
+ * - `{n,date}`, `{n,time}`, `{n,date,<pattern>}`, `{n,time,<pattern>}` (styles short, medium, long, full)
+ * - `{n,choice,0#zero|1#one|1<many}`
+ * - numbers round half to even on the exact binary value (0.5 as integer gives "0")
+ * - `'...'` is literal text and `''` is a quote; a missing argument leaves `{n}` in the text
+ */
+/** Formats `pattern` with `args` like PineScript `str.format`; dates use `timezone` (read only when a date is formatted). */
+export declare function formatMessage(pattern: string, args: unknown[], timezone: string | (() => string)): string;
+//# sourceMappingURL=messageformat.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"messageformat.d.ts","sourceRoot":"","sources":["../../../src/str/messageformat.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AA2DH,6HAA6H;AAC7H,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,CAAC,MAAM,MAAM,CAAC,GAAG,MAAM,CAsCzG"}

package/dist/cjs/str/messageformat.js

@@ -0,0 +1,114 @@
+"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 messageformat_exports = {};
+__export(messageformat_exports, {
+  formatMessage: () => formatMessage
+});
+module.exports = __toCommonJS(messageformat_exports);
+var import_numberformat = require("./numberformat.js");
+var import_dateformat = require("./dateformat.js");
+const DATE_STYLES = {
+  short: "M/d/yy",
+  medium: "MMM d, yyyy",
+  long: "MMMM d, yyyy",
+  full: "EEEE, MMMM d, yyyy"
+};
+const 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" ? (0, import_numberformat.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 (0, import_dateformat.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;
+}
+//# sourceMappingURL=messageformat.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/str/messageformat.ts"],
+  "sourcesContent": ["/**\n * `str.format` patterns as PineScript formats them (Java MessageFormat):\n *\n * - `{n}` inserts argument n; numbers use \"#,##0.###\" (1234.5678 gives \"1,234.568\")\n * - `{n,number}`, `{n,number,integer}` (\"#,##0\"), `{n,number,percent}` (\"#,##0%\"),\n *   `{n,number,currency}` (\"$1,234.57\", \"-$7.00\"), `{n,number,<pattern>}`\n * - `{n,date}`, `{n,time}`, `{n,date,<pattern>}`, `{n,time,<pattern>}` (styles short, medium, long, full)\n * - `{n,choice,0#zero|1#one|1<many}`\n * - numbers round half to even on the exact binary value (0.5 as integer gives \"0\")\n * - `'...'` is literal text and `''` is a quote; a missing argument leaves `{n}` in the text\n */\n\nimport { formatNumber } from './numberformat.js';\nimport { formatDate } from './dateformat.js';\n\nconst DATE_STYLES: Record<string, string> = {\n  short: 'M/d/yy', medium: 'MMM d, yyyy', long: 'MMMM d, yyyy', full: 'EEEE, MMMM d, yyyy',\n};\n// PineScript writes a narrow no-break space (U+202F) before AM/PM in the time styles\nconst TIME_STYLES: Record<string, string> = {\n  short: 'h:mm\u202Fa', medium: 'h:mm:ss\u202Fa', long: 'h:mm:ss\u202Fa z', full: 'h:mm:ss\u202Fa z',\n};\n\nfunction number(value: unknown, pattern: string): string {\n  return typeof value === 'number' ? formatNumber(value, pattern, 'halfEvenExact') : String(value);\n}\n\nfunction choice(value: number, spec: string): string {\n  const options = spec.split('|').map((part) => {\n    const m = /^\\s*(-?[\\d.]+|-?\u221E)\\s*([#<\u2264])(.*)$/.exec(part);\n    if (!m) throw new SyntaxError(`Invalid choice format \"${spec}\"`);\n    const limit = m[1]!.includes('\u221E') ? (m[1]!.startsWith('-') ? -Infinity : Infinity) : Number(m[1]);\n    return { limit: m[2] === '<' ? limit + Number.EPSILON * Math.max(1, Math.abs(limit)) : limit, text: m[3]! };\n  });\n  let chosen = options[0]!;\n  for (const o of options) if (value >= o.limit) chosen = o;\n  return chosen.text;\n}\n\nfunction formatArgument(\n  value: unknown,\n  type: string | undefined,\n  style: string | undefined,\n  timezone: string | (() => string)\n): string {\n  if (value === undefined) return '';\n  if (!type) return typeof value === 'number' ? number(value, '#,##0.###') : String(value);\n  switch (type.trim()) {\n    case 'number': {\n      const s = style?.trim();\n      if (!s) return number(value, '#,##0.###');\n      if (s === 'integer') return number(value, '#,##0');\n      if (s === 'percent') return number(value, '#,##0%');\n      if (s === 'currency') return number(value, \"'$'#,##0.00\");\n      return number(value, style!);\n    }\n    case 'date':\n    case 'time': {\n      const styles = type.trim() === 'date' ? DATE_STYLES : TIME_STYLES;\n      const s = style?.trim() ?? 'medium';\n      return formatDate(Number(value), styles[s] ?? style!, typeof timezone === 'function' ? timezone() : timezone);\n    }\n    case 'choice':\n      return choice(Number(value), style ?? '');\n    default:\n      throw new SyntaxError(`Unknown format type \"${type}\"`);\n  }\n}\n\n/** Formats `pattern` with `args` like PineScript `str.format`; dates use `timezone` (read only when a date is formatted). */\nexport function formatMessage(pattern: string, args: unknown[], timezone: string | (() => string)): string {\n  let out = '';\n  for (let i = 0; i < pattern.length; ) {\n    const ch = pattern[i]!;\n    if (ch === \"'\") {\n      if (pattern[i + 1] === \"'\") {\n        out += \"'\";\n        i += 2;\n        continue;\n      }\n      const end = pattern.indexOf(\"'\", i + 1);\n      out += pattern.slice(i + 1, end === -1 ? undefined : end);\n      i = end === -1 ? pattern.length : end + 1;\n      continue;\n    }\n    if (ch !== '{') {\n      out += ch;\n      i++;\n      continue;\n    }\n    // {index[,type[,style]]}; the style may contain quoted text and nested braces\n    let depth = 1;\n    let j = i + 1;\n    let inQuote = false;\n    for (; j < pattern.length && depth > 0; j++) {\n      const c = pattern[j];\n      if (c === \"'\") inQuote = !inQuote;\n      else if (!inQuote && c === '{') depth++;\n      else if (!inQuote && c === '}') depth--;\n    }\n    const inner = pattern.slice(i + 1, j - 1);\n    const [index = '', type, ...rest] = inner.split(',');\n    const style = rest.length ? rest.join(',') : undefined;\n    const n = Number(index.trim());\n    out += n < args.length ? formatArgument(args[n], type, style, timezone) : `{${inner}}`;\n    i = j;\n  }\n  return out;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Number patterns ("#.##", "#,##0.00", "0.00E0", "#.##%", "'#'#.##") as PineScript formats them.
+ *
+ * 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
+ *   (`1.005` with "#.##" gives "1.01", `2.5` with "#" gives "3")
+ * - `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),
+ *   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,
+ *   and keeps the sign: -0.004 gives "-price0"
+ */
+export type Rounding = 'halfUpShortest' | 'halfEvenExact';
+/** Formats a number with a DecimalFormat pattern. */
+export declare function formatNumber(value: number, pattern: string, mode: Rounding): string;
+//# sourceMappingURL=numberformat.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"numberformat.d.ts","sourceRoot":"","sources":["../../../src/str/numberformat.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,MAAM,MAAM,QAAQ,GAAG,gBAAgB,GAAG,eAAe,CAAC;AAuJ1D,qDAAqD;AACrD,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,MAAM,CA4BnF"}

package/dist/cjs/str/numberformat.js

@@ -0,0 +1,170 @@
+"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 numberformat_exports = {};
+__export(numberformat_exports, {
+  formatNumber: () => formatNumber
+});
+module.exports = __toCommonJS(numberformat_exports);
+const patterns = /* @__PURE__ */ new Map();
+function parsePattern(pattern) {
+  const cached = patterns.get(pattern);
+  if (cached) return cached;
+  let prefix = "";
+  let suffix = "";
+  let number = "";
+  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";
+      number += ch;
+      continue;
+    } else {
+      if (ch === "%") percent = true;
+      literal = ch;
+    }
+    if (phase === "number") phase = "suffix";
+    if (phase === "prefix") prefix += literal;
+    else suffix += literal;
+  }
+  const [mantissa = "", exp] = number.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: exp === void 0 ? null : exp.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 all = m[1] + (m[2] ?? "");
+  let intLen = m[1].length + Number(m[3] ?? 0);
+  const lead = all.length - all.replace(/^0+/, "").length;
+  intLen -= lead;
+  const digits = all.slice(lead).replace(/0+$/, "");
+  return { digits, intLen: digits ? intLen : 0 };
+}
+function exactDigits(x) {
+  const abs = Math.abs(x);
+  if (abs === 0) return { digits: "", intLen: 0 };
+  const view = new DataView(new ArrayBuffer(8));
+  view.setFloat64(0, abs);
+  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, mode) {
+  const keep = d.intLen + frac;
+  if (keep >= d.digits.length) return d;
+  if (keep < 0) return { digits: "", intLen: 0 };
+  const first = d.digits.charCodeAt(keep) - 48;
+  let up;
+  if (mode === "halfUpShortest") 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;
+  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, size) {
+  if (!size || int.length <= size) return int;
+  const parts = [];
+  for (let end = int.length; end > 0; end -= size) parts.unshift(int.slice(Math.max(0, end - size), 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, mode) {
+  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 = mode === "halfUpShortest" ? shortestDigits : exactDigits;
+  let body;
+  let isZero;
+  if (p.exponent !== null) {
+    const rounded = roundDigits(toDigits(x), p.maxFrac, mode);
+    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, mode);
+    if (mant.intLen > intDigits) {
+      exponent += 1;
+      mant = { digits: mant.digits, intLen: intDigits };
+    }
+    const e = String(Math.abs(exponent)).padStart(p.exponent, "0");
+    body = layout(mant, p) + "E" + (exponent < 0 ? "-" : "") + e;
+  } else {
+    const rounded = roundDigits(toDigits(x), p.hasDigits ? p.maxFrac : 0, mode);
+    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;
+}
+//# sourceMappingURL=numberformat.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/str/numberformat.ts"],
+  "sourcesContent": ["/**\n * Number patterns (\"#.##\", \"#,##0.00\", \"0.00E0\", \"#.##%\", \"'#'#.##\") as PineScript formats them.\n *\n * The pattern syntax is Java's DecimalFormat: `0` required digit, `#` optional digit, `,` grouping,\n * `.` decimal point, `E0` exponent, `%` multiplies by 100, `'...'` quoted literal text.\n * PineScript rules:\n * - `str.tostring` rounds half away from zero on the shortest decimal form of the number\n *   (`1.005` with \"#.##\" gives \"1.01\", `2.5` with \"#\" gives \"3\")\n * - `str.format` rounds half to even on the exact binary value (`0.25` with \"#.#\" gives \"0.2\")\n * - a negative number that rounds to zero loses its sign; \"#.00\" writes `.50` (no leading zero),\n *   but \"#.##\" writes `0.5` (a pattern without any '0' shows one integer digit)\n * - with an exponent, the value is first rounded to the fraction digits (\"0.00E0\": 0.125 gives \"1.30E-1\")\n * - a pattern without digit characters (`format.price` is \"price\") formats like \"#\" after its text,\n *   and keeps the sign: -0.004 gives \"-price0\"\n */\n\nexport type Rounding = 'halfUpShortest' | 'halfEvenExact';\n\ninterface Pattern {\n  prefix: string;\n  suffix: string;\n  minInt: number;\n  minFrac: number;\n  maxFrac: number;\n  /** Digits per group, 0 without grouping */\n  grouping: number;\n  percent: boolean;\n  /** Minimum exponent digits, or null without exponent */\n  exponent: number | null;\n  hasDigits: boolean;\n}\n\nconst patterns = new Map<string, Pattern>();\n\nfunction parsePattern(pattern: string): Pattern {\n  const cached = patterns.get(pattern);\n  if (cached) return cached;\n\n  let prefix = '';\n  let suffix = '';\n  let number = '';\n  let percent = false;\n  let phase: 'prefix' | 'number' | 'suffix' = 'prefix';\n  for (let i = 0; i < pattern.length; i++) {\n    const ch = pattern[i]!;\n    let literal: string;\n    if (ch === \"'\") {\n      const end = pattern.indexOf(\"'\", i + 1);\n      if (end === i + 1) {\n        literal = \"'\";\n        i = end;\n      } else {\n        literal = pattern.slice(i + 1, end === -1 ? undefined : end);\n        i = end === -1 ? pattern.length : end;\n      }\n    } else if (phase !== 'suffix' && ('#0,.'.includes(ch) || (phase === 'number' && ch === 'E'))) {\n      phase = 'number';\n      number += ch;\n      continue;\n    } else {\n      if (ch === '%') percent = true;\n      literal = ch;\n    }\n    if (phase === 'number') phase = 'suffix';\n    if (phase === 'prefix') prefix += literal;\n    else suffix += literal;\n  }\n\n  const [mantissa = '', exp] = number.split('E');\n  const [intPart = '', fracPart = ''] = mantissa.split('.');\n  const lastComma = intPart.lastIndexOf(',');\n  const parsed: Pattern = {\n    prefix,\n    suffix,\n    // as in Java, a pattern with a decimal point and no '0' at all (\"#.##\") shows one integer digit\n    minInt: !mantissa.includes('0') && mantissa.includes('.') ? 1 : [...intPart].filter((c) => c === '0').length,\n    minFrac: [...fracPart].filter((c) => c === '0').length,\n    maxFrac: [...fracPart].filter((c) => c === '0' || c === '#').length,\n    grouping: lastComma === -1 ? 0 : intPart.length - lastComma - 1,\n    percent,\n    exponent: exp === undefined ? null : exp.length,\n    hasDigits: /[0#]/.test(mantissa),\n  };\n  patterns.set(pattern, parsed);\n  return parsed;\n}\n\n/** Decimal digits of |x|: value = 0.d1d2d3... \u00D7 10^intLen (no leading zero digit; \"\" for 0). */\ninterface Digits {\n  digits: string;\n  intLen: number;\n}\n\nfunction shortestDigits(x: number): Digits {\n  const m = /^(\\d+)(?:\\.(\\d+))?(?:e([+-]\\d+))?$/.exec(String(Math.abs(x)))!;\n  const all = m[1]! + (m[2] ?? '');\n  let intLen = m[1]!.length + Number(m[3] ?? 0);\n  const lead = all.length - all.replace(/^0+/, '').length;\n  intLen -= lead;\n  const digits = all.slice(lead).replace(/0+$/, '');\n  return { digits, intLen: digits ? intLen : 0 };\n}\n\n/** Exact decimal expansion of the double |x|. */\nfunction exactDigits(x: number): Digits {\n  const abs = Math.abs(x);\n  if (abs === 0) return { digits: '', intLen: 0 };\n  const view = new DataView(new ArrayBuffer(8));\n  view.setFloat64(0, abs);\n  const bits = view.getBigUint64(0);\n  const expBits = Number((bits >> 52n) & 0x7ffn);\n  let mant = bits & 0xfffffffffffffn;\n  const e2 = expBits === 0 ? -1074 : expBits - 1075;\n  if (expBits !== 0) mant |= 1n << 52n;\n  let str: string;\n  let fracDigits: number;\n  if (e2 >= 0) {\n    str = (mant << BigInt(e2)).toString();\n    fracDigits = 0;\n  } else {\n    str = (mant * 5n ** BigInt(-e2)).toString();\n    fracDigits = -e2;\n  }\n  const intLen = str.length - fracDigits;\n  const lead = str.length - str.replace(/^0+/, '').length;\n  const digits = str.slice(lead).replace(/0+$/, '');\n  return { digits, intLen: intLen - lead };\n}\n\n/** Rounds to `frac` digits after the point. */\nfunction roundDigits(d: Digits, frac: number, mode: Rounding): Digits {\n  const keep = d.intLen + frac;\n  if (keep >= d.digits.length) return d;\n  if (keep < 0) return { digits: '', intLen: 0 };\n  const first = d.digits.charCodeAt(keep) - 48;\n  let up: boolean;\n  if (mode === 'halfUpShortest') up = first >= 5;\n  else if (first !== 5) up = first > 5;\n  else if (d.digits.length > keep + 1) up = true;\n  else up = keep > 0 && (d.digits.charCodeAt(keep - 1) - 48) % 2 === 1;\n  let kept = d.digits.slice(0, keep);\n  let intLen = d.intLen;\n  if (up) {\n    const n = (BigInt(kept || '0') + 1n).toString();\n    if (n.length > kept.length) intLen += 1;\n    kept = n;\n  }\n  kept = kept.replace(/0+$/, '');\n  return { digits: kept, intLen: kept ? intLen : 0 };\n}\n\nfunction group(int: string, size: number): string {\n  if (!size || int.length <= size) return int;\n  const parts: string[] = [];\n  for (let end = int.length; end > 0; end -= size) parts.unshift(int.slice(Math.max(0, end - size), end));\n  return parts.join(',');\n}\n\nfunction layout(d: Digits, p: Pattern): string {\n  let int = d.intLen > 0 ? d.digits.slice(0, d.intLen).padEnd(d.intLen, '0') : '';\n  int = int.replace(/^0+/, '').padStart(p.minInt, '0');\n  let frac = d.intLen < 0 ? '0'.repeat(-d.intLen) + d.digits : d.digits.slice(Math.max(0, d.intLen));\n  frac = frac.slice(0, p.maxFrac).replace(/0+$/, '').padEnd(p.minFrac, '0');\n  if (!int && !frac) int = '0';\n  return group(int, p.grouping) + (frac ? '.' + frac : '');\n}\n\n/** Formats a number with a DecimalFormat pattern. */\nexport function formatNumber(value: number, pattern: string, mode: Rounding): string {\n  if (Number.isNaN(value)) return 'NaN';\n  const p = parsePattern(pattern);\n  if (!Number.isFinite(value)) return (value < 0 ? '-' : '') + p.prefix + '\u221E' + p.suffix;\n  const x = p.percent ? value * 100 : value;\n  const toDigits = mode === 'halfUpShortest' ? shortestDigits : exactDigits;\n\n  let body: string;\n  let isZero: boolean;\n  if (p.exponent !== null) {\n    const rounded = roundDigits(toDigits(x), p.maxFrac, mode);\n    const intDigits = Math.max(p.minInt, 1);\n    isZero = rounded.digits === '';\n    let exponent = isZero ? 0 : rounded.intLen - intDigits;\n    let mant = roundDigits({ digits: rounded.digits, intLen: isZero ? 0 : intDigits }, p.maxFrac, mode);\n    if (mant.intLen > intDigits) {\n      exponent += 1;\n      mant = { digits: mant.digits, intLen: intDigits };\n    }\n    const e = String(Math.abs(exponent)).padStart(p.exponent, '0');\n    body = layout(mant, p) + 'E' + (exponent < 0 ? '-' : '') + e;\n  } else {\n    const rounded = roundDigits(toDigits(x), p.hasDigits ? p.maxFrac : 0, mode);\n    isZero = rounded.digits === '';\n    body = p.hasDigits ? layout(rounded, p) : layout(rounded, { ...p, minInt: 0, maxFrac: 0, minFrac: 0 });\n  }\n  const negative = x < 0 && (!isZero || !p.hasDigits);\n  return (negative ? '-' : '') + p.prefix + body + p.suffix;\n}\n"],
+  "mappings": "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",
+  "names": []
+}