oakscriptjs 0.10.1 → 0.11.1

package/src/session/context.ts

@@ -0,0 +1,162 @@
+/**
+ * The session of a chart context, for code that does not run a whole script (a port with its own bar loop).
+ *
+ * The same values as the script API gives (`time(tf)`, `time_close(tf)`, `time_tradingday`, `session.*`, the periods
+ * of `request.security`), from the session, corrections and holidays of the context. Bar times are in the unit of
+ * the context (`timeUnit`, seconds by default, as `Bar.time`); PineScript time values are returned in ms.
+ *
+ * @module session/context
+ */
+
+import type { Bar } from '../types/index.js';
+import { info, in_seconds } from '../timeframe/index.js';
+import { afterCompletion, periodsOf, resample } from '../security/resample.js';
+import { SessionBars, sessionFlags, strayPeriods, type SessionFlags } from './bars.js';
+import { TradingCalendar, type SessionSpec } from './calendar.js';
+
+/** The part of a chart context that the session functions read (a `ChartContext` of the script API fits). */
+export interface SessionContext {
+  /** Chart timeframe: "5", "60", "1D"... */
+  timeframe?: string;
+  /** Exchange time zone: "America/New_York", "Etc/UTC"... */
+  timezone?: string;
+  /** Session of the loaded bars: hours, corrections, holidays */
+  session?: SessionSpec | string;
+  /** Regular trading hours when the bars include extended hours (default: `session`) */
+  regularSession?: SessionSpec | string;
+  /** Unit of the bar times: 's' (default) or 'ms' */
+  timeUnit?: 's' | 'ms';
+}
+
+/** The session calendars of a context: the loaded bars and the regular hours. */
+export interface ChartSessions {
+  bars: SessionBars;
+  regular: SessionBars;
+  /** ms per unit of the bar times */
+  unit: number;
+}
+
+const toSpec = (s: SessionSpec | string): SessionSpec => (typeof s === 'string' ? { session: s } : s);
+const cache = new WeakMap<object, ChartSessions>();
+
+/**
+ * Session calendars of a chart context (cached per context object).
+ * @throws Error when the context has no timeframe, time zone or session
+ */
+export function chartSessions(chart: SessionContext): ChartSessions {
+  const cached = cache.get(chart);
+  if (cached) return cached;
+  const { timeframe, timezone, session } = chart;
+  if (!timeframe || !timezone || !session) {
+    throw new Error('The chart context needs timeframe, timezone and session for the session functions.');
+  }
+  const loaded = toSpec(session);
+  const regular = chart.regularSession ? toSpec(chart.regularSession) : loaded;
+  const out: ChartSessions = {
+    bars: new SessionBars(new TradingCalendar(timezone, loaded), timeframe),
+    regular: new SessionBars(new TradingCalendar(timezone, { holidays: loaded.holidays, ...regular }), timeframe),
+    unit: chart.timeUnit === 'ms' ? 1 : 1000,
+  };
+  cache.set(chart, out);
+  return out;
+}
+
+/** PineScript `time(timeframe)` (ms) of a bar that opens at `time`: the start of its period; NaN without one. */
+export function periodTime(time: number, timeframe: string, chart: SessionContext): number {
+  const s = chartSessions(chart);
+  return s.bars.timeOf(time * s.unit, timeframe);
+}
+
+/** PineScript `time_close(timeframe)` (ms) of a bar that opens at `time`. */
+export function periodClose(time: number, timeframe: string, chart: SessionContext): number {
+  const s = chartSessions(chart);
+  return s.bars.closeOf(time * s.unit, timeframe);
+}
+
+/** PineScript `time_tradingday` (ms, 00:00 UTC of the trading day) of a bar that opens at `time`. */
+export function tradingDayTime(time: number, chart: SessionContext): number {
+  const s = chartSessions(chart);
+  return s.bars.tradingDayTime(time * s.unit);
+}
+
+/** PineScript `session.*` flags of bars that open at `times` (in order). */
+export function chartSessionFlags(times: ArrayLike<number>, chart: SessionContext): SessionFlags {
+  const s = chartSessions(chart);
+  return sessionFlags(Array.from(times, (t) => t * s.unit), s.bars, s.regular);
+}
+
+/** Higher-timeframe bars of the chart bars and what `mapToChart` needs to bring values back to the chart. */
+export interface SessionResample {
+  /** Bars of `timeframe`, built from the chart bars */
+  bars: Bar[];
+  /** Period index of each chart bar */
+  group: number[];
+  /** Latest completed period at each chart bar */
+  latest: number[];
+}
+
+/**
+ * Same-symbol `request.security` on a timeframe equal to or higher than the chart's, with the session of the context:
+ * D / W / M periods follow the regular hours, corrections and holidays; intraday periods the loaded session.
+ * Compute on `bars`, then bring each value series back with `mapToChart(values, group, latest, lookahead, gaps)`.
+ * @throws Error when `timeframe` is lower than the chart timeframe
+ */
+export function resampleSession(bars: Bar[], timeframe: string, chart: SessionContext): SessionResample {
+  const s = chartSessions(chart);
+  const chartTf = s.bars.chart;
+  const tf = info(timeframe || chartTf.period);
+  if (tf.period === chartTf.period) {
+    const group = bars.map((_, i) => i);
+    return { bars, group, latest: group };
+  }
+  if (in_seconds(tf.period) < in_seconds(chartTf.period)) {
+    throw new Error(`resampleSession: timeframe "${tf.period}" is lower than the chart timeframe "${chartTf.period}".`);
+  }
+  const times = bars.map((b) => (b.time as number) * s.unit);
+  const calendar = tf.isdwm ? s.regular : s.bars;
+  const starts = times.map((t) => calendar.timeOf(t, tf.period));
+  const dayPeriods = times.map((t, i) => {
+    const at = s.bars.calendar.locate(t);
+    const periods = at ? calendar.calendar.periods(at.date) : [];
+    return periods.length ? calendar.timeOf(periods[0]![0], tf.period) : starts[i]!;
+  });
+  strayPeriods(starts, dayPeriods, times, s.bars, tf.isdwm ? null : in_seconds(tf.period) * 1000);
+  const reaches = times.map((t) => s.bars.closeOf(t, chartTf.period) >= calendar.periodEnd(t, tf.period));
+  const { group, latest } = periodsOf(starts, dayPeriods, reaches);
+  // a higher-timeframe bar ends at the bar that completes it (no value from after the completion)
+  const after = afterCompletion(group, latest);
+  const kept = (_: unknown, i: number): boolean => !after[i];
+  return { bars: resample(bars.filter(kept), starts.map((x) => x / s.unit).filter(kept)).bars, group, latest };
+}
+
+/**
+ * Open time of the `count`-th bar after the bar that opens at `time`, on the trading calendar of the context: the
+ * closed hours, weekends, holidays and days off are skipped. `count` 0 is the bar itself. For a drawing that ends
+ * `count` bars after the last bar (PineScript `bar_index + count`).
+ */
+export function barTimeAfter(time: number, count: number, chart: SessionContext): number {
+  const s = chartSessions(chart);
+  let t = time * s.unit;
+  for (let k = 0; k < count && !Number.isNaN(t); k++) t = s.bars.nextBarTime(t);
+  return t / s.unit;
+}
+
+/**
+ * Number of bars from the bar that opens at `from` to the bar that contains `to`, on the trading calendar of the
+ * context (0 when `to` is in the bar of `from` or before it). For a drawing placed at a time after the last bar
+ * (PineScript `time + n days` with `xloc.bar_time`): the chart shows it on the bar of that time, weekends and
+ * holidays skipped. `to` is first rounded to the nearest second, a half second going up (#174: 15 ms before a bar
+ * opens is on that bar, 501 ms before is on the bar before). NaN when no bar is found within 100,000 bars.
+ */
+export function barsUntil(from: number, to: number, chart: SessionContext): number {
+  const s = chartSessions(chart);
+  const target = Math.floor((to * s.unit) / 1000 + 0.5) * 1000;
+  let t = from * s.unit;
+  for (let k = 0; k < 100_000; k++) {
+    const next = s.bars.nextBarTime(t);
+    if (Number.isNaN(next)) return NaN;
+    if (next > target) return k;
+    t = next;
+  }
+  return NaN;
+}

