Added bigint.

Author: uhop

llms-full.txt

@@ -280,6 +280,8 @@ Browser-safe Web-only entry: `stream-json/web/disassembler.js` (no Node-stream i
 Options: same as Parser (`packKeys`, `packStrings`, `packNumbers`, `streamKeys`, `streamStrings`, `streamNumbers`, `packValues`, `streamValues`). Also:
 - `replacer` (function or array) — like `JSON.stringify` replacer.
 
+Value handling follows `JSON.stringify`: `toJSON()` is honored; functions, symbols, and `undefined` are skipped in objects and become `null` in arrays; `NaN` and `±Infinity` become `null`. Exception: `bigint` is emitted as number tokens with all digits intact (JSON has no magnitude limit) instead of throwing.
+
 ```js
 import {disassembler} from 'stream-json/disassembler.js';
 import {stringer} from 'stream-json/stringer.js';
@@ -426,9 +428,10 @@ Replaces matching subobjects with a replacement value.
 
 Extra option:
 - `replacement` — the replacement:
-  - **function** `(stack, chunk, options) => value` — dynamic replacement.
-  - **value** — static replacement value (converted to tokens).
+  - **function** `(stack, chunk, options) => tokens` — dynamic replacement; return `none` to remove the value.
+  - **token** — a single static token, such as `{name: 'nullValue', value: null}`.
   - **array** — array of tokens to insert.
+  - Anything else, including `null`, removes the value.
   - Default: `none` (removes the value, replaced by nothing).
 
 ```js

llms.txt

@@ -121,7 +121,7 @@ e.addEventListener('keyValue', ev => console.log(ev.detail));
 All filters accept `{filter, pathSeparator, once, streamKeys, maxDepth}` options. `filter` can be a string, RegExp, or `(stack, chunk) => boolean`. `maxDepth` caps the JSON nesting depth a filter evaluates (default `1024`; a deeper token throws a `RangeError`, `Infinity` disables the limit).
 
 - **`pick(options)`** — passes only matching subobjects, discards the rest.
-- **`replace(options)`** — replaces matching subobjects. Extra option: `replacement` (function, value, or array of tokens).
+- **`replace(options)`** — replaces matching subobjects. Extra option: `replacement` (function, token, or array of tokens).
 - **`ignore(options)`** — removes matching subobjects completely.
 - **`filter(options)`** — keeps matching subobjects preserving surrounding structure.
 

src/core/disassembler.d.ts

@@ -5,6 +5,8 @@ import type parser from './parser.js';
  *
  * The inverse of the parser: takes JS values and produces `{name, value}` tokens
  * following the same protocol. Supports `JSON.stringify()`-compatible `replacer` and `toJSON()`.
+ * `bigint` values become number tokens with all digits intact (JSON has no magnitude limit;
+ * `JSON.stringify()` throws instead).
  *
  * This is the pure, stream-agnostic factory — no `.asStream` / `.asWebStream` adapters
  * attached. For the Node-flavored entry (with both adapters) import from

src/core/disassembler.js

@@ -14,13 +14,14 @@ function* dump(value, options, processed) {
     case 'function':
     case 'symbol':
     case 'undefined':
-    case 'bigint':
       return;
     case 'number':
       if (isNaN(value) || !isFinite(value)) {
         yield {name: 'nullValue', value: null};
         return;
       }
+    // falls through
+    case 'bigint':
       value = String(value);
       if (options.streamNumbers) {
         yield {name: 'startNumber'};
@@ -71,7 +72,6 @@ function* dump(value, options, processed) {
         case 'function':
         case 'symbol':
         case 'undefined':
-        case 'bigint':
           v = null; // force null
           break;
       }
@@ -95,7 +95,6 @@ function* dump(value, options, processed) {
       case 'function':
       case 'symbol':
       case 'undefined':
-      case 'bigint':
         continue;
     }
     if (options.streamKeys) {

tests/node/test-disassembler.js

@@ -6,6 +6,7 @@ import disassembler from '../../src/disassembler.js';
 import pick from '../../src/filters/pick.js';
 import streamArray from '../../src/streamers/stream-array.js';
 import streamValues from '../../src/streamers/stream-values.js';
+import {stringer} from '../../src/stringer.js';
 
 import {readString} from '../helpers.js';
 
@@ -33,7 +34,7 @@ test.asPromise('disassembler: roundtrip', (t, resolve, reject) => {
 });
 
 test.asPromise('disassembler: bad top-level values', (t, resolve, reject) => {
-  const input = [1, () => {}, 2, undefined, 3, Symbol(), 4, 5n],
+  const input = [1, () => {}, 2, undefined, 3, Symbol(), 4],
     result = [],
     pipeline = chain([disassembler(), streamValues()]);
 
@@ -51,7 +52,7 @@ test.asPromise('disassembler: bad top-level values', (t, resolve, reject) => {
 });
 
 test.asPromise('disassembler: bad values in object', (t, resolve, reject) => {
-  const input = [{a: 1, b: () => {}, c: 2, d: undefined, e: 3, f: Symbol(), g: 4, h: 5n}],
+  const input = [{a: 1, b: () => {}, c: 2, d: undefined, e: 3, f: Symbol(), g: 4}],
     result = [],
     pipeline = chain([disassembler(), streamValues()]);
 
@@ -69,14 +70,14 @@ test.asPromise('disassembler: bad values in object', (t, resolve, reject) => {
 });
 
 test.asPromise('disassembler: bad values in array', (t, resolve, reject) => {
-  const input = [[1, () => {}, 2, undefined, 3, Symbol(), 4, 5n]],
+  const input = [[1, () => {}, 2, undefined, 3, Symbol(), 4]],
     result = [],
     pipeline = chain([disassembler(), streamValues()]);
 
   pipeline.on('data', item => result.push(item.value));
   pipeline.on('error', reject);
   pipeline.on('end', () => {
-    t.deepEqual(result, [[1, null, 2, null, 3, null, 4, null]]);
+    t.deepEqual(result, [[1, null, 2, null, 3, null, 4]]);
     resolve();
   });
 
@@ -295,3 +296,51 @@ test('disassembler: -Infinity yields only nullValue', t => {
   t.equal(tokens[0].name, 'nullValue');
   t.equal(tokens[0].value, null);
 });
+
+test('disassembler: bigint yields number tokens with all digits', t => {
+  const fn = disassembler();
+  t.deepEqual(
+    [...fn(12345678901234567890n)],
+    [{name: 'startNumber'}, {name: 'numberChunk', value: '12345678901234567890'}, {name: 'endNumber'}, {name: 'numberValue', value: '12345678901234567890'}]
+  );
+});
+
+test('disassembler: bigint streamValues=false yields only numberValue', t => {
+  const fn = disassembler({streamValues: false});
+  t.deepEqual([...fn(-5n)], [{name: 'numberValue', value: '-5'}]);
+});
+
+test('disassembler: bigint in containers', t => {
+  const fn = disassembler({streamValues: false});
+  t.deepEqual(
+    [...fn({a: 1n, b: [2n]})],
+    [
+      {name: 'startObject'},
+      {name: 'keyValue', value: 'a'},
+      {name: 'numberValue', value: '1'},
+      {name: 'keyValue', value: 'b'},
+      {name: 'startArray'},
+      {name: 'numberValue', value: '2'},
+      {name: 'endArray'},
+      {name: 'endObject'}
+    ]
+  );
+});
+
+test.asPromise('disassembler: bigint round trip through stringer', (t, resolve, reject) => {
+  const input = [{a: 12345678901234567890n, b: [-1n, 9007199254740993n]}];
+  let buffer = '';
+  const pipeline = chain([disassembler(), stringer()]);
+
+  pipeline.on('data', data => (buffer += data));
+  pipeline.on('error', reject);
+  pipeline.on('end', () => {
+    t.equal(buffer, '{"a":12345678901234567890,"b":[-1,9007199254740993]}');
+    resolve();
+  });
+
+  for (const item of input) {
+    pipeline.write(item);
+  }
+  pipeline.end();
+});

tests/web/test-disassembler.js

@@ -9,6 +9,7 @@ import disassembler from '../../src/web/disassembler.js';
 import pick from '../../src/web/filters/pick.js';
 import streamArray from '../../src/web/streamers/stream-array.js';
 import streamValues from '../../src/web/streamers/stream-values.js';
+import {stringer} from '../../src/web/stringer.js';
 
 import {readWebString, drain} from '../web-helpers.js';
 
@@ -49,7 +50,7 @@ test.asPromise('disassembler (web): roundtrip', async (t, resolve, reject) => {
 
 test.asPromise('disassembler (web): bad top-level values', async (t, resolve, reject) => {
   try {
-    const input = [1, () => {}, 2, undefined, 3, Symbol(), 4, 5n];
+    const input = [1, () => {}, 2, undefined, 3, Symbol(), 4];
     const pipeline = chain([fromArray(input), disassembler(), streamValues()]);
     const out = await drain(pipeline);
     const result = out.map(item => item.value);
@@ -62,7 +63,7 @@ test.asPromise('disassembler (web): bad top-level values', async (t, resolve, re
 
 test.asPromise('disassembler (web): bad values in object', async (t, resolve, reject) => {
   try {
-    const input = [{a: 1, b: () => {}, c: 2, d: undefined, e: 3, f: Symbol(), g: 4, h: 5n}];
+    const input = [{a: 1, b: () => {}, c: 2, d: undefined, e: 3, f: Symbol(), g: 4}];
     const pipeline = chain([fromArray(input), disassembler(), streamValues()]);
     const out = await drain(pipeline);
     const result = out.map(item => item.value);
@@ -75,11 +76,11 @@ test.asPromise('disassembler (web): bad values in object', async (t, resolve, re
 
 test.asPromise('disassembler (web): bad values in array', async (t, resolve, reject) => {
   try {
-    const input = [[1, () => {}, 2, undefined, 3, Symbol(), 4, 5n]];
+    const input = [[1, () => {}, 2, undefined, 3, Symbol(), 4]];
     const pipeline = chain([fromArray(input), disassembler(), streamValues()]);
     const out = await drain(pipeline);
     const result = out.map(item => item.value);
-    t.deepEqual(result, [[1, null, 2, null, 3, null, 4, null]]);
+    t.deepEqual(result, [[1, null, 2, null, 3, null, 4]]);
     resolve();
   } catch (e) {
     reject(e);
@@ -258,3 +259,45 @@ test('disassembler (web): -Infinity yields only nullValue', t => {
   t.equal(tokens[0].name, 'nullValue');
   t.equal(tokens[0].value, null);
 });
+
+test('disassembler (web): bigint yields number tokens with all digits', t => {
+  const fn = disassembler();
+  t.deepEqual(
+    [...fn(12345678901234567890n)],
+    [{name: 'startNumber'}, {name: 'numberChunk', value: '12345678901234567890'}, {name: 'endNumber'}, {name: 'numberValue', value: '12345678901234567890'}]
+  );
+});
+
+test('disassembler (web): bigint streamValues=false yields only numberValue', t => {
+  const fn = disassembler({streamValues: false});
+  t.deepEqual([...fn(-5n)], [{name: 'numberValue', value: '-5'}]);
+});
+
+test('disassembler (web): bigint in containers', t => {
+  const fn = disassembler({streamValues: false});
+  t.deepEqual(
+    [...fn({a: 1n, b: [2n]})],
+    [
+      {name: 'startObject'},
+      {name: 'keyValue', value: 'a'},
+      {name: 'numberValue', value: '1'},
+      {name: 'keyValue', value: 'b'},
+      {name: 'startArray'},
+      {name: 'numberValue', value: '2'},
+      {name: 'endArray'},
+      {name: 'endObject'}
+    ]
+  );
+});
+
+test.asPromise('disassembler (web): bigint round trip through stringer', async (t, resolve, reject) => {
+  try {
+    const input = [{a: 12345678901234567890n, b: [-1n, 9007199254740993n]}];
+    const pipeline = chain([fromArray(input), disassembler(), stringer()]);
+    const out = await drain(pipeline);
+    t.equal(out.join(''), '{"a":12345678901234567890,"b":[-1,9007199254740993]}');
+    resolve();
+  } catch (e) {
+    reject(e);
+  }
+});