edf2csv 0.8.97 → 0.8.99

package/dist/edf/scale.js.map

@@ -1 +1 @@
-{"version":3,"file":"scale.js","sourceRoot":"","sources":["../../src/edf/scale.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Digital-to-physical conversion.\n *\n * EDF defines the mapping by two calibration points, (digitalMin -> physicalMin)\n * and (digitalMax -> physicalMax), which the specification writes as:\n *\n *   gain     = (physicalMax - physicalMin) / (digitalMax - digitalMin)\n *   physical = (digital - digitalMin) * gain + physicalMin\n *\n * That form is evaluated here in EDFlib's algebraically equivalent arrangement:\n *\n *   offset   = physicalMax / gain - digitalMax\n *   physical = gain * (offset + digital)\n *\n * The rearrangement is not cosmetic. Written the first way, a channel spanning\n * +/-800 uV computes a value near 800 and then subtracts 800, and the cancellation\n * throws away low-order bits: digital 0 yields 0.19536019536019467 when the exact\n * value is 0.19536019536019536. EDFlib's form keeps the intermediate small\n * (offset + digital = 0.5 here) and returns the correctly rounded result.\n *\n * Both properties matter. The values are as accurate as a double can express, and\n * they are bit-identical to pyEDFlib and EDFbrowser, which share EDFlib's arithmetic,\n * so the test suite can assert exact equality against a reference implementation\n * rather than settling for a tolerance.\n */\n\nimport type { EdfSignal } from './header.js';\nimport { OptionError, describeValue } from '../convert/options.js';\n\nexport type Scaler = (digital: number) => number;\n\n/** The four header fields this reads, in the order a message should name them. */\nconst CALIBRATION = ['digitalMin', 'digitalMax', 'physicalMin', 'physicalMax'] as const;\n\n/**\n * The four calibration numbers, confirmed to be on the thing that was passed.\n *\n * Written for `makeScaler` in 0.8.61 and shared since 0.8.76, when the two functions beside\n * it turned out to read the same four fields off the same argument and ask nothing of it.\n * Both answer rather than refuse:\n *\n *     quantizationStep({})     // 0     — the step of a channel whose header contradicts itself\n *     decimalsForSignal(42)    // 3     — the precision an ordinary EEG channel gets\n *\n * `undefined - undefined` is `NaN`, `NaN === 0` is false, and the division that follows gives\n * `NaN`; `quantizationStep` returns it as a step, and `decimalsForSignal` reads a step that is\n * not a positive number as \"this channel has none to derive from\" and falls back to three\n * places. Both of those are real answers for real channels — a zero digital span is what\n * `DEGENERATE_DIGITAL_RANGE` reports, and three places is what most EEG gets — so a caller\n * holding the wrong object gets a number they have no way to doubt.\n */\nfunction assertCalibration(signal: EdfSignal): void {\n  if (typeof signal !== 'object' || signal === null) {\n    throw new OptionError(`signal must be a channel from a header, got ${describeValue(signal)}.`);\n  }\n  const missing = CALIBRATION.find((name) => typeof signal[name] !== 'number');\n  if (missing !== undefined) {\n    throw new OptionError(\n      `signal.${missing} must be a number, got ${describeValue(signal[missing])}.`,\n    );\n  }\n}\n\nexport function makeScaler(signal: EdfSignal): Scaler {\n  /*\n    The argument, checked like the arguments of the other exported functions.\n\n    Every branch below reads four numbers off `signal`, and the first of them — the one that\n    catches a header contradicting itself — is `digitalMax === digitalMin`. On an object that\n    has neither, that comparison is `undefined === undefined`, which is true. So\n    `makeScaler({})` came back as a working function returning NaN for every sample, which is\n    exactly what a real channel with a zero digital span returns.\n\n    A caller cannot tell the two apart. The api page recommends this function for reading\n    physical units out of a file, and the empty column it produces is documented as meaning\n    \"the header contradicts itself\" — a sentence about the recording, over a call that passed\n    the wrong object. The diagnostic that normally accompanies it, DEGENERATE_DIGITAL_RANGE,\n    comes from the header parser and is not raised here at all.\n  */\n  assertCalibration(signal);\n  const { digitalMin, digitalMax, physicalMin, physicalMax } = signal;\n\n  // A zero digital span leaves the mapping undefined — the header contradicts itself,\n  // so there is no physical value for any sample on this channel.\n  //\n  // NaN rather than a stand-in number. Writing the physical minimum produces a column\n  // of plausible readings (\"-100.000\" repeated) that is indistinguishable from a real\n  // flat recording once the CSV is opened somewhere else, which is exactly the kind of\n  // invented data this tool exists to avoid. NaN carries through to an empty CSV cell\n  // and reads back as NaN in pandas, matching how a missing annotation duration is\n  // already written. DEGENERATE_DIGITAL_RANGE is raised alongside it.\n  if (digitalMax === digitalMin) return () => NaN;\n\n  const gain = (physicalMax - physicalMin) / (digitalMax - digitalMin);\n\n  /*\n    A flat physical range makes every sample the same value, and would divide by zero in the\n    offset below. That mapping is defined, so its constant is written.\n\n    A gain of zero does not always mean flat, and this could not tell the difference. A range\n    of -1e-320 to 1e-320 is not flat — it is 65,536 distinct physical values — but the gain\n    is 2e-320/65535, which is smaller than the smallest subnormal double and underflows to\n    +0. Every distinct sample then took `physicalMin`, so eight codes spanning -16,000 to\n    +12,000 came out as one repeated number, with no diagnostic anywhere and `--strict`\n    exiting 0. At 1e-319, one power of ten away, the same file raises VALUE_RESOLUTION.\n\n    That is the same situation as the overflow below it, which this codebase already reasoned\n    about and answered: the span cannot be represented, so there is no mapping, so the cells\n    are left empty rather than filled with a value the header cannot justify. Underflow only\n    got the flat-range treatment because `gain === 0` is what both look like from here.\n  */\n  if (gain === 0) return physicalMax === physicalMin ? (): number => physicalMin : (): number => NaN;\n\n  // A non-finite gain is a different thing: the physical span overflowed a double, so\n  // there is no mapping at all. Returning physicalMin filled the column with one enormous\n  // constant — every distinct sample rendered as the same 300-digit number — and raised\n  // nothing. NaN takes the same route as a degenerate digital range: empty cells, plus\n  // UNUSABLE_PHYSICAL_RANGE from the header parser.\n  if (!Number.isFinite(gain)) return () => NaN;\n\n  // Deriving the offset divides by the gain. For every realistic calibration that is\n  // both safe and more accurate, but an absurd header (a huge physical range over a\n  // near-zero gain) could overflow it, so fall back to the specification's own\n  // arrangement rather than emitting Infinity.\n  const offset = physicalMax / gain - digitalMax;\n  if (!Number.isFinite(offset)) {\n    return (digital: number): number => (digital - digitalMin) * gain + physicalMin;\n  }\n\n  return (digital: number): number => gain * (offset + digital);\n}\n\n/**\n * Smallest physical step this channel can express — one digital unit.\n * Used to choose a decimal precision that preserves every distinct sample value.\n */\nexport function quantizationStep(signal: EdfSignal): number {\n  // See `assertCalibration`: without it `quantizationStep({})` answered 0, which is the step\n  // of a channel whose header contradicts itself.\n  assertCalibration(signal);\n  const digitalSpan = signal.digitalMax - signal.digitalMin;\n  if (digitalSpan === 0) return 0;\n  return Math.abs((signal.physicalMax - signal.physicalMin) / digitalSpan);\n}\n\n/**\n * The most `toFixed` accepts. 101 is a RangeError, so this is the ceiling, not a taste.\n *\n * It used to be 20, on the stated grounds that 20 was what `toFixed` allowed. It is not,\n * and the gap was not academic: a magnetometer channel spanning ±1e-16 T over a 16-bit\n * converter has a step of 3.05e-21 and needs 23 places. Clamped to 20, every value landed\n * on a 1e-20 grid — about three digital codes to a printed value — so 69% of the samples\n * could not be recovered, the conversion exited 0, and nothing said a word. The channel\n * type the old comment named as the reason for the ceiling was the one it broke.\n */\nconst MAX_DERIVED_DECIMALS = 100;\n\n/**\n * Places this channel needs before any ceiling, or null when it has no step to derive one from.\n *\n * One expression, because two functions depend on agreeing about it. `decimalsForSignal`\n * computed `Math.ceil(-Math.log10(step)) + 2` and clamped it; `decimalsAreClamped` computed the\n * same thing again and compared it to the same ceiling. Two copies of one formula whose only\n * job is to give the same answer — change either `+ 2` and they part company at the boundary,\n * so a channel whose precision really was capped is reported as not capped, VALUE_RESOLUTION is\n * not raised, and its codes print indistinguishable in silence. Which is the exact thing that\n * warning exists to say.\n */\nfunction decimalsNeeded(signal: EdfSignal): number | null {\n  const step = quantizationStep(signal);\n  if (!(step > 0) || !Number.isFinite(step)) return null;\n  return Math.ceil(-Math.log10(step)) + 2;\n}\n\n/**\n * Decimal places needed so that two adjacent digital codes never round to the same\n * string. Two places past the quantization step keep rounding error far below the\n * resolution the hardware actually recorded, without padding the file with digits\n * that carry no information.\n *\n * Ordinary channels land at three or four: a ±800 µV channel over 12 bits steps by\n * 0.39 µV and needs three. The ceiling is only reached by calibrations whose step is\n * below 1e-98, which an 8-character physical bound can still express — `1e-99` is five\n * characters. Those get VALUE_RESOLUTION rather than silence.\n */\nexport function decimalsForSignal(signal: EdfSignal, max = MAX_DERIVED_DECIMALS): number {\n  /*\n    The ceiling, which is the caller's to choose and was the caller's to get wrong.\n\n    0.8.76 checked the channel. The second argument went on being whatever was passed, and\n    `Math.min` carries it straight out:\n\n        decimalsForSignal(signal, -5)    // -5\n        decimalsForSignal(signal, 2.5)   // 2.5\n        decimalsForSignal(signal, 'x')   // NaN\n\n    A negative number of decimal places, a fractional one, and not a number — from the\n    function whose whole answer is how many places a column needs. Each is a `RangeError` out\n    of `toFixed` at the point the caller uses it, one call later and somewhere else.\n\n    A whole number of places, and not bounded above: handing this a ceiling nothing can reach\n    is how a caller asks what a channel would need without one, which is how\n    `decimalsAreClamped` is checked against this function rather than against its own copy of\n    the formula.\n  */\n  if (!Number.isInteger(max) || max < 0) {\n    throw new OptionError(\n      `max must be a whole number of decimal places, zero or more, got ${describeValue(max)}. ` +\n        `It is a ceiling on the precision this derives; the default is ` +\n        `${MAX_DERIVED_DECIMALS}, which is what toFixed accepts.`,\n    );\n  }\n  const needed = decimalsNeeded(signal);\n  // The ceiling applies to the fallback too. A channel with no step to derive from takes the\n  // ordinary three places, and `decimalsForSignal(signal, 0)` returned them — a ceiling of\n  // zero answered with three, on the one branch that does not measure anything.\n  if (needed === null) return Math.min(max, 3);\n  return Math.min(max, Math.max(0, needed));\n}\n\n/**\n * Whether this channel's step is finer than any precision the tool can print.\n *\n * Asked of the ceiling, not of the precision in use. `--decimals 2` on a channel needing 3\n * is a trade the caller made knowingly and is not this warning's business — 0.5.10 fixed a\n * version of this that fired on every ordinary EEG at `--decimals 2` and made\n * `--decimals 2 --strict` impossible. But it fixed it by asking \"did the caller choose the\n * precision\", which suppressed the real case too: at `--decimals 20` a channel stepping by\n * 1e-106 printed every one of its codes as `0.00000000000000000000`, in silence.\n *\n * The question is whether anything the tool can print would separate consecutive codes. When\n * the answer is no, that is a ceiling nobody chose, and it holds whatever `--decimals` says.\n */\nexport function decimalsAreClamped(signal: EdfSignal): boolean {\n  const needed = decimalsNeeded(signal);\n  return needed !== null && needed > MAX_DERIVED_DECIMALS;\n}\n"]}
+{"version":3,"file":"scale.js","sourceRoot":"","sources":["../../src/edf/scale.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Digital-to-physical conversion.\n *\n * EDF defines the mapping by two calibration points, (digitalMin -> physicalMin)\n * and (digitalMax -> physicalMax), which the specification writes as:\n *\n *   gain     = (physicalMax - physicalMin) / (digitalMax - digitalMin)\n *   physical = (digital - digitalMin) * gain + physicalMin\n *\n * That form is evaluated here in EDFlib's algebraically equivalent arrangement:\n *\n *   offset   = physicalMax / gain - digitalMax\n *   physical = gain * (offset + digital)\n *\n * The rearrangement is not cosmetic. Written the first way, a channel spanning\n * +/-800 uV computes a value near 800 and then subtracts 800, and the cancellation\n * throws away low-order bits: digital 0 yields 0.19536019536019467 when the exact\n * value is 0.19536019536019536. EDFlib's form keeps the intermediate small\n * (offset + digital = 0.5 here) and returns the correctly rounded result.\n *\n * Both properties matter. The values are as accurate as a double can express, and\n * they are bit-identical to pyEDFlib and EDFbrowser, which share EDFlib's arithmetic,\n * so the test suite can assert exact equality against a reference implementation\n * rather than settling for a tolerance.\n */\n\nimport type { EdfSignal } from './header.js';\nimport { OptionError, describeValue } from '../convert/options.js';\n\nexport type Scaler = (digital: number) => number;\n\n/** The four header fields this reads, in the order a message should name them. */\nconst CALIBRATION = ['digitalMin', 'digitalMax', 'physicalMin', 'physicalMax'] as const;\n\n/**\n * The four calibration numbers, confirmed to be on the thing that was passed.\n *\n * Written for `makeScaler` in 0.8.61 and shared since 0.8.76, when the two functions beside\n * it turned out to read the same four fields off the same argument and ask nothing of it.\n * Both answer rather than refuse:\n *\n *     quantizationStep({})     // 0     — the step of a channel whose header contradicts itself\n *     decimalsForSignal(42)    // 3     — the precision an ordinary EEG channel gets\n *\n * `undefined - undefined` is `NaN`, `NaN === 0` is false, and the division that follows gives\n * `NaN`; `quantizationStep` returns it as a step, and `decimalsForSignal` reads a step that is\n * not a positive number as \"this channel has none to derive from\" and falls back to three\n * places. Both of those are real answers for real channels — a zero digital span is what\n * `DEGENERATE_DIGITAL_RANGE` reports, and three places is what most EEG gets — so a caller\n * holding the wrong object gets a number they have no way to doubt.\n */\nfunction assertCalibration(signal: EdfSignal): void {\n  if (typeof signal !== 'object' || signal === null) {\n    throw new OptionError(`signal must be a channel from a header, got ${describeValue(signal)}.`);\n  }\n  const missing = CALIBRATION.find((name) => typeof signal[name] !== 'number');\n  if (missing !== undefined) {\n    throw new OptionError(\n      `signal.${missing} must be a number, got ${describeValue(signal[missing])}.`,\n    );\n  }\n}\n\n/**\n * The one argument a scaler takes, confirmed to be a number before it is added to one.\n *\n * The arithmetic below is `gain * (offset + digital)`, and `+` on a string concatenates. A\n * sample that arrived as text — from `JSON.parse` of a stored record, a CSV read back, a form\n * field, every door `assertOptions` names for the options — was pasted onto the offset instead\n * of added to it:\n *\n *     const scale = makeScaler(signal);   // ±250 uV over a 12-bit range\n *     scale(42)      // 5.1892551892551895\n *     scale('42')    // 0.06617826617826618   offset 0.5, so 0.5 + '42' is '0.542'\n *     scale(null)    // the value for digital 0\n *     scale(true)    // the value for digital 1\n *\n * Every one of them is a physical value this channel could really have recorded: in range, in\n * the right unit, printed to the right precision, and wrong by a factor of seventy-eight. This\n * is the function the api page recommends for reading physical units out of a file, and \"never\n * invent a number\" is the promise the whole tool is built on.\n *\n * The two branches did not even agree about it. The fallback arrangement below is\n * `(digital - digitalMin) * gain + physicalMin`, and `-` coerces where `+` concatenates, so\n * `'42'` came back correct there and wrong here — one function, two answers, decided by\n * whether the header's offset overflowed.\n *\n * Only the two closures that read the argument ask this. The three that return a constant —\n * a degenerate digital range, a flat physical one — give the same answer for every sample of\n * such a channel, which is the right answer whatever they are handed.\n */\nfunction assertDigital(digital: number): void {\n  if (typeof digital !== 'number') {\n    throw new OptionError(\n      `A scaler takes one digital sample, got ${describeValue(digital)}. It is the raw integer ` +\n        `out of the record — what EdfFile.sampleAt returns — not its text.`,\n    );\n  }\n}\n\nexport function makeScaler(signal: EdfSignal): Scaler {\n  /*\n    The argument, checked like the arguments of the other exported functions.\n\n    Every branch below reads four numbers off `signal`, and the first of them — the one that\n    catches a header contradicting itself — is `digitalMax === digitalMin`. On an object that\n    has neither, that comparison is `undefined === undefined`, which is true. So\n    `makeScaler({})` came back as a working function returning NaN for every sample, which is\n    exactly what a real channel with a zero digital span returns.\n\n    A caller cannot tell the two apart. The api page recommends this function for reading\n    physical units out of a file, and the empty column it produces is documented as meaning\n    \"the header contradicts itself\" — a sentence about the recording, over a call that passed\n    the wrong object. The diagnostic that normally accompanies it, DEGENERATE_DIGITAL_RANGE,\n    comes from the header parser and is not raised here at all.\n  */\n  assertCalibration(signal);\n  const { digitalMin, digitalMax, physicalMin, physicalMax } = signal;\n\n  // A zero digital span leaves the mapping undefined — the header contradicts itself,\n  // so there is no physical value for any sample on this channel.\n  //\n  // NaN rather than a stand-in number. Writing the physical minimum produces a column\n  // of plausible readings (\"-100.000\" repeated) that is indistinguishable from a real\n  // flat recording once the CSV is opened somewhere else, which is exactly the kind of\n  // invented data this tool exists to avoid. NaN carries through to an empty CSV cell\n  // and reads back as NaN in pandas, matching how a missing annotation duration is\n  // already written. DEGENERATE_DIGITAL_RANGE is raised alongside it.\n  if (digitalMax === digitalMin) return () => NaN;\n\n  const gain = (physicalMax - physicalMin) / (digitalMax - digitalMin);\n\n  /*\n    A flat physical range makes every sample the same value, and would divide by zero in the\n    offset below. That mapping is defined, so its constant is written.\n\n    A gain of zero does not always mean flat, and this could not tell the difference. A range\n    of -1e-320 to 1e-320 is not flat — it is 65,536 distinct physical values — but the gain\n    is 2e-320/65535, which is smaller than the smallest subnormal double and underflows to\n    +0. Every distinct sample then took `physicalMin`, so eight codes spanning -16,000 to\n    +12,000 came out as one repeated number, with no diagnostic anywhere and `--strict`\n    exiting 0. At 1e-319, one power of ten away, the same file raises VALUE_RESOLUTION.\n\n    That is the same situation as the overflow below it, which this codebase already reasoned\n    about and answered: the span cannot be represented, so there is no mapping, so the cells\n    are left empty rather than filled with a value the header cannot justify. Underflow only\n    got the flat-range treatment because `gain === 0` is what both look like from here.\n  */\n  if (gain === 0) return physicalMax === physicalMin ? (): number => physicalMin : (): number => NaN;\n\n  // A non-finite gain is a different thing: the physical span overflowed a double, so\n  // there is no mapping at all. Returning physicalMin filled the column with one enormous\n  // constant — every distinct sample rendered as the same 300-digit number — and raised\n  // nothing. NaN takes the same route as a degenerate digital range: empty cells, plus\n  // UNUSABLE_PHYSICAL_RANGE from the header parser.\n  if (!Number.isFinite(gain)) return () => NaN;\n\n  // Deriving the offset divides by the gain. For every realistic calibration that is\n  // both safe and more accurate, but an absurd header (a huge physical range over a\n  // near-zero gain) could overflow it, so fall back to the specification's own\n  // arrangement rather than emitting Infinity.\n  const offset = physicalMax / gain - digitalMax;\n  if (!Number.isFinite(offset)) {\n    return (digital: number): number => {\n      assertDigital(digital);\n      return (digital - digitalMin) * gain + physicalMin;\n    };\n  }\n\n  return (digital: number): number => {\n    assertDigital(digital);\n    return gain * (offset + digital);\n  };\n}\n\n/**\n * Smallest physical step this channel can express — one digital unit.\n * Used to choose a decimal precision that preserves every distinct sample value.\n */\nexport function quantizationStep(signal: EdfSignal): number {\n  // See `assertCalibration`: without it `quantizationStep({})` answered 0, which is the step\n  // of a channel whose header contradicts itself.\n  assertCalibration(signal);\n  const digitalSpan = signal.digitalMax - signal.digitalMin;\n  if (digitalSpan === 0) return 0;\n  return Math.abs((signal.physicalMax - signal.physicalMin) / digitalSpan);\n}\n\n/**\n * The most `toFixed` accepts. 101 is a RangeError, so this is the ceiling, not a taste.\n *\n * It used to be 20, on the stated grounds that 20 was what `toFixed` allowed. It is not,\n * and the gap was not academic: a magnetometer channel spanning ±1e-16 T over a 16-bit\n * converter has a step of 3.05e-21 and needs 23 places. Clamped to 20, every value landed\n * on a 1e-20 grid — about three digital codes to a printed value — so 69% of the samples\n * could not be recovered, the conversion exited 0, and nothing said a word. The channel\n * type the old comment named as the reason for the ceiling was the one it broke.\n */\nconst MAX_DERIVED_DECIMALS = 100;\n\n/**\n * Places this channel needs before any ceiling, or null when it has no step to derive one from.\n *\n * One expression, because two functions depend on agreeing about it. `decimalsForSignal`\n * computed `Math.ceil(-Math.log10(step)) + 2` and clamped it; `decimalsAreClamped` computed the\n * same thing again and compared it to the same ceiling. Two copies of one formula whose only\n * job is to give the same answer — change either `+ 2` and they part company at the boundary,\n * so a channel whose precision really was capped is reported as not capped, VALUE_RESOLUTION is\n * not raised, and its codes print indistinguishable in silence. Which is the exact thing that\n * warning exists to say.\n */\nfunction decimalsNeeded(signal: EdfSignal): number | null {\n  const step = quantizationStep(signal);\n  if (!(step > 0) || !Number.isFinite(step)) return null;\n  return Math.ceil(-Math.log10(step)) + 2;\n}\n\n/**\n * Decimal places needed so that two adjacent digital codes never round to the same\n * string. Two places past the quantization step keep rounding error far below the\n * resolution the hardware actually recorded, without padding the file with digits\n * that carry no information.\n *\n * Ordinary channels land at three or four: a ±800 µV channel over 12 bits steps by\n * 0.39 µV and needs three. The ceiling is only reached by calibrations whose step is\n * below 1e-98, which an 8-character physical bound can still express — `1e-99` is five\n * characters. Those get VALUE_RESOLUTION rather than silence.\n */\nexport function decimalsForSignal(signal: EdfSignal, max = MAX_DERIVED_DECIMALS): number {\n  /*\n    The ceiling, which is the caller's to choose and was the caller's to get wrong.\n\n    0.8.76 checked the channel. The second argument went on being whatever was passed, and\n    `Math.min` carries it straight out:\n\n        decimalsForSignal(signal, -5)    // -5\n        decimalsForSignal(signal, 2.5)   // 2.5\n        decimalsForSignal(signal, 'x')   // NaN\n\n    A negative number of decimal places, a fractional one, and not a number — from the\n    function whose whole answer is how many places a column needs. Each is a `RangeError` out\n    of `toFixed` at the point the caller uses it, one call later and somewhere else.\n\n    A whole number of places, and not bounded above: handing this a ceiling nothing can reach\n    is how a caller asks what a channel would need without one, which is how\n    `decimalsAreClamped` is checked against this function rather than against its own copy of\n    the formula.\n  */\n  if (!Number.isInteger(max) || max < 0) {\n    throw new OptionError(\n      `max must be a whole number of decimal places, zero or more, got ${describeValue(max)}. ` +\n        `It is a ceiling on the precision this derives; the default is ` +\n        `${MAX_DERIVED_DECIMALS}, which is what toFixed accepts.`,\n    );\n  }\n  const needed = decimalsNeeded(signal);\n  // The ceiling applies to the fallback too. A channel with no step to derive from takes the\n  // ordinary three places, and `decimalsForSignal(signal, 0)` returned them — a ceiling of\n  // zero answered with three, on the one branch that does not measure anything.\n  if (needed === null) return Math.min(max, 3);\n  return Math.min(max, Math.max(0, needed));\n}\n\n/**\n * Whether this channel's step is finer than any precision the tool can print.\n *\n * Asked of the ceiling, not of the precision in use. `--decimals 2` on a channel needing 3\n * is a trade the caller made knowingly and is not this warning's business — 0.5.10 fixed a\n * version of this that fired on every ordinary EEG at `--decimals 2` and made\n * `--decimals 2 --strict` impossible. But it fixed it by asking \"did the caller choose the\n * precision\", which suppressed the real case too: at `--decimals 20` a channel stepping by\n * 1e-106 printed every one of its codes as `0.00000000000000000000`, in silence.\n *\n * The question is whether anything the tool can print would separate consecutive codes. When\n * the answer is no, that is a ceiling nobody chose, and it holds whatever `--decimals` says.\n */\nexport function decimalsAreClamped(signal: EdfSignal): boolean {\n  const needed = decimalsNeeded(signal);\n  return needed !== null && needed > MAX_DERIVED_DECIMALS;\n}\n"]}