package/src/str/floatingdecimal.ts

@@ -0,0 +1,268 @@
+/**
+ * Decimal digits of a double as PineScript's plain `str.tostring` produces them.
+ *
+ * PineScript formats a number without a format with the digits of the classic binary to decimal conversion of the
+ * JVM (the one `Double.toString` used before Java 19), then rounds them to 10 decimals half to even, with two
+ * flags of the conversion deciding a tie on the last digit: digits that were rounded up are not rounded up again,
+ * digits that were cut on a '5' are. These digits are not always the shortest ones: 78195689105219552 keeps all
+ * its digits (the shortest form is 78195689105219550), and 1990736.000001111 has 16 digits where rounding the exact
+ * value would give 1990736.0000011111 (#174).
+ */
+
+/** Digits d1d2d3... of |x| = 0.d1d2d3... × 10^decExponent, with the flags of the conversion. */
+export interface ConvertedDigits {
+  digits: string;
+  decExponent: number;
+  /** The last digit was rounded up */
+  roundedUp: boolean;
+  /** The digits are the exact value of the double */
+  exact: boolean;
+}
+
+const EXP_SHIFT = 52;
+const MAX_SMALL_BIN_EXP = 62;
+const MIN_SMALL_BIN_EXP = -21;
+// approximately ceil(log2(5^i))
+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];
+// number of decimal digits of 2^i minus one, for i < 64
+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): bigint => BigInt.asIntN(32, v);
+const int64 = (v: bigint): bigint => BigInt.asIntN(64, v);
+
+function trailingZeros(v: bigint): number {
+  let n = 0;
+  while ((v & 1n) === 0n) {
+    v >>= 1n;
+    n++;
+  }
+  return n;
+}
+
+/** floor(log10(x)) estimate of the conversion (it can be one too high). */
+function estimateDecExp(fractBits: bigint, binExp: number): number {
+  view.setBigUint64(0, (1023n << 52n) | (fractBits & 0xfffffffffffffn));
+  const d2 = view.getFloat64(0);
+  const d = (d2 - 1.5) * 0.289529654 + 0.176091259 + binExp * 0.301029995663981;
+  // the conversion truncates toward zero and corrects negative non-integers down
+  const r = Math.trunc(d);
+  return d < 0 && r !== d ? r - 1 : r;
+}
+
+/** Digits of a positive finite double, as the JVM converter gives them. */
+export function convertDouble(x: number): ConvertedDigits {
+  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: number;
+  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);
+
+  // an integer that fits in a long: its digits, the low ones rounded away when they are not significant
+  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;
+  // an exact power of two: the next smaller double is half as far
+  if (nFractBits === 1) M2 -= 1;
+  if (M2 < 0) {
+    B2 -= M2;
+    S2 -= M2;
+    M2 = 0;
+  }
+
+  const digits: number[] = [];
+  let low: boolean;
+  let high: boolean;
+  let lowDigitDifference: bigint;
+  let exact: boolean;
+  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);
+  // two digits at least in the exponent form
+  const minTwo = decExp < -3 || decExp >= 8;
+
+  if (Bbits < 64 && tenSbits < 64) {
+    // int or long arithmetic, with its overflows
+    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 = (): void => {
+    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 };
+}
+
+/**
+ * `|x|` with at most `maxFrac` decimals, as the JVM's decimal formatter rounds the converted digits (half to even;
+ * a tie on the last converted digit is decided by the conversion flags). Returns the digits and the position of the
+ * decimal point (value = 0.digits × 10^intLen); "" for zero.
+ */
+export function javaFixedDigits(x: number, maxFrac: number): { digits: string; intLen: number } {
+  if (x === 0) return { digits: '', intLen: 0 };
+  const c = convertDouble(x);
+  const digits = [...c.digits].map(Number);
+  let decimalAt = c.decExponent;
+  // the formatter reads the conversion's text, which ends in ".0" when no digit follows the point ("5.0E-11",
+  // "120.0"): that zero is a digit for the tie test below (5e-11 to 10 decimals gives 0)
+  const n = digits.length;
+  if (decimalAt > 0 && decimalAt < 8) {
+    if (n <= decimalAt) digits.push(...Array<number>(decimalAt - n + 1).fill(0));
+  } else if (decimalAt <= -3 || decimalAt >= 8) {
+    if (n === 1) digits.push(0);
+  }
+  let count = digits.length;
+
+  const shouldRoundUp = (keep: number): boolean => {
+    if (keep >= count) return false;
+    if (digits[keep]! > 5) return true;
+    if (digits[keep] !== 5) return false;
+    if (keep === count - 1) {
+      if (c.exact) return keep > 0 && digits[keep - 1]! % 2 !== 0;
+      return !c.roundedUp;
+    }
+    for (let i = keep + 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 };
+}

package/src/str/index.ts

@@ -45,7 +45,10 @@ export 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)")
@@ -72,6 +75,8 @@ export function length(str: simple_string): int {
  * ```
  */
 export function tostring(value: any, format?: simple_string, mintick?: float, pricescale?: float): string {
+  // an array: "[a, b]", each element as a single value
+  if (Array.isArray(value)) return '[' + value.map((v) => tostring(v, format, mintick, pricescale)).join(', ') + ']';
   if (typeof value !== 'number') return String(value);
   if (Number.isNaN(value)) return format === 'percent' ? 'NaN%' : 'NaN';
   if (!Number.isFinite(value)) {
@@ -83,7 +88,8 @@ export function tostring(value: any, format?: simple_string, mintick?: float, pr
     if (Math.abs(value) >= 1e21 && Number.isFinite(value)) {
       return String(value).replace('e+', 'E').replace(/\.0+E/, 'E');
     }
-    return formatNumber(value, '#.##########', 'halfUpShortest');
+    // without a format: the digits of the JVM conversion, 10 decimals half to even (#171, #174)
+    return formatNumber(value, '#.##########', 'halfEvenConverted');
   }
   switch (format) {
     case 'percent':

package/src/str/numberformat.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,
@@ -18,7 +22,9 @@
  *   0.1 with 20 '#' decimals gives "0.1" in both rounding modes
  */
 
-export type Rounding = 'halfUpShortest' | 'halfEvenExact';
+import { javaFixedDigits } from './floatingdecimal.js';
+
+export type Rounding = 'halfUpShortest' | 'halfUpExact' | 'halfEvenExact' | 'halfEvenConverted';
 
 interface Pattern {
   prefix: string;
@@ -161,7 +167,7 @@ function roundDigits(d: Digits, frac: number, mode: Rounding): Digits {
   if (keep < 0) return { digits: '', intLen: 0 };
   const first = d.digits.charCodeAt(keep) - 48;
   let up: boolean;
-  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;
@@ -217,11 +223,12 @@ export function formatNumber(value: number, pattern: string, mode: Rounding): st
   } else {
     // 16 decimals at most from 1e-3 up (the shortest digits of a double have no more there)
     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' ? 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);
+  // a negative number that rounds to zero keeps its sign with a percent pattern ("-0%", #180)
+  return affixes(p, x < 0 && (!isZero || !p.hasDigits || p.percent), body);
 }
 
 /** `body` with the text of the positive pattern, or of the negative one ("-" + prefix without "pos;neg"). */