package/dist/format/number.d.ts

@@ -67,6 +67,7 @@ export declare function timeDecimals(samplingRate: number): number;
 export declare function formatBytes(bytes: number): string;
 /** Human-readable duration: 1h 05m 12s. */
 export declare function formatDuration(seconds: number): string;
+export declare function plainSeconds(seconds: number): string;
 /**
  * How many cached offsets a conversion has left to spend.
  *

package/dist/format/number.js

@@ -259,7 +259,7 @@ export function formatDuration(seconds) {
       say what `--start` may be given — and `--start 1e-15s` is refused as an unknown unit "e".
     */
     if (total === 0 && seconds > 0)
-        return `${plain(seconds)}s`;
+        return `${plainSeconds(seconds)}s`;
     const h = Math.floor(total / 3600);
     const m = Math.floor((total % 3600) / 60);
     const s = Math.round((total - h * 3600 - m * 60) * 1000) / 1000;
@@ -270,6 +270,39 @@ export function formatDuration(seconds) {
         return `${m}m ${sText}s`;
     return `${sText}s`;
 }
+/**
+ * A length of time in a form the sentence it sits in can hold.
+ *
+ * `plain` expands a double to its full decimal form, which is what the columns of
+ * annotations.csv need — one notation down a column, so a `merge` on it matches. Every message
+ * that states a length of seconds took the same rendering, and a record duration is eight
+ * characters of header, so `1e308` and `1e-320` both fit in one:
+ *
+ *     Duration   unknown  (2 records of 1000000000000000000000 ... 000s)
+ *
+ * Three hundred and nine digits, on a line whose other half has just said the total cannot be
+ * stated — and three lines under a RATE column rendering the same magnitude as `4.000e-308 Hz`,
+ * because `formatRate` already falls back to exponent form when plain decimal stops carrying
+ * the number. This is the failure `listed` was written for, one line over: a message is not
+ * the place for everything a header is free to ask for.
+ *
+ * Plain while plain is *typable*, which is the reason the expansion is here at all —
+ * `--start 1e-15s` is refused as an unknown unit `e`, so `repeating-fast.edf` reads
+ * `0.000000000000001s` and can be acted on. Past the width of a line nothing is typable
+ * either way: a reader cannot count three hundred digits any more than they can pass an
+ * exponent, so the shortest exact form is the more honest of the two.
+ *
+ * Here rather than in cli/report.ts, where 0.8.95 wrote it for one half of one line. The
+ * other half of that same line expanded a duration of 3e-308 to three hundred and ten
+ * characters; so did the refusal naming a record duration that is not positive, and the hint
+ * that says how wide a window has to be to hold a sample. All four state a length of seconds
+ * out of a header, and the rule is one rule.
+ */
+const LONGEST_PLAIN_SECONDS = 30;
+export function plainSeconds(seconds) {
+    const expanded = plain(seconds);
+    return expanded.length <= LONGEST_PLAIN_SECONDS ? expanded : String(seconds);
+}
 /** A record can declare a great many samples; two arrays this size is the cost of caching. */
 const MAX_CACHED_OFFSETS = 1 << 20;
 export function newOffsetBudget() {

package/dist/format/number.js.map

@@ -1 +1 @@
-{"version":3,"file":"number.js","sourceRoot":"","sources":["../../src/format/number.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Number formatting for CSV cells.\n *\n * A one-hour, 23-channel, 256 Hz recording is about 21 million numeric cells, so\n * this is the hottest code in a conversion. Two things keep it cheap:\n *\n *  - Every sample in a channel comes from a bounded set of integers (digitalMin to\n *    digitalMax, typically 4096 distinct values for a 12-bit ADC). The formatted\n *    text for a digital code never changes, so it is computed once and reused.\n *  - The cache fills lazily. Real recordings visit only a fraction of the range,\n *    and a channel with an implausibly wide range falls back to direct formatting\n *    rather than reserving memory it will never use.\n */\n\nimport type { EdfSignal } from '../edf/header.js';\nimport { makeScaler } from '../edf/scale.js';\n\n/** Widest digital range worth caching: 16 bits of pointers is 512 KB per channel. */\nconst MAX_CACHED_SPAN = 1 << 16;\n\n/**\n * How many cached sample slots a conversion has left to spend.\n *\n * MAX_CACHED_SPAN is a bound on one channel, and a bound on one channel is not a bound: a\n * file may declare as many channels as it likes, and each was handed its own cache. A\n * channel declaring the ordinary full 16-bit digital range takes the whole 512 KB, so a\n * 256-channel montage reserved 134 MB of pointers before writing a row — a 7.9 MB\n * recording that needed a 192 MB heap and died with a V8 out-of-memory fatal error under\n * anything smaller. The caches were the live set; nothing else in the conversion came near\n * them. It is the same shape of mistake the offset budget below was made to fix, one level\n * over: there the unbounded count was rate groups, here it is channels.\n *\n * One budget for the whole conversion leaves the ordinary recording exactly as it was and\n * puts a ceiling on the dense montage: the same 256-channel file now holds its caches to\n * 16 MB and converts under a 48 MB heap. Channels ask in the order the groups are written,\n * which is fastest rate first, so the cache goes to the channels with the most cells to\n * format. The ones that miss out fall back to formatting directly, which produces\n * identical text — the output is byte-for-byte what it was.\n */\nexport interface SampleCacheBudget {\n  remaining: number;\n}\n\n/**\n * Slots for the whole conversion: 16 MB of pointers if every one is claimed.\n *\n * Enough that a full 32-channel montage declaring the whole 16-bit range keeps every cache\n * it had before, and 512 channels of an ordinary 12-bit ADC do too. Past that the extra\n * channels format directly, which costs about a quarter of the conversion's time on a\n * recording where almost none of them are cached — against a file that did not convert at\n * all under a 128 MB heap.\n */\nconst MAX_CACHED_SAMPLES = 1 << 21;\n\nexport function newSampleCacheBudget(): SampleCacheBudget {\n  return { remaining: MAX_CACHED_SAMPLES };\n}\n\n/**\n * Format with a fixed number of decimals, normalising negative zero.\n *\n * Without this, a sample that scales to a very small negative value prints as\n * \"-0.000\", which looks like a distinct measurement but is not.\n */\nexport function fixed(value: number, decimals: number): string {\n  // An undefined value becomes an empty cell rather than the text \"NaN\" or \"Infinity\".\n  // A channel whose header leaves the digital-to-physical mapping undefined scales to\n  // NaN, and an empty field is the CSV convention for \"no value here\" — the same one\n  // annotations.csv uses for an absent duration. Readers parse it back as NaN / NA\n  // rather than as a measurement.\n  if (!Number.isFinite(value)) return '';\n\n  // toFixed switches to exponent notation at 1e21, which would put \"1e+21\" in a column\n  // whose every other cell is plain fixed-decimal — and a reader parsing the column as\n  // decimal text has no reason to expect it. Reachable because EDF's 8-character physical\n  // range fields accept exponent form, so a header may legitimately say \"1e30\".\n  //\n  // Above 2^53 a double carries no fractional part anyway, so the integer expansion is\n  // exact rather than an approximation of one.\n  if (Math.abs(value) >= 1e21) {\n    const whole = BigInt(Math.trunc(value)).toString();\n    return decimals > 0 ? `${whole}.${'0'.repeat(decimals)}` : whole;\n  }\n\n  const text = value.toFixed(decimals);\n  if (text.charCodeAt(0) !== 45 /* - */) return text;\n  // Cheap check for \"-0\", \"-0.0\", \"-0.000\"...\n  for (let i = 1; i < text.length; i++) {\n    const c = text.charCodeAt(i);\n    if (c === 46 /* . */ || c === 48 /* 0 */) continue;\n    return text;\n  }\n  return text.slice(1);\n}\n\n/**\n * A number as plain decimal text, at any magnitude.\n *\n * `String()` switches to exponent notation twice — above 1e21 and below 1e-6 — and\n * annotations.csv wrote its `onset_s` and `duration_s` through it. An EDF+ TAL states its\n * onset as ordinary decimal text, so a file saying `+0.0000001` came back as `1e-7` in a\n * column whose every other cell is a plain decimal, beside a `time_s` the documentation says\n * it \"joins directly\" with. It does not: pandas reads the column as object rather than\n * float64 once one cell is exponent text, and a `merge` on it matches nothing.\n *\n * `fixed` cannot answer this. It needs a decimal count, and these two columns are documented\n * as carrying \"their natural numeric form ... without padding to a fixed decimal count\" —\n * asking for enough places to hold 1e-7 would rewrite `0.1` as `0.10000000000000000555`.\n * Expanding the notation instead touches only the values that are in it and leaves every\n * other cell byte-for-byte what it was.\n */\nexport function plain(value: number): string {\n  const text = String(value);\n  const e = text.indexOf('e');\n  if (e === -1) return text;\n  const negative = text.charCodeAt(0) === 45 /* - */;\n  const mantissa = text.slice(negative ? 1 : 0, e);\n  const dot = mantissa.indexOf('.');\n  // Where the point sits once the exponent is spent, counted in significant digits.\n  const point = (dot === -1 ? mantissa.length : dot) + Number(text.slice(e + 1));\n  const digits = dot === -1 ? mantissa : mantissa.slice(0, dot) + mantissa.slice(dot + 1);\n  const sign = negative ? '-' : '';\n  if (point <= 0) return `${sign}0.${'0'.repeat(-point)}${digits}`;\n  if (point >= digits.length) return `${sign}${digits}${'0'.repeat(point - digits.length)}`;\n  return `${sign}${digits.slice(0, point)}.${digits.slice(point)}`;\n}\n\n/** Maps a raw digital sample to its formatted physical value. */\nexport type SampleFormatter = (digital: number) => string;\n\nexport function makeSampleFormatter(\n  signal: EdfSignal,\n  decimals: number,\n  budget: SampleCacheBudget = newSampleCacheBudget(),\n): SampleFormatter {\n  const scale = makeScaler(signal);\n  const low = Math.min(signal.digitalMin, signal.digitalMax);\n  const high = Math.max(signal.digitalMin, signal.digitalMax);\n  const span = high - low + 1;\n\n  if (\n    !Number.isFinite(span) ||\n    span <= 0 ||\n    span > MAX_CACHED_SPAN ||\n    span > budget.remaining\n  ) {\n    return (digital: number): string => fixed(scale(digital), decimals);\n  }\n  budget.remaining -= span;\n\n  /*\n    The cache covers the channel's declared digital range, not the whole int16 domain.\n\n    Allocating 65536 slots regardless of span cost 512 KB of pointers per channel, which a\n    dense montage cannot afford: a 400-channel recording needed over 200 MB of cache alone\n    and died with a V8 out-of-memory fatal error before writing a row. Sizing to the\n    declared span makes the ordinary 12-bit channel 32 KB instead — the same 400 channels\n    now fit in about 13 MB. Channels that declare the full range still take the whole 512 KB,\n    which is what the budget above is for.\n\n    Samples outside the declared range still occur in non-conforming files. They simply\n    miss the cache and are formatted directly, which produces identical text.\n  */\n  const cache = new Array<string | undefined>(span);\n  return (digital: number): string => {\n    const slot = digital - low;\n    if (slot >= 0 && slot < span) {\n      const hit = cache[slot];\n      if (hit !== undefined) return hit;\n      const text = fixed(scale(digital), decimals);\n      cache[slot] = text;\n      return text;\n    }\n    return fixed(scale(digital), decimals);\n  };\n}\n\n/**\n * Decimals for the time column.\n *\n * The interval between samples is 1/rate, which has a terminating decimal expansion of d\n * places exactly when 10^d divides evenly by the rate. Writing that many places makes sample\n * times exact rather than rounded, so `time_s * rate` comes back as a whole number instead\n * of 8191.999999.\n *\n * The search used to stop at nine places, and the comment here claimed \"every rate in common\n * use clears this — 256 Hz needs 8 places, 512 Hz needs 9\". The next two powers of two do\n * not: 1/1024 needs ten places and 1/2048 needs eleven, and those are the rates a BioSemi\n * ActiveTwo records at by default. Both fell through to the rounding fallback, so the two\n * most common high-rate EEG recordings got exactly the behaviour this function exists to\n * avoid — 0.0009766 for an interval of 0.0009765625.\n *\n * A rate of 2^a * 5^b terminates in max(a, b) places, so fifteen covers every power of two up\n * to 32768 Hz, far past anything that records biosignals. Rates with a repeating expansion\n * (3 Hz, say) still fall back to enough places to keep consecutive samples distinct, and that\n * fallback keeps its own cap.\n *\n * Fifteen and not more, because the test below has to stay exact: 10^16 is past 2^53, where a\n * double can no longer hold every integer, and `Number.isInteger(10 ** 17 / 3)` is true — so a\n * larger bound reports a terminating expansion for rates that have none, and 3 Hz would ask\n * for seventeen decimals of a number that repeats forever.\n *\n * The fallback is bounded by the same fifteen. It used to stop at nine, which defeated the\n * one thing it exists to do: at 3e10 Hz — non-terminating, so no exact expansion to find —\n * the interval is 3.3e-11 and nine places rounded every sample in a record to the same\n * timestamp. A column that cannot tell two samples apart is not keeping them distinct, which\n * is what this branch is for.\n */\nconst MAX_TIME_DECIMALS = 15;\n\nexport function timeDecimals(samplingRate: number): number {\n  if (!(samplingRate > 0) || !Number.isFinite(samplingRate)) return 3;\n  for (let d = 0; d <= MAX_TIME_DECIMALS; d++) {\n    if (Number.isInteger(10 ** d / samplingRate)) return Math.max(3, d);\n  }\n  return Math.min(MAX_TIME_DECIMALS, Math.max(3, Math.ceil(Math.log10(samplingRate)) + 3));\n}\n\n/** Human-readable byte size for warnings and summaries. */\nexport function formatBytes(bytes: number): string {\n  const units = ['B', 'KB', 'MB', 'GB', 'TB'];\n  let value = bytes;\n  let unit = 0;\n  while (value >= 1024 && unit < units.length - 1) {\n    value /= 1024;\n    unit++;\n  }\n  let rounded = value >= 100 || unit === 0 ? Math.round(value) : Number(value.toFixed(1));\n  // Rounding can carry into the next unit, and the unit was chosen before it: 1,048,575 bytes\n  // is 1023.999 KB, which printed as \"1024 KB\". The same slip formatDuration below fixed by\n  // rounding before splitting, one function up.\n  if (rounded === 1024 && unit < units.length - 1) {\n    unit++;\n    rounded = 1;\n  }\n  return `${rounded} ${units[unit]}`;\n}\n\n/** Human-readable duration: 1h 05m 12s. */\nexport function formatDuration(seconds: number): string {\n  // A duration that is not a number cannot be broken into hours and minutes, and saying so\n  // beats the alternative: the fallback below rendered these as \"NaNs\" and \"Infinitys\".\n  if (!Number.isFinite(seconds)) return 'unknown';\n\n  /*\n    Past 2^53 the decomposition stops being arithmetic and starts being noise.\n\n    `total - h * 3600 - m * 60` cannot be exact once `total` exceeds what a double can hold\n    as a whole number, and the error lands in the seconds field, where it shows up as a\n    value that cannot exist. A header declaring a record duration of 1e300 printed:\n\n        Duration   8.333333333333333e+296h 48m -2880s\n\n    Forty-eight minutes and minus forty-eight seconds, under an hours field in exponent\n    notation. The seconds are the honest form for a figure this size — nobody reads\n    285 million years as hours — and the record count and duration are printed beside it\n    anyway, so a corrupt header stays just as visible.\n\n    Written through `fixed` rather than by interpolation, which is the same 1e21 cliff again:\n    `${seconds}` switches to exponent notation exactly where `toFixed` does, so the fallback\n    put a token back that this tool's own parser refuses. `--start 4000000000000000000000` on\n    a recording of three 1e21-second records was answered with\n\n        --start \"4000000000000000000000\" is at or past the end of this 3e+21s recording.\n\n    a sentence whose whole job is to say what window there is to ask for, ending in a length\n    `--start` and `--duration` reject with \"uses an unknown unit \\\"e\\\"\". `formatSeconds` in\n    time-range.ts was fixed for this in the other half of that same message, and its comment\n    quotes this half as part of what was wrong. `fixed` expands these with BigInt, which is\n    exact past 2^53 where a double carries no fraction anyway.\n  */\n  if (seconds < 0 || seconds >= Number.MAX_SAFE_INTEGER) return `${fixed(seconds, 0)}s`;\n\n  // Round to the precision that will actually be printed BEFORE splitting into units.\n  // Splitting first left the remainder to be rounded on its own, so 3599.9996 s decomposed\n  // as 59 minutes and 59.9996 seconds and then printed as \"59m 60s\" — a duration that\n  // cannot exist. Rounding first carries the extra second into the minute where it belongs.\n  const total = Math.round(seconds * 1000) / 1000;\n  /*\n    A duration shorter than the rounding is not a duration of zero.\n\n    Three decimals is the right precision for a recording measured in hours, and it collapses\n    everything under half a millisecond to \"0s\". `repeating-fast.edf` — two records of 1e-15s,\n    six samples, one of this repository's own fixtures — printed\n\n        Duration   0s  (2 records of 1e-15s)\n\n    and refused `--start 0.5` with \"is at or past the end of this 0s recording\". A reader is\n    told the file holds nothing, on the line they look at first, about a file that converts to\n    six rows; the record duration two columns over already contradicts it. Same shape as the\n    other end of this function, which stops decomposing past 2^53 and prints the seconds\n    instead, and as the byte size above, which carries 1023.999 KB up rather than printing the\n    \"1024 KB\" no unit has. None of the three is a rounding rule; each one refuses to print a\n    form the quantity cannot take.\n\n    Written through `plain` rather than interpolated, for the reason the comment above gives:\n    `${1e-15}` is exponent notation, and the sentence this feeds is one whose whole job is to\n    say what `--start` may be given — and `--start 1e-15s` is refused as an unknown unit \"e\".\n  */\n  if (total === 0 && seconds > 0) return `${plain(seconds)}s`;\n  const h = Math.floor(total / 3600);\n  const m = Math.floor((total % 3600) / 60);\n  const s = Math.round((total - h * 3600 - m * 60) * 1000) / 1000;\n  const sText = Number.isInteger(s) ? String(s) : s.toFixed(3).replace(/\\.?0+$/u, '');\n  if (h > 0) return `${h}h ${String(m).padStart(2, '0')}m ${sText}s`;\n  if (m > 0) return `${m}m ${sText}s`;\n  return `${sText}s`;\n}\n\n/** A record can declare a great many samples; two arrays this size is the cost of caching. */\nconst MAX_CACHED_OFFSETS = 1 << 20;\n\n/**\n * How many cached offsets a conversion has left to spend.\n *\n * The cap used to be per rate group, and a file may hold as many rate groups as it has\n * channels. Twelve channels at twelve rates just under the cap — a 25 MB file — took\n * 1.66 GB and 36 seconds, where a 92 MB file at one rate takes 283 MB and finishes in a\n * fraction of that; twenty-four of them never finished at all. A per-group limit is not a\n * limit, since nothing bounds the number of groups.\n *\n * One budget for the whole conversion makes the single-group case identical to what it was\n * and the many-group case bounded. Groups ask in order of rate, fastest first, so the cache\n * goes to the tables with the most rows to write and the ones that miss out are the ones\n * that would have gained least.\n */\nexport interface OffsetBudget {\n  remaining: number;\n}\n\nexport function newOffsetBudget(): OffsetBudget {\n  return { remaining: MAX_CACHED_OFFSETS };\n}\n\n/**\n * Formats the time column, reusing the part of it that repeats.\n *\n * Every value cell is already cached — a channel has at most `digitalMax - digitalMin + 1`\n * distinct readings, so the same handful of strings serve millions of rows. The time column\n * had no such luck: it rises monotonically, so no two rows share a string and `toFixed` ran\n * once per row. On a ten-million-row conversion that was a third of the total time, more\n * than reading the file and writing the CSV put together.\n *\n * What repeats is the offset within a record. Sample `s` sits at `s / rate` from the start of\n * whichever record holds it, and there are only `samplesPerRecord` such offsets in the whole\n * recording. Splitting each into whole seconds and printed fraction turns the per-row work\n * into one integer addition and a concatenation:\n *\n *     record starting at 42s, sample 7 of a 100 Hz record\n *     -> 42 + 0 whole seconds, fraction \".070\"  ->  \"42.070\"\n *\n * The decomposition is only valid when the record starts on a whole, non-negative second,\n * which is what lets the fraction come entirely from the offset. A record starting at 0.5 s would mix the\n * two, so those fall back to formatting the sum directly. Continuous recordings start every\n * record at `index * recordDuration`, so this holds for all of them whose record duration is\n * a whole number of seconds, and for discontinuous files it holds per record depending on\n * where that record actually starts.\n */\nexport function makeTimeFormatter(\n  samplesPerRecord: number,\n  rate: number,\n  decimals: number,\n  budget: OffsetBudget = newOffsetBudget(),\n): (recordStart: number, sample: number) => string {\n  const usable = rate > 0 && Number.isFinite(rate);\n\n  /** The sum, formatted. Right only where the decomposition below does not apply. */\n  const summed = (recordStart: number, sample: number): string =>\n    fixed(recordStart + sample / rate, decimals);\n\n  /*\n    The same decomposition the table holds, computed on the spot.\n\n    This used to be the sum, and that made the time column two columns depending on how much\n    of the budget above was left. `recordStart + sample / rate` cannot carry the fraction once\n    the record start is large: at a start of 1e9 and 30 kHz the exact instant is\n    1000000000.0000333333, and the double nearest the sum prints as 1000000000.00003338 —\n    the last two places are the addition's rounding, not the recording's clock.\n\n    Which of the two a rate group got was decided by the groups ahead of it, since they ask\n    from one budget fastest first. So a recording whose fast channel takes the table left its\n    slow channel adding doubles, and the same channel asked for on its own got the table:\n\n        edf2csv far.edf --out whole                 ->  1000000000.00003338\n        edf2csv far.edf --out one --channels slow   ->  1000000000.00003333\n\n    Two files from one recording disagreeing about when a sample was taken, in a tool whose\n    documentation says `--channels` selects columns and changes nothing else. The narrowing\n    sweep asserts exactly that and could not see it: its fixtures are small enough that the\n    budget never runs out, so both conversions took the table.\n\n    The sum is still the answer where the decomposition has nothing to stand on — a record\n    starting on a fraction or before zero, where the whole part and the fraction are not\n    separable — and past 1e21, where the whole part stops printing in full.\n  */\n  const composed = (recordStart: number, sample: number): string => {\n    const text = fixed(sample / rate, decimals);\n    const dot = text.indexOf('.');\n    const whole = recordStart + (dot === -1 ? Number(text) : Number(text.slice(0, dot)));\n    if (whole >= 1e21) return summed(recordStart, sample);\n    return dot === -1 ? `${whole}` : `${whole}${text.slice(dot)}`;\n  };\n\n  /** What every row gets when the table is not there to be read. */\n  const direct = (recordStart: number, sample: number): string =>\n    usable && sample >= 0 && Number.isInteger(recordStart) && recordStart >= 0\n      ? composed(recordStart, sample)\n      : summed(recordStart, sample);\n\n  if (!usable || samplesPerRecord <= 0 || samplesPerRecord > budget.remaining) {\n    return direct;\n  }\n  budget.remaining -= samplesPerRecord;\n\n  // Whole seconds and printed fraction of each offset, taken from the formatted offset\n  // itself so that an offset which rounds up to the next second (0.9996 at three places)\n  // carries that second rather than losing it.\n  const wholeOffset = new Float64Array(samplesPerRecord);\n  const fractionText: string[] = new Array<string>(samplesPerRecord);\n  for (let sample = 0; sample < samplesPerRecord; sample++) {\n    const text = fixed(sample / rate, decimals);\n    const dot = text.indexOf('.');\n    wholeOffset[sample] = dot === -1 ? Number(text) : Number(text.slice(0, dot));\n    fractionText[sample] = dot === -1 ? '' : text.slice(dot);\n  }\n\n  return (recordStart: number, sample: number): string => {\n    /*\n      Non-negative only. Appending a fraction to a negative whole part moves the time the\n      wrong way: a record at -5 s and an offset of half a second is -4.5, but \"-5\" and\n      \".500\" concatenate to -5.500. Recording times start at zero, so this is unreachable\n      from a well-formed file — an EDF+ timekeeping TAL is free to carry a negative onset\n      though, and that is enough reason for the fast path to decline it.\n    */\n    if (\n      sample < 0 ||\n      sample >= samplesPerRecord ||\n      !Number.isInteger(recordStart) ||\n      recordStart < 0\n    ) {\n      return direct(recordStart, sample);\n    }\n    const whole = recordStart + (wholeOffset[sample] as number);\n    /*\n      The same 1e21 cliff `fixed` guards against, arriving through the back door.\n\n      `${whole}` is the implicit Number-to-String conversion, which switches to exponent\n      notation at 1e21 exactly as `toFixed` does — and then the cached fraction is glued onto\n      the end of it, so the cell reads \"1e+21.000\". That is not a number in any notation:\n      pandas and R both parse it as NaN, and a column of ordinary decimals ends in a run of\n      them. A header may legitimately say `1e21` in its 8-character record-duration field, so\n      three records are enough to reach it.\n\n      The slow path already expands these with BigInt. One comparison per row keeps that\n      correct without giving up the cache for the other twenty million.\n    */\n    if (whole >= 1e21) return summed(recordStart, sample);\n    return `${whole}${fractionText[sample] as string}`;\n  };\n}\n"]}
+{"version":3,"file":"number.js","sourceRoot":"","sources":["../../src/format/number.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Number formatting for CSV cells.\n *\n * A one-hour, 23-channel, 256 Hz recording is about 21 million numeric cells, so\n * this is the hottest code in a conversion. Two things keep it cheap:\n *\n *  - Every sample in a channel comes from a bounded set of integers (digitalMin to\n *    digitalMax, typically 4096 distinct values for a 12-bit ADC). The formatted\n *    text for a digital code never changes, so it is computed once and reused.\n *  - The cache fills lazily. Real recordings visit only a fraction of the range,\n *    and a channel with an implausibly wide range falls back to direct formatting\n *    rather than reserving memory it will never use.\n */\n\nimport type { EdfSignal } from '../edf/header.js';\nimport { makeScaler } from '../edf/scale.js';\n\n/** Widest digital range worth caching: 16 bits of pointers is 512 KB per channel. */\nconst MAX_CACHED_SPAN = 1 << 16;\n\n/**\n * How many cached sample slots a conversion has left to spend.\n *\n * MAX_CACHED_SPAN is a bound on one channel, and a bound on one channel is not a bound: a\n * file may declare as many channels as it likes, and each was handed its own cache. A\n * channel declaring the ordinary full 16-bit digital range takes the whole 512 KB, so a\n * 256-channel montage reserved 134 MB of pointers before writing a row — a 7.9 MB\n * recording that needed a 192 MB heap and died with a V8 out-of-memory fatal error under\n * anything smaller. The caches were the live set; nothing else in the conversion came near\n * them. It is the same shape of mistake the offset budget below was made to fix, one level\n * over: there the unbounded count was rate groups, here it is channels.\n *\n * One budget for the whole conversion leaves the ordinary recording exactly as it was and\n * puts a ceiling on the dense montage: the same 256-channel file now holds its caches to\n * 16 MB and converts under a 48 MB heap. Channels ask in the order the groups are written,\n * which is fastest rate first, so the cache goes to the channels with the most cells to\n * format. The ones that miss out fall back to formatting directly, which produces\n * identical text — the output is byte-for-byte what it was.\n */\nexport interface SampleCacheBudget {\n  remaining: number;\n}\n\n/**\n * Slots for the whole conversion: 16 MB of pointers if every one is claimed.\n *\n * Enough that a full 32-channel montage declaring the whole 16-bit range keeps every cache\n * it had before, and 512 channels of an ordinary 12-bit ADC do too. Past that the extra\n * channels format directly, which costs about a quarter of the conversion's time on a\n * recording where almost none of them are cached — against a file that did not convert at\n * all under a 128 MB heap.\n */\nconst MAX_CACHED_SAMPLES = 1 << 21;\n\nexport function newSampleCacheBudget(): SampleCacheBudget {\n  return { remaining: MAX_CACHED_SAMPLES };\n}\n\n/**\n * Format with a fixed number of decimals, normalising negative zero.\n *\n * Without this, a sample that scales to a very small negative value prints as\n * \"-0.000\", which looks like a distinct measurement but is not.\n */\nexport function fixed(value: number, decimals: number): string {\n  // An undefined value becomes an empty cell rather than the text \"NaN\" or \"Infinity\".\n  // A channel whose header leaves the digital-to-physical mapping undefined scales to\n  // NaN, and an empty field is the CSV convention for \"no value here\" — the same one\n  // annotations.csv uses for an absent duration. Readers parse it back as NaN / NA\n  // rather than as a measurement.\n  if (!Number.isFinite(value)) return '';\n\n  // toFixed switches to exponent notation at 1e21, which would put \"1e+21\" in a column\n  // whose every other cell is plain fixed-decimal — and a reader parsing the column as\n  // decimal text has no reason to expect it. Reachable because EDF's 8-character physical\n  // range fields accept exponent form, so a header may legitimately say \"1e30\".\n  //\n  // Above 2^53 a double carries no fractional part anyway, so the integer expansion is\n  // exact rather than an approximation of one.\n  if (Math.abs(value) >= 1e21) {\n    const whole = BigInt(Math.trunc(value)).toString();\n    return decimals > 0 ? `${whole}.${'0'.repeat(decimals)}` : whole;\n  }\n\n  const text = value.toFixed(decimals);\n  if (text.charCodeAt(0) !== 45 /* - */) return text;\n  // Cheap check for \"-0\", \"-0.0\", \"-0.000\"...\n  for (let i = 1; i < text.length; i++) {\n    const c = text.charCodeAt(i);\n    if (c === 46 /* . */ || c === 48 /* 0 */) continue;\n    return text;\n  }\n  return text.slice(1);\n}\n\n/**\n * A number as plain decimal text, at any magnitude.\n *\n * `String()` switches to exponent notation twice — above 1e21 and below 1e-6 — and\n * annotations.csv wrote its `onset_s` and `duration_s` through it. An EDF+ TAL states its\n * onset as ordinary decimal text, so a file saying `+0.0000001` came back as `1e-7` in a\n * column whose every other cell is a plain decimal, beside a `time_s` the documentation says\n * it \"joins directly\" with. It does not: pandas reads the column as object rather than\n * float64 once one cell is exponent text, and a `merge` on it matches nothing.\n *\n * `fixed` cannot answer this. It needs a decimal count, and these two columns are documented\n * as carrying \"their natural numeric form ... without padding to a fixed decimal count\" —\n * asking for enough places to hold 1e-7 would rewrite `0.1` as `0.10000000000000000555`.\n * Expanding the notation instead touches only the values that are in it and leaves every\n * other cell byte-for-byte what it was.\n */\nexport function plain(value: number): string {\n  const text = String(value);\n  const e = text.indexOf('e');\n  if (e === -1) return text;\n  const negative = text.charCodeAt(0) === 45 /* - */;\n  const mantissa = text.slice(negative ? 1 : 0, e);\n  const dot = mantissa.indexOf('.');\n  // Where the point sits once the exponent is spent, counted in significant digits.\n  const point = (dot === -1 ? mantissa.length : dot) + Number(text.slice(e + 1));\n  const digits = dot === -1 ? mantissa : mantissa.slice(0, dot) + mantissa.slice(dot + 1);\n  const sign = negative ? '-' : '';\n  if (point <= 0) return `${sign}0.${'0'.repeat(-point)}${digits}`;\n  if (point >= digits.length) return `${sign}${digits}${'0'.repeat(point - digits.length)}`;\n  return `${sign}${digits.slice(0, point)}.${digits.slice(point)}`;\n}\n\n/** Maps a raw digital sample to its formatted physical value. */\nexport type SampleFormatter = (digital: number) => string;\n\nexport function makeSampleFormatter(\n  signal: EdfSignal,\n  decimals: number,\n  budget: SampleCacheBudget = newSampleCacheBudget(),\n): SampleFormatter {\n  const scale = makeScaler(signal);\n  const low = Math.min(signal.digitalMin, signal.digitalMax);\n  const high = Math.max(signal.digitalMin, signal.digitalMax);\n  const span = high - low + 1;\n\n  if (\n    !Number.isFinite(span) ||\n    span <= 0 ||\n    span > MAX_CACHED_SPAN ||\n    span > budget.remaining\n  ) {\n    return (digital: number): string => fixed(scale(digital), decimals);\n  }\n  budget.remaining -= span;\n\n  /*\n    The cache covers the channel's declared digital range, not the whole int16 domain.\n\n    Allocating 65536 slots regardless of span cost 512 KB of pointers per channel, which a\n    dense montage cannot afford: a 400-channel recording needed over 200 MB of cache alone\n    and died with a V8 out-of-memory fatal error before writing a row. Sizing to the\n    declared span makes the ordinary 12-bit channel 32 KB instead — the same 400 channels\n    now fit in about 13 MB. Channels that declare the full range still take the whole 512 KB,\n    which is what the budget above is for.\n\n    Samples outside the declared range still occur in non-conforming files. They simply\n    miss the cache and are formatted directly, which produces identical text.\n  */\n  const cache = new Array<string | undefined>(span);\n  return (digital: number): string => {\n    const slot = digital - low;\n    if (slot >= 0 && slot < span) {\n      const hit = cache[slot];\n      if (hit !== undefined) return hit;\n      const text = fixed(scale(digital), decimals);\n      cache[slot] = text;\n      return text;\n    }\n    return fixed(scale(digital), decimals);\n  };\n}\n\n/**\n * Decimals for the time column.\n *\n * The interval between samples is 1/rate, which has a terminating decimal expansion of d\n * places exactly when 10^d divides evenly by the rate. Writing that many places makes sample\n * times exact rather than rounded, so `time_s * rate` comes back as a whole number instead\n * of 8191.999999.\n *\n * The search used to stop at nine places, and the comment here claimed \"every rate in common\n * use clears this — 256 Hz needs 8 places, 512 Hz needs 9\". The next two powers of two do\n * not: 1/1024 needs ten places and 1/2048 needs eleven, and those are the rates a BioSemi\n * ActiveTwo records at by default. Both fell through to the rounding fallback, so the two\n * most common high-rate EEG recordings got exactly the behaviour this function exists to\n * avoid — 0.0009766 for an interval of 0.0009765625.\n *\n * A rate of 2^a * 5^b terminates in max(a, b) places, so fifteen covers every power of two up\n * to 32768 Hz, far past anything that records biosignals. Rates with a repeating expansion\n * (3 Hz, say) still fall back to enough places to keep consecutive samples distinct, and that\n * fallback keeps its own cap.\n *\n * Fifteen and not more, because the test below has to stay exact: 10^16 is past 2^53, where a\n * double can no longer hold every integer, and `Number.isInteger(10 ** 17 / 3)` is true — so a\n * larger bound reports a terminating expansion for rates that have none, and 3 Hz would ask\n * for seventeen decimals of a number that repeats forever.\n *\n * The fallback is bounded by the same fifteen. It used to stop at nine, which defeated the\n * one thing it exists to do: at 3e10 Hz — non-terminating, so no exact expansion to find —\n * the interval is 3.3e-11 and nine places rounded every sample in a record to the same\n * timestamp. A column that cannot tell two samples apart is not keeping them distinct, which\n * is what this branch is for.\n */\nconst MAX_TIME_DECIMALS = 15;\n\nexport function timeDecimals(samplingRate: number): number {\n  if (!(samplingRate > 0) || !Number.isFinite(samplingRate)) return 3;\n  for (let d = 0; d <= MAX_TIME_DECIMALS; d++) {\n    if (Number.isInteger(10 ** d / samplingRate)) return Math.max(3, d);\n  }\n  return Math.min(MAX_TIME_DECIMALS, Math.max(3, Math.ceil(Math.log10(samplingRate)) + 3));\n}\n\n/** Human-readable byte size for warnings and summaries. */\nexport function formatBytes(bytes: number): string {\n  const units = ['B', 'KB', 'MB', 'GB', 'TB'];\n  let value = bytes;\n  let unit = 0;\n  while (value >= 1024 && unit < units.length - 1) {\n    value /= 1024;\n    unit++;\n  }\n  let rounded = value >= 100 || unit === 0 ? Math.round(value) : Number(value.toFixed(1));\n  // Rounding can carry into the next unit, and the unit was chosen before it: 1,048,575 bytes\n  // is 1023.999 KB, which printed as \"1024 KB\". The same slip formatDuration below fixed by\n  // rounding before splitting, one function up.\n  if (rounded === 1024 && unit < units.length - 1) {\n    unit++;\n    rounded = 1;\n  }\n  return `${rounded} ${units[unit]}`;\n}\n\n/** Human-readable duration: 1h 05m 12s. */\nexport function formatDuration(seconds: number): string {\n  // A duration that is not a number cannot be broken into hours and minutes, and saying so\n  // beats the alternative: the fallback below rendered these as \"NaNs\" and \"Infinitys\".\n  if (!Number.isFinite(seconds)) return 'unknown';\n\n  /*\n    Past 2^53 the decomposition stops being arithmetic and starts being noise.\n\n    `total - h * 3600 - m * 60` cannot be exact once `total` exceeds what a double can hold\n    as a whole number, and the error lands in the seconds field, where it shows up as a\n    value that cannot exist. A header declaring a record duration of 1e300 printed:\n\n        Duration   8.333333333333333e+296h 48m -2880s\n\n    Forty-eight minutes and minus forty-eight seconds, under an hours field in exponent\n    notation. The seconds are the honest form for a figure this size — nobody reads\n    285 million years as hours — and the record count and duration are printed beside it\n    anyway, so a corrupt header stays just as visible.\n\n    Written through `fixed` rather than by interpolation, which is the same 1e21 cliff again:\n    `${seconds}` switches to exponent notation exactly where `toFixed` does, so the fallback\n    put a token back that this tool's own parser refuses. `--start 4000000000000000000000` on\n    a recording of three 1e21-second records was answered with\n\n        --start \"4000000000000000000000\" is at or past the end of this 3e+21s recording.\n\n    a sentence whose whole job is to say what window there is to ask for, ending in a length\n    `--start` and `--duration` reject with \"uses an unknown unit \\\"e\\\"\". `formatSeconds` in\n    time-range.ts was fixed for this in the other half of that same message, and its comment\n    quotes this half as part of what was wrong. `fixed` expands these with BigInt, which is\n    exact past 2^53 where a double carries no fraction anyway.\n  */\n  if (seconds < 0 || seconds >= Number.MAX_SAFE_INTEGER) return `${fixed(seconds, 0)}s`;\n\n  // Round to the precision that will actually be printed BEFORE splitting into units.\n  // Splitting first left the remainder to be rounded on its own, so 3599.9996 s decomposed\n  // as 59 minutes and 59.9996 seconds and then printed as \"59m 60s\" — a duration that\n  // cannot exist. Rounding first carries the extra second into the minute where it belongs.\n  const total = Math.round(seconds * 1000) / 1000;\n  /*\n    A duration shorter than the rounding is not a duration of zero.\n\n    Three decimals is the right precision for a recording measured in hours, and it collapses\n    everything under half a millisecond to \"0s\". `repeating-fast.edf` — two records of 1e-15s,\n    six samples, one of this repository's own fixtures — printed\n\n        Duration   0s  (2 records of 1e-15s)\n\n    and refused `--start 0.5` with \"is at or past the end of this 0s recording\". A reader is\n    told the file holds nothing, on the line they look at first, about a file that converts to\n    six rows; the record duration two columns over already contradicts it. Same shape as the\n    other end of this function, which stops decomposing past 2^53 and prints the seconds\n    instead, and as the byte size above, which carries 1023.999 KB up rather than printing the\n    \"1024 KB\" no unit has. None of the three is a rounding rule; each one refuses to print a\n    form the quantity cannot take.\n\n    Written through `plain` rather than interpolated, for the reason the comment above gives:\n    `${1e-15}` is exponent notation, and the sentence this feeds is one whose whole job is to\n    say what `--start` may be given — and `--start 1e-15s` is refused as an unknown unit \"e\".\n  */\n  if (total === 0 && seconds > 0) return `${plainSeconds(seconds)}s`;\n  const h = Math.floor(total / 3600);\n  const m = Math.floor((total % 3600) / 60);\n  const s = Math.round((total - h * 3600 - m * 60) * 1000) / 1000;\n  const sText = Number.isInteger(s) ? String(s) : s.toFixed(3).replace(/\\.?0+$/u, '');\n  if (h > 0) return `${h}h ${String(m).padStart(2, '0')}m ${sText}s`;\n  if (m > 0) return `${m}m ${sText}s`;\n  return `${sText}s`;\n}\n\n/**\n * A length of time in a form the sentence it sits in can hold.\n *\n * `plain` expands a double to its full decimal form, which is what the columns of\n * annotations.csv need — one notation down a column, so a `merge` on it matches. Every message\n * that states a length of seconds took the same rendering, and a record duration is eight\n * characters of header, so `1e308` and `1e-320` both fit in one:\n *\n *     Duration   unknown  (2 records of 1000000000000000000000 ... 000s)\n *\n * Three hundred and nine digits, on a line whose other half has just said the total cannot be\n * stated — and three lines under a RATE column rendering the same magnitude as `4.000e-308 Hz`,\n * because `formatRate` already falls back to exponent form when plain decimal stops carrying\n * the number. This is the failure `listed` was written for, one line over: a message is not\n * the place for everything a header is free to ask for.\n *\n * Plain while plain is *typable*, which is the reason the expansion is here at all —\n * `--start 1e-15s` is refused as an unknown unit `e`, so `repeating-fast.edf` reads\n * `0.000000000000001s` and can be acted on. Past the width of a line nothing is typable\n * either way: a reader cannot count three hundred digits any more than they can pass an\n * exponent, so the shortest exact form is the more honest of the two.\n *\n * Here rather than in cli/report.ts, where 0.8.95 wrote it for one half of one line. The\n * other half of that same line expanded a duration of 3e-308 to three hundred and ten\n * characters; so did the refusal naming a record duration that is not positive, and the hint\n * that says how wide a window has to be to hold a sample. All four state a length of seconds\n * out of a header, and the rule is one rule.\n */\nconst LONGEST_PLAIN_SECONDS = 30;\n\nexport function plainSeconds(seconds: number): string {\n  const expanded = plain(seconds);\n  return expanded.length <= LONGEST_PLAIN_SECONDS ? expanded : String(seconds);\n}\n\n/** A record can declare a great many samples; two arrays this size is the cost of caching. */\nconst MAX_CACHED_OFFSETS = 1 << 20;\n\n/**\n * How many cached offsets a conversion has left to spend.\n *\n * The cap used to be per rate group, and a file may hold as many rate groups as it has\n * channels. Twelve channels at twelve rates just under the cap — a 25 MB file — took\n * 1.66 GB and 36 seconds, where a 92 MB file at one rate takes 283 MB and finishes in a\n * fraction of that; twenty-four of them never finished at all. A per-group limit is not a\n * limit, since nothing bounds the number of groups.\n *\n * One budget for the whole conversion makes the single-group case identical to what it was\n * and the many-group case bounded. Groups ask in order of rate, fastest first, so the cache\n * goes to the tables with the most rows to write and the ones that miss out are the ones\n * that would have gained least.\n */\nexport interface OffsetBudget {\n  remaining: number;\n}\n\nexport function newOffsetBudget(): OffsetBudget {\n  return { remaining: MAX_CACHED_OFFSETS };\n}\n\n/**\n * Formats the time column, reusing the part of it that repeats.\n *\n * Every value cell is already cached — a channel has at most `digitalMax - digitalMin + 1`\n * distinct readings, so the same handful of strings serve millions of rows. The time column\n * had no such luck: it rises monotonically, so no two rows share a string and `toFixed` ran\n * once per row. On a ten-million-row conversion that was a third of the total time, more\n * than reading the file and writing the CSV put together.\n *\n * What repeats is the offset within a record. Sample `s` sits at `s / rate` from the start of\n * whichever record holds it, and there are only `samplesPerRecord` such offsets in the whole\n * recording. Splitting each into whole seconds and printed fraction turns the per-row work\n * into one integer addition and a concatenation:\n *\n *     record starting at 42s, sample 7 of a 100 Hz record\n *     -> 42 + 0 whole seconds, fraction \".070\"  ->  \"42.070\"\n *\n * The decomposition is only valid when the record starts on a whole, non-negative second,\n * which is what lets the fraction come entirely from the offset. A record starting at 0.5 s would mix the\n * two, so those fall back to formatting the sum directly. Continuous recordings start every\n * record at `index * recordDuration`, so this holds for all of them whose record duration is\n * a whole number of seconds, and for discontinuous files it holds per record depending on\n * where that record actually starts.\n */\nexport function makeTimeFormatter(\n  samplesPerRecord: number,\n  rate: number,\n  decimals: number,\n  budget: OffsetBudget = newOffsetBudget(),\n): (recordStart: number, sample: number) => string {\n  const usable = rate > 0 && Number.isFinite(rate);\n\n  /** The sum, formatted. Right only where the decomposition below does not apply. */\n  const summed = (recordStart: number, sample: number): string =>\n    fixed(recordStart + sample / rate, decimals);\n\n  /*\n    The same decomposition the table holds, computed on the spot.\n\n    This used to be the sum, and that made the time column two columns depending on how much\n    of the budget above was left. `recordStart + sample / rate` cannot carry the fraction once\n    the record start is large: at a start of 1e9 and 30 kHz the exact instant is\n    1000000000.0000333333, and the double nearest the sum prints as 1000000000.00003338 —\n    the last two places are the addition's rounding, not the recording's clock.\n\n    Which of the two a rate group got was decided by the groups ahead of it, since they ask\n    from one budget fastest first. So a recording whose fast channel takes the table left its\n    slow channel adding doubles, and the same channel asked for on its own got the table:\n\n        edf2csv far.edf --out whole                 ->  1000000000.00003338\n        edf2csv far.edf --out one --channels slow   ->  1000000000.00003333\n\n    Two files from one recording disagreeing about when a sample was taken, in a tool whose\n    documentation says `--channels` selects columns and changes nothing else. The narrowing\n    sweep asserts exactly that and could not see it: its fixtures are small enough that the\n    budget never runs out, so both conversions took the table.\n\n    The sum is still the answer where the decomposition has nothing to stand on — a record\n    starting on a fraction or before zero, where the whole part and the fraction are not\n    separable — and past 1e21, where the whole part stops printing in full.\n  */\n  const composed = (recordStart: number, sample: number): string => {\n    const text = fixed(sample / rate, decimals);\n    const dot = text.indexOf('.');\n    const whole = recordStart + (dot === -1 ? Number(text) : Number(text.slice(0, dot)));\n    if (whole >= 1e21) return summed(recordStart, sample);\n    return dot === -1 ? `${whole}` : `${whole}${text.slice(dot)}`;\n  };\n\n  /** What every row gets when the table is not there to be read. */\n  const direct = (recordStart: number, sample: number): string =>\n    usable && sample >= 0 && Number.isInteger(recordStart) && recordStart >= 0\n      ? composed(recordStart, sample)\n      : summed(recordStart, sample);\n\n  if (!usable || samplesPerRecord <= 0 || samplesPerRecord > budget.remaining) {\n    return direct;\n  }\n  budget.remaining -= samplesPerRecord;\n\n  // Whole seconds and printed fraction of each offset, taken from the formatted offset\n  // itself so that an offset which rounds up to the next second (0.9996 at three places)\n  // carries that second rather than losing it.\n  const wholeOffset = new Float64Array(samplesPerRecord);\n  const fractionText: string[] = new Array<string>(samplesPerRecord);\n  for (let sample = 0; sample < samplesPerRecord; sample++) {\n    const text = fixed(sample / rate, decimals);\n    const dot = text.indexOf('.');\n    wholeOffset[sample] = dot === -1 ? Number(text) : Number(text.slice(0, dot));\n    fractionText[sample] = dot === -1 ? '' : text.slice(dot);\n  }\n\n  return (recordStart: number, sample: number): string => {\n    /*\n      Non-negative only. Appending a fraction to a negative whole part moves the time the\n      wrong way: a record at -5 s and an offset of half a second is -4.5, but \"-5\" and\n      \".500\" concatenate to -5.500. Recording times start at zero, so this is unreachable\n      from a well-formed file — an EDF+ timekeeping TAL is free to carry a negative onset\n      though, and that is enough reason for the fast path to decline it.\n    */\n    if (\n      sample < 0 ||\n      sample >= samplesPerRecord ||\n      !Number.isInteger(recordStart) ||\n      recordStart < 0\n    ) {\n      return direct(recordStart, sample);\n    }\n    const whole = recordStart + (wholeOffset[sample] as number);\n    /*\n      The same 1e21 cliff `fixed` guards against, arriving through the back door.\n\n      `${whole}` is the implicit Number-to-String conversion, which switches to exponent\n      notation at 1e21 exactly as `toFixed` does — and then the cached fraction is glued onto\n      the end of it, so the cell reads \"1e+21.000\". That is not a number in any notation:\n      pandas and R both parse it as NaN, and a column of ordinary decimals ends in a run of\n      them. A header may legitimately say `1e21` in its 8-character record-duration field, so\n      three records are enough to reach it.\n\n      The slow path already expands these with BigInt. One comparison per row keeps that\n      correct without giving up the cache for the other twenty million.\n    */\n    if (whole >= 1e21) return summed(recordStart, sample);\n    return `${whole}${fractionText[sample] as string}`;\n  };\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edf2csv",
-  "version": "0.8.97",
+  "version": "0.8.99",
   "description": "Convert EDF, EDF+ and BDF biosignal recordings (European Data Format) to CSV from the command line. Local, streaming, and never resamples or alters units.",
   "keywords": [
     "edf",