node-modules-tools 2.1.2 → 2.2.0

package/dist/chunks/json-parse-stream.mjs

@@ -1,1617 +1,2265 @@
-import { createRequire } from 'node:module';
-import require$$0 from 'string_decoder';
+import { Duplex, Readable, Writable } from 'node:stream';
+
+// @ts-self-types="./defs.d.ts"
+
+const none = Symbol.for('object-stream.none');
+const stop = Symbol.for('object-stream.stop');
+
+const finalSymbol = Symbol.for('object-stream.final');
+const manySymbol = Symbol.for('object-stream.many');
+const flushSymbol = Symbol.for('object-stream.flush');
+const fListSymbol = Symbol.for('object-stream.fList');
+
+const finalValue = value => ({[finalSymbol]: 1, value});
+const many = values => ({[manySymbol]: 1, values});
+
+const isFinalValue = o => o && o[finalSymbol] === 1;
+const isMany = o => o && o[manySymbol] === 1;
+const isFlushable = o => o && o[flushSymbol] === 1;
+const isFunctionList = o => o && o[fListSymbol] === 1;
+
+const getFinalValue = o => o.value;
+const getManyValues = o => o.values;
+const getFunctionList = o => o.fList;
+
+const flushable = (write, final = null) => {
+  const fn = final ? value => (value === none ? final() : write(value)) : write;
+  fn[flushSymbol] = 1;
+  return fn;
+};
+
+const setFunctionList = (o, fns) => {
+  o.fList = fns;
+  o[fListSymbol] = 1;
+  return o;
+};
+
+const clearFunctionList = o => {
+  delete o.fList;
+  delete o[fListSymbol];
+  return o;
+};
+
+class Stop extends Error {}
+
+const toMany = value =>
+  value === none ? many([]) : value && value[manySymbol] === 1 ? value : many([value]);
+
+const normalizeMany = o => {
+  if (o?.[manySymbol] === 1) {
+    switch (o.values.length) {
+      case 0:
+        return none;
+      case 1:
+        return o.values[0];
+    }
+  }
+  return o;
+};
 
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
+const combineMany = (...args) => {
+  const values = [];
+  for (let i = 0; i < args.length; ++i) {
+    const a = args[i];
+    if (a === none) continue;
+    if (a?.[manySymbol] === 1) {
+      values.push(...a.values);
+    } else {
+      values.push(a);
+    }
+  }
+  return many(values);
+};
+
+const combineManyMut = (a, ...args) => {
+  const values = a === none ? [] : a?.[manySymbol] === 1 ? a.values : [a];
+  for (let i = 0; i < args.length; ++i) {
+    const b = args[i];
+    if (b === none) continue;
+    if (b?.[manySymbol] === 1) {
+      values.push(...b.values);
+    } else {
+      values.push(b);
+    }
+  }
+  return many(values);
+};
+
+// ---------------------------------------------------------------------------
+// Stream type guards (shape-based). Live in defs.js so the symmetric
+// is*WebStream and is*NodeStream are co-located and reachable from any
+// subpath. Neither path imports `node:stream` — both are duck-typed:
+//
+// - Web: ReadableStream has `getReader`, WritableStream has `getWriter`
+//   (Node streams expose neither).
+// - Node: streams expose `.pipe` / `.write` / `.on` plus the private
+//   `_readableState` / `_writableState` markers (Web streams expose none).
+//
+// Node guard logic is taken from
+// https://github.com/nodejs/node/blob/master/lib/internal/streams/utils.js
+// ---------------------------------------------------------------------------
+
+const isReadableWebStream$1 = x =>
+  !!(
+    x &&
+    typeof x === 'object' &&
+    typeof x.getReader === 'function' &&
+    typeof x.pipeTo === 'function'
+  );
+
+const isWritableWebStream$1 = x =>
+  !!(
+    x &&
+    typeof x === 'object' &&
+    typeof x.getWriter === 'function' &&
+    typeof x.abort === 'function'
+  );
+
+const isDuplexWebStream$1 = x =>
+  !!(
+    x &&
+    typeof x === 'object' &&
+    isReadableWebStream$1(x.readable) &&
+    isWritableWebStream$1(x.writable)
+  );
+
+const isReadableNodeStream$1 = obj =>
+  obj &&
+  typeof obj.pipe === 'function' &&
+  typeof obj.on === 'function' &&
+  (!obj._writableState ||
+    (typeof obj._readableState === 'object' ? obj._readableState.readable : null) !== false) &&
+  (!obj._writableState || obj._readableState);
+
+const isWritableNodeStream$1 = obj =>
+  obj &&
+  typeof obj.write === 'function' &&
+  typeof obj.on === 'function' &&
+  (!obj._readableState ||
+    (typeof obj._writableState === 'object' ? obj._writableState.writable : null) !== false);
+
+const isDuplexNodeStream$1 = obj =>
+  obj &&
+  typeof obj.pipe === 'function' &&
+  obj._readableState &&
+  typeof obj.on === 'function' &&
+  typeof obj.write === 'function';
+
+// old aliases
+const final$1 = finalValue;
+
+const defs = {
+  __proto__: null,
+  Stop: Stop,
+  clearFunctionList: clearFunctionList,
+  combineMany: combineMany,
+  combineManyMut: combineManyMut,
+  fListSymbol: fListSymbol,
+  final: final$1,
+  finalSymbol: finalSymbol,
+  finalValue: finalValue,
+  flushSymbol: flushSymbol,
+  flushable: flushable,
+  getFinalValue: getFinalValue,
+  getFunctionList: getFunctionList,
+  getManyValues: getManyValues,
+  isDuplexNodeStream: isDuplexNodeStream$1,
+  isDuplexWebStream: isDuplexWebStream$1,
+  isFinalValue: isFinalValue,
+  isFlushable: isFlushable,
+  isFunctionList: isFunctionList,
+  isMany: isMany,
+  isReadableNodeStream: isReadableNodeStream$1,
+  isReadableWebStream: isReadableWebStream$1,
+  isWritableNodeStream: isWritableNodeStream$1,
+  isWritableWebStream: isWritableWebStream$1,
+  many: many,
+  manySymbol: manySymbol,
+  none: none,
+  normalizeMany: normalizeMany,
+  setFunctionList: setFunctionList,
+  stop: stop,
+  toMany: toMany
+};
+
+// @ts-self-types="./exec.d.ts"
+
+
+const next = (value, fns, index, push) => {
+  for (let i = index; ; ) {
+    if (value && typeof value.then == 'function') {
+      const ii = i;
+      return value.then(v => next(v, fns, ii, push));
+    }
+    if (value == null || value === none) return;
+    if (value === stop) throw new Stop();
+    if (isFinalValue(value)) {
+      return push(getFinalValue(value)); // emit, bypass remaining fns
+    }
+    if (isMany(value)) {
+      return nextMany(getManyValues(value), fns, i, push);
+    }
+    if (value && typeof value.next == 'function') {
+      return nextGen(value, fns, i, push);
+    }
+    if (i >= fns.length) {
+      return push(value); // terminal plain value
+    }
+    value = fns[i++](value);
+  }
+};
+
+// Iterate a many() array, threading each element. A resumable `step` stays
+// synchronous until one element returns a promise (a backpressure push, or
+// genuine async); then it suspends AT that element and resumes the remainder
+// via .then(step). Allocating one closure per actual suspension — not one per
+// element — keeps live allocation O(1) in the array length even when the
+// consumer backpressures from element 0 (the bug a per-element .then chain hit:
+// a chunk-sized many() exploded into O(N) live promises). Mirrors nextGen.
+const nextMany = (values, fns, i, push) => {
+  const step = j => {
+    for (; j < values.length; ++j) {
+      const r = next(values[j], fns, i, push);
+      if (r && typeof r.then == 'function') {
+        const jj = j;
+        return r.then(() => step(jj + 1));
+      }
+    }
+  };
+  return step(0);
+};
+
+// Iterate a generator, threading each yield. A resumable `step` keeps a sync
+// generator with a draining queue fully synchronous; it goes async only when
+// next() returns a promise (async generator) or a yield's push backpressures —
+// then resumes via .then(step).
+const nextGen = (it, fns, i, push) => {
+  const step = () => {
+    for (;;) {
+      let data = it.next();
+      if (data && typeof data.then == 'function') {
+        return data.then(d => {
+          if (d.done) return;
+          const r = next(d.value, fns, i, push);
+          return r && typeof r.then == 'function' ? r.then(step) : step();
+        });
+      }
+      if (data.done) return;
+      const r = next(data.value, fns, i, push);
+      if (r && typeof r.then == 'function') return r.then(step);
+    }
+  };
+  // Abnormal termination — a downstream stage threw (sync or rejected promise),
+  // or a push rejected (the gen bridge's consumer CANCEL) — leaves the source
+  // generator suspended at a yield, so its `finally {}` never runs and a
+  // resource-owning source (e.g. asyncBlockReader's FileHandle) leaks. Run
+  // `it.return()` to fire that finally, awaiting it for an async generator, then
+  // re-throw the ORIGINAL error. Normal completion (`data.done`) already ran the
+  // generator's own finally — don't touch it. The sync fast path stays
+  // overhead-free: a plain `try` plus one `.then(undefined, abort)` only when
+  // iteration actually suspended.
+  const abort = err => {
+    // If the source generator's own cleanup (its `finally`, fired by
+    // `it.return()`) ALSO fails, keep both errors instead of dropping the
+    // cleanup one. Combine only when `err` is a real Error — a non-Error
+    // control sentinel (e.g. gen()'s CANCEL on consumer break) must keep its
+    // identity so callers comparing against it still work.
+    const onCleanupError = cleanupErr =>
+      err instanceof Error
+        ? new AggregateError([err, cleanupErr], 'pipeline error; generator cleanup also failed')
+        : err;
+    let ret;
+    try {
+      ret = it.return ? it.return() : undefined;
+    } catch (cleanupErr) {
+      throw onCleanupError(cleanupErr);
+    }
+    if (ret && typeof ret.then == 'function') {
+      return ret.then(
+        () => {
+          throw err;
+        },
+        cleanupErr => {
+          throw onCleanupError(cleanupErr);
+        }
+      );
+    }
+    throw err;
+  };
+  let r;
+  try {
+    r = step();
+  } catch (err) {
+    return abort(err);
+  }
+  return r && typeof r.then == 'function' ? r.then(undefined, abort) : r;
+};
+
+// Flush flushable stages (called when the factory's driver receives `none`).
+// Mirrors fun.flush: each flushable's output threads through the stages after
+// it, value-or-promise chained. Resumable `step` (same shape as nextMany) keeps
+// live allocation O(1) in the number of flushable stages under backpressure.
+const flush = (fns, index, push) => {
+  const step = i => {
+    for (; i < fns.length; ++i) {
+      const f = fns[i];
+      if (!isFlushable(f)) continue;
+      const r = next(f(none), fns, i + 1, push);
+      if (r && typeof r.then == 'function') {
+        const ii = i;
+        return r.then(() => step(ii + 1));
+      }
+    }
+  };
+  return step(index);
+};
+
+// @ts-self-types="./gen.d.ts"
+
+
+// gen() builds a push→pull async-generator bridge over the shared executor
+// (exec.next / exec.flush) — ~45% faster than the recursive `async function*` it
+// replaced, whose native `yield*` delegation instantiated a nested generator per
+// many() element. See [[projects/stream-chain/design/sync-when-possible-executor]].
+const gen = (...fns) => {
+  fns = fns
+    .filter(fn => fn)
+    .flat(Infinity)
+    .map(fn => (isFunctionList(fn) ? getFunctionList(fn) : fn))
+    .flat(Infinity);
+  if (!fns.length) {
+    fns = [x => x];
+  }
+  let flushed = false;
+
+  // push→pull bridge: the shared executor drives the producer (exec.next, or
+  // exec.flush on `none`); each push parks on a promise the consumer resolves
+  // when it pulls the next value, so production stays one item ahead (bounded).
+  // A for-await `break` runs .return() → the finally rejects the parked push
+  // with CANCEL, unwinding exec; the driver swallows it (no leaked producer).
+  let g = async function* (value) {
+    if (flushed) throw Error('Call to a flushed pipe.');
+    const isFlush = value === none;
+    if (isFlush) flushed = true;
+
+    const pending = [];
+    /** @type {((value?: any) => void) | null} */
+    let wakeConsumer = null;
+    /** @type {((value?: any) => void) | null} */
+    let resolveProducer = null;
+    /** @type {((reason?: any) => void) | null} */
+    let rejectProducer = null;
+    let done = false,
+      error = null,
+      cancelled = false;
+    const CANCEL = Symbol('cancel');
+
+    const push = v => {
+      if (cancelled) throw CANCEL;
+      pending.push(v);
+      if (wakeConsumer) {
+        const w = wakeConsumer;
+        wakeConsumer = null;
+        w();
+      }
+      return new Promise((res, rej) => {
+        resolveProducer = res;
+        rejectProducer = rej;
+      });
+    };
+
+    Promise.resolve()
+      .then(() => (isFlush ? flush(fns, 0, push) : next(value, fns, 0, push)))
+      .then(
+        () => {},
+        e => {
+          if (e !== CANCEL) error = e;
+        }
+      )
+      .finally(() => {
+        done = true;
+        if (wakeConsumer) {
+          const w = wakeConsumer;
+          wakeConsumer = null;
+          w();
+        }
+      });
+
+    try {
+      for (;;) {
+        while (pending.length) {
+          const v = pending.shift();
+          if (resolveProducer) {
+            const r = resolveProducer;
+            resolveProducer = rejectProducer = null;
+            r();
+          }
+          yield v;
+        }
+        if (error) throw error;
+        if (done) return;
+        await new Promise(res => (wakeConsumer = res));
+      }
+    } finally {
+      cancelled = true;
+      if (rejectProducer) {
+        const rj = rejectProducer;
+        resolveProducer = rejectProducer = null;
+        rj(CANCEL);
+      }
+    }
+  };
 
-var src$1 = {exports: {}};
-
-var parser = {exports: {}};
-
-var src = {exports: {}};
-
-const require$2 = createRequire(import.meta.url);
-function __require$1() { return require$2("node:stream"); }
-
-var defs = {};
-
-var hasRequiredDefs;
-
-function requireDefs () {
-	if (hasRequiredDefs) return defs;
-	hasRequiredDefs = 1;
-
-	const none = Symbol.for('object-stream.none');
-	const stop = Symbol.for('object-stream.stop');
-
-	const finalSymbol = Symbol.for('object-stream.final');
-	const manySymbol = Symbol.for('object-stream.many');
-	const flushSymbol = Symbol.for('object-stream.flush');
-	const fListSymbol = Symbol.for('object-stream.fList');
-
-	const finalValue = value => ({[finalSymbol]: 1, value});
-	const many = values => ({[manySymbol]: 1, values});
-
-	const isFinalValue = o => o && o[finalSymbol] === 1;
-	const isMany = o => o && o[manySymbol] === 1;
-	const isFlushable = o => o && o[flushSymbol] === 1;
-	const isFunctionList = o => o && o[fListSymbol] === 1;
-
-	const getFinalValue = o => o.value;
-	const getManyValues = o => o.values;
-	const getFunctionList = o => o.fList;
-
-	const flushable = (write, final = null) => {
-	  const fn = final ? value => (value === none ? final() : write(value)) : write;
-	  fn[flushSymbol] = 1;
-	  return fn;
-	};
-
-	const setFunctionList = (o, fns) => {
-	  o.fList = fns;
-	  o[fListSymbol] = 1;
-	  return o;
-	};
-
-	const clearFunctionList = o => {
-	  delete o.fList;
-	  delete o[fListSymbol];
-	  return o;
-	};
-
-	class Stop extends Error {}
-
-	const toMany = value =>
-	  value === none ? many([]) : value && value[manySymbol] === 1 ? value : many([value]);
-
-	const normalizeMany = o => {
-	  if (o?.[manySymbol] === 1) {
-	    switch (o.values.length) {
-	      case 0:
-	        return none;
-	      case 1:
-	        return o.values[0];
-	    }
-	  }
-	  return o;
-	};
-
-	const combineMany = (...args) => {
-	  const values = [];
-	  for (let i = 0; i < args.length; ++i) {
-	    const a = args[i];
-	    if (a === none) continue;
-	    if (a?.[manySymbol] === 1) {
-	      values.push(...a.values);
-	    } else {
-	      values.push(a);
-	    }
-	  }
-	  return many(values);
-	};
-
-	const combineManyMut = (a, ...args) => {
-	  const values = a === none ? [] : a?.[manySymbol] === 1 ? a.values : [a];
-	  for (let i = 0; i < args.length; ++i) {
-	    const b = args[i];
-	    if (b === none) continue;
-	    if (b?.[manySymbol] === 1) {
-	      values.push(...b.values);
-	    } else {
-	      values.push(b);
-	    }
-	  }
-	  return many(values);
-	};
-
-	// old aliases
-	const final = finalValue;
-
-	defs.none = none;
-	defs.stop = stop;
-	defs.Stop = Stop;
-
-	defs.finalSymbol = finalSymbol;
-	defs.finalValue = finalValue;
-	defs.final = final;
-	defs.isFinalValue = isFinalValue;
-	defs.getFinalValue = getFinalValue;
-
-	defs.manySymbol = manySymbol;
-	defs.many = many;
-	defs.isMany = isMany;
-	defs.getManyValues = getManyValues;
-
-	defs.flushSymbol = flushSymbol;
-	defs.flushable = flushable;
-	defs.isFlushable = isFlushable;
-
-	defs.fListSymbol = fListSymbol;
-	defs.isFunctionList = isFunctionList;
-	defs.getFunctionList = getFunctionList;
-	defs.setFunctionList = setFunctionList;
-	defs.clearFunctionList = clearFunctionList;
-
-	defs.toMany = toMany;
-	defs.normalizeMany = normalizeMany;
-	defs.combineMany = combineMany;
-	defs.combineManyMut = combineManyMut;
-	return defs;
-}
+  const needToFlush = fns.some(fn => isFlushable(fn));
+  if (needToFlush) g = flushable(g);
+  return setFunctionList(g, fns);
+};
 
-var gen = {exports: {}};
-
-var hasRequiredGen;
-
-function requireGen () {
-	if (hasRequiredGen) return gen.exports;
-	hasRequiredGen = 1;
-
-	const defs = requireDefs();
-
-	const next = async function* (value, fns, index) {
-	  for (let i = index; i <= fns.length; ++i) {
-	    if (value && typeof value.then == 'function') {
-	      // thenable
-	      value = await value;
-	    }
-	    if (value === defs.none) break;
-	    if (value === defs.stop) throw new defs.Stop();
-	    if (defs.isFinalValue(value)) {
-	      yield defs.getFinalValue(value);
-	      break;
-	    }
-	    if (defs.isMany(value)) {
-	      const values = defs.getManyValues(value);
-	      if (i == fns.length) {
-	        yield* values;
-	      } else {
-	        for (let j = 0; j < values.length; ++j) {
-	          yield* next(values[j], fns, i);
-	        }
-	      }
-	      break;
-	    }
-	    if (value && typeof value.next == 'function') {
-	      // generator
-	      for (;;) {
-	        let data = value.next();
-	        if (data && typeof data.then == 'function') {
-	          data = await data;
-	        }
-	        if (data.done) break;
-	        if (i == fns.length) {
-	          yield data.value;
-	        } else {
-	          yield* next(data.value, fns, i);
-	        }
-	      }
-	      break;
-	    }
-	    if (i == fns.length) {
-	      yield value;
-	      break;
-	    }
-	    const f = fns[i];
-	    value = f(value);
-	  }
-	};
-
-	const gen$1 = (...fns) => {
-	  fns = fns
-	    .filter(fn => fn)
-	    .flat(Infinity)
-	    .map(fn => (defs.isFunctionList(fn) ? defs.getFunctionList(fn) : fn))
-	    .flat(Infinity);
-	  if (!fns.length) {
-	    fns = [x => x];
-	  }
-	  let flushed = false;
-	  let g = async function* (value) {
-	    if (flushed) throw Error('Call to a flushed pipe.');
-	    if (value !== defs.none) {
-	      for (let i = 0; i <= fns.length; ++i) {
-	        if (value && typeof value.then == 'function') {
-	          yield* next(value, fns, i);
-	          return;
-	        }
-	        if (value === defs.none) return;
-	        if (value === defs.stop) throw new defs.Stop();
-	        if (defs.isFinalValue(value)) {
-	          yield defs.getFinalValue(value);
-	          return;
-	        }
-	        if (defs.isMany(value) || (value && typeof value.next == 'function')) {
-	          yield* next(value, fns, i);
-	          return;
-	        }
-	        if (i == fns.length) {
-	          yield value;
-	          return;
-	        }
-	        value = fns[i](value);
-	      }
-	    } else {
-	      flushed = true;
-	      for (let i = 0; i < fns.length; ++i) {
-	        const f = fns[i];
-	        if (defs.isFlushable(f)) {
-	          yield* next(f(defs.none), fns, i + 1);
-	        }
-	      }
-	    }
-	  };
-	  const needToFlush = fns.some(fn => defs.isFlushable(fn));
-	  if (needToFlush) g = defs.flushable(g);
-	  return defs.setFunctionList(g, fns);
-	};
-
-	gen.exports = gen$1;
-
-	gen.exports.next = next;
-	return gen.exports;
-}
+// @ts-self-types="./asStream.d.ts"
 
-var asStream_1;
-var hasRequiredAsStream;
-
-function requireAsStream () {
-	if (hasRequiredAsStream) return asStream_1;
-	hasRequiredAsStream = 1;
-
-	const {Duplex} = __require$1();
-	const defs = requireDefs();
-
-	const asStream = (fn, options) => {
-	  if (typeof fn != 'function') throw TypeError('Only a function is accepted as the first argument');
-
-	  // pump variables
-	  let paused = Promise.resolve(),
-	    resolvePaused = null;
-	  const queue = [];
-
-	  // pause/resume
-	  const resume = () => {
-	    if (!resolvePaused) return;
-	    resolvePaused();
-	    resolvePaused = null;
-	    paused = Promise.resolve();
-	  };
-	  const pause = () => {
-	    if (resolvePaused) return;
-	    paused = new Promise(resolve => (resolvePaused = resolve));
-	  };
-
-	  const innerFns = defs.isFunctionList(fn) ? fn.fList : null;
-
-	  const applyFns = innerFns
-	    ? function apply(value, i, push) {
-	        for (;;) {
-	          if (value && typeof value.then == 'function') return value.then(v => apply(v, i, push));
-	          if (value === undefined || value === null || value === defs.none) return;
-	          if (value === defs.stop) throw new defs.Stop();
-	          if (defs.isFinalValue(value)) {
-	            push(defs.getFinalValue(value));
-	            return;
-	          }
-	          if (defs.isMany(value)) {
-	            const values = defs.getManyValues(value);
-	            if (i >= innerFns.length) {
-	              for (let j = 0; j < values.length; ++j) push(values[j]);
-	              return;
-	            }
-	            let pending;
-	            for (let j = 0; j < values.length; ++j) {
-	              if (pending) {
-	                const jj = j;
-	                pending = pending.then(() => apply(values[jj], i, push));
-	              } else {
-	                const result = apply(values[j], i, push);
-	                if (result) pending = result;
-	              }
-	            }
-	            return pending;
-	          }
-	          if (value && typeof value.next == 'function') {
-	            return (async () => {
-	              for (;;) {
-	                let data = value.next();
-	                if (data && typeof data.then == 'function') data = await data;
-	                if (data.done) break;
-	                const result = apply(data.value, i, push);
-	                if (result) await result;
-	              }
-	            })();
-	          }
-	          if (i >= innerFns.length) {
-	            push(value);
-	            return;
-	          }
-	          value = innerFns[i++](value);
-	        }
-	      }
-	    : null;
-
-	  let stopped = false;
-	  let stream = null; // will be assigned later
-
-	  // data processing
-	  const pushResults = values => {
-	    if (values && typeof values.next == 'function') {
-	      // generator
-	      queue.push(values);
-	      return;
-	    }
-	    // array
-	    queue.push(values[Symbol.iterator]());
-	  };
-	  const pump = async () => {
-	    while (queue.length) {
-	      await paused;
-	      const gen = queue[queue.length - 1];
-	      let result = gen.next();
-	      if (result && typeof result.then == 'function') {
-	        result = await result;
-	      }
-	      if (result.done) {
-	        queue.pop();
-	        continue;
-	      }
-	      let value = result.value;
-	      if (value && typeof value.then == 'function') {
-	        value = await value;
-	      }
-	      await sanitize(value);
-	    }
-	  };
-	  const sanitize = async value => {
-	    if (value === undefined || value === null || value === defs.none) return;
-	    if (value === defs.stop) throw new defs.Stop();
-
-	    if (defs.isMany(value)) {
-	      pushResults(defs.getManyValues(value));
-	      return pump();
-	    }
-
-	    if (defs.isFinalValue(value)) {
-	      // a final value is not supported, it is treated as a regular value
-	      value = defs.getFinalValue(value);
-	      return processValue(value);
-	    }
-
-	    if (!stream.push(value)) {
-	      pause();
-	    }
-	  };
-	  const processChunk = async (chunk, encoding) => {
-	    try {
-	      const value = fn(chunk, encoding);
-	      await processValue(value);
-	    } catch (error) {
-	      if (error instanceof defs.Stop) {
-	        stream.push(null);
-	        stopped = true;
-	        return;
-	      }
-	      throw error;
-	    }
-	  };
-	  const processValue = async value => {
-	    if (value && typeof value.then == 'function') {
-	      // thenable
-	      return value.then(value => processValue(value));
-	    }
-	    if (value && typeof value.next == 'function') {
-	      // generator
-	      pushResults(value);
-	      return pump();
-	    }
-	    return sanitize(value);
-	  };
-
-	  stream = new Duplex({
-	    writableObjectMode: true,
-	    readableObjectMode: true,
-	    ...options,
-	    write(chunk, encoding, callback) {
-	      if (stopped) {
-	        callback(null);
-	        return;
-	      }
-	      // fast path for gen() compositions: process inner functions directly
-	      if (applyFns) {
-	        let backpressure = false;
-	        let asyncResult;
-	        try {
-	          asyncResult = applyFns(chunk, 0, value => {
-	            if (!stream.push(value)) backpressure = true;
-	          });
-	        } catch (error) {
-	          if (error instanceof defs.Stop) {
-	            stream.push(null);
-	            stopped = true;
-	            callback(null);
-	            return;
-	          }
-	          callback(error);
-	          return;
-	        }
-	        if (asyncResult) {
-	          asyncResult.then(
-	            () => callback(null),
-	            error => {
-	              if (error instanceof defs.Stop) {
-	                stream.push(null);
-	                stopped = true;
-	                callback(null);
-	                return;
-	              }
-	              callback(error);
-	            }
-	          );
-	          return;
-	        }
-	        if (backpressure) {
-	          pause();
-	          paused.then(() => callback(null));
-	        } else {
-	          callback(null);
-	        }
-	        return;
-	      }
-	      let value;
-	      try {
-	        value = fn(chunk, encoding);
-	      } catch (error) {
-	        if (error instanceof defs.Stop) {
-	          stream.push(null);
-	          stopped = true;
-	          callback(null);
-	          return;
-	        }
-	        callback(error);
-	        return;
-	      }
-	      // sync fast path: plain value (not a promise, generator, or special)
-	      if (
-	        !(value && (typeof value.then == 'function' || typeof value.next == 'function')) &&
-	        value !== defs.stop &&
-	        !defs.isMany(value) &&
-	        !defs.isFinalValue(value)
-	      ) {
-	        if (value !== undefined && value !== null && value !== defs.none) {
-	          if (!stream.push(value)) {
-	            pause();
-	            paused.then(() => callback(null));
-	            return;
-	          }
-	        }
-	        callback(null);
-	        return;
-	      }
-	      // async slow path: promises, generators, many, finalValue, stop
-	      processValue(value).then(
-	        () => callback(null),
-	        error => {
-	          if (error instanceof defs.Stop) {
-	            stream.push(null);
-	            stopped = true;
-	            callback(null);
-	            return;
-	          }
-	          callback(error);
-	        }
-	      );
-	    },
-	    final(callback) {
-	      // fast path for gen() compositions: flush inner functions directly
-	      if (applyFns) {
-	        let backpressure = false;
-	        let asyncChain;
-	        try {
-	          const pushFn = value => {
-	            if (!stream.push(value)) backpressure = true;
-	          };
-	          for (let i = 0; i < innerFns.length; ++i) {
-	            if (defs.isFlushable(innerFns[i])) {
-	              if (asyncChain) {
-	                const ii = i;
-	                asyncChain = asyncChain.then(() =>
-	                  applyFns(innerFns[ii](defs.none), ii + 1, pushFn)
-	                );
-	              } else {
-	                const result = applyFns(innerFns[i](defs.none), i + 1, pushFn);
-	                if (result) asyncChain = result;
-	              }
-	            }
-	          }
-	        } catch (error) {
-	          if (error instanceof defs.Stop) {
-	            stream.push(null);
-	            stopped = true;
-	            callback(null);
-	            return;
-	          }
-	          callback(error);
-	          return;
-	        }
-	        if (asyncChain) {
-	          asyncChain.then(
-	            () => (stream.push(null), callback(null)),
-	            error => {
-	              if (error instanceof defs.Stop) {
-	                stopped = true;
-	                stream.push(null);
-	                callback(null);
-	                return;
-	              }
-	              callback(error);
-	            }
-	          );
-	          return;
-	        }
-	        stream.push(null);
-	        if (backpressure) {
-	          pause();
-	          paused.then(() => callback(null));
-	        } else {
-	          callback(null);
-	        }
-	        return;
-	      }
-	      if (!defs.isFlushable(fn)) {
-	        stream.push(null);
-	        callback(null);
-	        return;
-	      }
-	      processChunk(defs.none, null).then(
-	        () => {
-	          if (!stopped) stream.push(null);
-	          callback(null);
-	        },
-	        error => callback(error)
-	      );
-	    },
-	    read() {
-	      resume();
-	    }
-	  });
-
-	  return stream;
-	};
-
-	asStream_1 = asStream;
-	return asStream_1;
-}
 
-var hasRequiredSrc$1;
-
-function requireSrc$1 () {
-	if (hasRequiredSrc$1) return src.exports;
-	hasRequiredSrc$1 = 1;
-
-	const {Readable, Writable, Duplex} = __require$1();
-	const defs = requireDefs();
-	const gen = requireGen();
-	const asStream = requireAsStream();
-
-	// is*NodeStream functions taken from https://github.com/nodejs/node/blob/master/lib/internal/streams/utils.js
-	const isReadableNodeStream = obj =>
-	  obj &&
-	  typeof obj.pipe === 'function' &&
-	  typeof obj.on === 'function' &&
-	  (!obj._writableState ||
-	    (typeof obj._readableState === 'object' ? obj._readableState.readable : null) !== false) && // Duplex
-	  (!obj._writableState || obj._readableState); // Writable has .pipe.
-
-	const isWritableNodeStream = obj =>
-	  obj &&
-	  typeof obj.write === 'function' &&
-	  typeof obj.on === 'function' &&
-	  (!obj._readableState ||
-	    (typeof obj._writableState === 'object' ? obj._writableState.writable : null) !== false); // Duplex
-
-	const isDuplexNodeStream = obj =>
-	  obj &&
-	  typeof obj.pipe === 'function' &&
-	  obj._readableState &&
-	  typeof obj.on === 'function' &&
-	  typeof obj.write === 'function';
-
-	const isNodeStream = obj => {
-	  return (
-	    obj &&
-	    (obj._readableState ||
-	      obj._writableState ||
-	      (typeof obj.write === 'function' && typeof obj.on === 'function') ||
-	      (typeof obj.pipe === 'function' && typeof obj.on === 'function'))
-	  );
-	};
-
-	const isReadableWebStream = obj =>
-	  !!(
-	    obj &&
-	    !isNodeStream(obj) &&
-	    typeof obj.pipeThrough === 'function' &&
-	    typeof obj.getReader === 'function' &&
-	    typeof obj.cancel === 'function'
-	  );
-
-	const isWritableWebStream = obj =>
-	  !!(
-	    obj &&
-	    !isNodeStream(obj) &&
-	    typeof obj.getWriter === 'function' &&
-	    typeof obj.abort === 'function'
-	  );
-
-	const isDuplexWebStream = obj =>
-	  !!(
-	    obj &&
-	    !isNodeStream(obj) &&
-	    typeof obj.readable === 'object' &&
-	    typeof obj.writable === 'object'
-	  );
-
-	const groupFunctions = (output, fn, index, fns) => {
-	  if (
-	    isDuplexNodeStream(fn) ||
-	    (!index && isReadableNodeStream(fn)) ||
-	    (index === fns.length - 1 && isWritableNodeStream(fn))
-	  ) {
-	    output.push(fn);
-	    return output;
-	  }
-	  if (isDuplexWebStream(fn)) {
-	    output.push(Duplex.fromWeb(fn, {objectMode: true}));
-	    return output;
-	  }
-	  if (!index && isReadableWebStream(fn)) {
-	    output.push(Readable.fromWeb(fn, {objectMode: true}));
-	    return output;
-	  }
-	  if (index === fns.length - 1 && isWritableWebStream(fn)) {
-	    output.push(Writable.fromWeb(fn, {objectMode: true}));
-	    return output;
-	  }
-	  if (typeof fn != 'function')
-	    throw TypeError('Item #' + index + ' is not a proper stream, nor a function.');
-	  if (!output.length) output.push([]);
-	  const last = output[output.length - 1];
-	  if (Array.isArray(last)) {
-	    last.push(fn);
-	  } else {
-	    output.push([fn]);
-	  }
-	  return output;
-	};
-
-	const produceStreams = item => {
-	  if (Array.isArray(item)) {
-	    if (!item.length) return null;
-	    if (item.length == 1) return item[0] && chain.asStream(item[0]);
-	    return chain.asStream(chain.gen(...item));
-	  }
-	  return item;
-	};
-
-	const wrapFunctions = (fn, index, fns) => {
-	  if (
-	    isDuplexNodeStream(fn) ||
-	    (!index && isReadableNodeStream(fn)) ||
-	    (index === fns.length - 1 && isWritableNodeStream(fn))
-	  ) {
-	    return fn; // an acceptable stream
-	  }
-	  if (isDuplexWebStream(fn)) {
-	    return Duplex.fromWeb(fn, {objectMode: true});
-	  }
-	  if (!index && isReadableWebStream(fn)) {
-	    return Readable.fromWeb(fn, {objectMode: true});
-	  }
-	  if (index === fns.length - 1 && isWritableWebStream(fn)) {
-	    return Writable.fromWeb(fn, {objectMode: true});
-	  }
-	  if (typeof fn == 'function') return chain.asStream(fn); // a function
-	  throw TypeError('Item #' + index + ' is not a proper stream, nor a function.');
-	};
-
-	// default implementation of required stream methods
-
-	const write = (input, chunk, encoding, callback) => {
-	  let error = null;
-	  try {
-	    input.write(chunk, encoding, e => callback(e || error));
-	  } catch (e) {
-	    error = e;
-	  }
-	};
-
-	const final = (input, callback) => {
-	  let error = null;
-	  try {
-	    input.end(null, null, e => callback(e || error));
-	  } catch (e) {
-	    error = e;
-	  }
-	};
-
-	const read = output => {
-	  output.resume();
-	};
-
-	// the chain creator
-
-	const chain = (fns, options) => {
-	  if (!Array.isArray(fns) || !fns.length) {
-	    throw TypeError("Chain's first argument should be a non-empty array.");
-	  }
-
-	  fns = fns.flat(Infinity).filter(fn => fn);
-
-	  const streams = (
-	      options && options.noGrouping
-	        ? fns.map(wrapFunctions)
-	        : fns
-	            .map(fn => (defs.isFunctionList(fn) ? defs.getFunctionList(fn) : fn))
-	            .flat(Infinity)
-	            .reduce(groupFunctions, [])
-	            .map(produceStreams)
-	    ).filter(s => s),
-	    input = streams[0],
-	    output = streams.reduce((output, item) => (output && output.pipe(item)) || item);
-
-	  let stream = null; // will be assigned later
-
-	  let writeMethod = (chunk, encoding, callback) => write(input, chunk, encoding, callback),
-	    finalMethod = callback => final(input, callback),
-	    readMethod = () => read(output);
-
-	  if (!isWritableNodeStream(input)) {
-	    writeMethod = (_1, _2, callback) => callback(null);
-	    finalMethod = callback => callback(null);
-	    input.on('end', () => stream.end());
-	  }
-
-	  if (isReadableNodeStream(output)) {
-	    output.on('data', chunk => !stream.push(chunk) && output.pause());
-	    output.on('end', () => stream.push(null));
-	  } else {
-	    readMethod = () => {}; // nop
-	    output.on('finish', () => stream.push(null));
-	  }
-
-	  stream = new Duplex({
-	    writableObjectMode: true,
-	    readableObjectMode: true,
-	    ...options,
-	    readable: isReadableNodeStream(output),
-	    writable: isWritableNodeStream(input),
-	    write: writeMethod,
-	    final: finalMethod,
-	    read: readMethod
-	  });
-	  stream.streams = streams;
-	  stream.input = input;
-	  stream.output = output;
-
-	  if (!isReadableNodeStream(output)) {
-	    stream.resume();
-	  }
-
-	  // connect events
-	  if (!options || !options.skipEvents) {
-	    streams.forEach(item => item.on('error', error => stream.emit('error', error)));
-	  }
-
-	  return stream;
-	};
-
-	const dataSource = fn => {
-	  if (typeof fn == 'function') return fn;
-	  if (fn) {
-	    if (typeof fn[Symbol.asyncIterator] == 'function') return fn[Symbol.asyncIterator].bind(fn);
-	    if (typeof fn[Symbol.iterator] == 'function') return fn[Symbol.iterator].bind(fn);
-	  }
-	  throw new TypeError('The argument should be a function or an iterable object.');
-	};
-
-	src.exports = chain;
-
-	// from defs.js
-	src.exports.none = defs.none;
-	src.exports.stop = defs.stop;
-	src.exports.Stop = defs.Stop;
-
-	src.exports.finalSymbol = defs.finalSymbol;
-	src.exports.finalValue = defs.finalValue;
-	src.exports.final = defs.final;
-	src.exports.isFinalValue = defs.isFinalValue;
-	src.exports.getFinalValue = defs.getFinalValue;
-
-	src.exports.manySymbol = defs.manySymbol;
-	src.exports.many = defs.many;
-	src.exports.isMany = defs.isMany;
-	src.exports.getManyValues = defs.getManyValues;
-
-	src.exports.flushSymbol = defs.flushSymbol;
-	src.exports.flushable = defs.flushable;
-	src.exports.isFlushable = defs.isFlushable;
-
-	src.exports.fListSymbol = defs.fListSymbol;
-	src.exports.isFunctionList = defs.isFunctionList;
-	src.exports.getFunctionList = defs.getFunctionList;
-	src.exports.setFunctionList = defs.setFunctionList;
-	src.exports.clearFunctionList = defs.clearFunctionList;
-
-	src.exports.toMany = defs.toMany;
-	src.exports.normalizeMany = defs.normalizeMany;
-	src.exports.combineMany = defs.combineMany;
-	src.exports.combineManyMut = defs.combineManyMut;
-
-	src.exports.chain = chain; // for compatibility with 2.x
-	src.exports.chainUnchecked = chain; // for TypeScript to bypass type checks
-	src.exports.gen = gen;
-	src.exports.asStream = asStream;
-
-	src.exports.dataSource = dataSource;
-	return src.exports;
-}
+const asStream = (fn, options) => {
+  if (typeof fn != 'function') {
+    throw TypeError('Only a function is accepted as the first argument');
+  }
 
-var fixUtf8Stream_1;
-var hasRequiredFixUtf8Stream;
-
-function requireFixUtf8Stream () {
-	if (hasRequiredFixUtf8Stream) return fixUtf8Stream_1;
-	hasRequiredFixUtf8Stream = 1;
-
-	const {StringDecoder} = require$$0;
-
-	const {none, flushable} = requireDefs();
-
-	const fixUtf8Stream = () => {
-	  const stringDecoder = new StringDecoder();
-	  let input = '';
-	  return flushable(chunk => {
-	    if (chunk === none) {
-	      const result = input + stringDecoder.end();
-	      input = '';
-	      return result;
-	    }
-	    if (typeof chunk == 'string') {
-	      if (!input) return chunk;
-	      const result = input + chunk;
-	      input = '';
-	      return result;
-	    }
-	    if (chunk instanceof Buffer) {
-	      const result = input + stringDecoder.write(chunk);
-	      input = '';
-	      return result;
-	    }
-	    throw new TypeError('Expected a string or a Buffer');
-	  });
-	};
-
-	fixUtf8Stream_1 = fixUtf8Stream;
-	return fixUtf8Stream_1;
-}
+  const innerFns = isFunctionList(fn) ? fn.fList : null;
+
+  let stopped = false;
+  let nullPushed = false;
+  let resolvePaused = null;
+  let stream = null;
+
+  const resume = () => {
+    if (!resolvePaused) return;
+    const resolve = resolvePaused;
+    resolvePaused = null;
+    resolve();
+  };
+
+  // Idempotent: prevents 'error' from push-after-end on duplicate end signals.
+  const signalEnd = () => {
+    if (nullPushed) return;
+    nullPushed = true;
+    stream.push(null);
+  };
+
+  // After Stop / destroy, enqueue silently no-ops so producers see clean
+  // completion instead of push-after-end errors.
+  const enqueue = value => {
+    if (stopped) return;
+    if (!stream.push(value)) {
+      return new Promise(resolve => {
+        resolvePaused = resolve;
+      });
+    }
+  };
+
+  // Slow-path generator queue (preserves iterator state across re-entry) —
+  // used by the single-fn processValue path below.
+  const queue = [];
+
+  const pump = async () => {
+    while (queue.length) {
+      const g = queue[queue.length - 1];
+      let result = g.next();
+      if (result && typeof result.then == 'function') result = await result;
+      if (result.done) {
+        queue.pop();
+        continue;
+      }
+      let value = result.value;
+      if (value && typeof value.then == 'function') value = await value;
+      const r = processValue(value);
+      if (r) await r;
+    }
+  };
+
+  // Sync-when-possible single-fn path: returns undefined for plain
+  // non-backpressured paths, a Promise for promise unwrap / pump drain /
+  // backpressure await. Array-of-Many is iterated directly.
+  const processValue = value => {
+    if (value && typeof value.then == 'function') {
+      return value.then(processValue);
+    }
+    if (value == null || value === none) return;
+    if (value === stop) throw new Stop();
+    if (isMany(value)) {
+      const values = getManyValues(value);
+      let promise;
+      for (let i = 0; i < values.length; ++i) {
+        if (promise) {
+          const ii = i;
+          promise = promise.then(() => processValue(values[ii]));
+        } else {
+          const r = processValue(values[i]);
+          if (r) promise = r;
+        }
+      }
+      return promise;
+    }
+    if (isFinalValue(value)) {
+      return processValue(getFinalValue(value));
+    }
+    if (value && typeof value.next == 'function') {
+      queue.push(value);
+      return pump();
+    }
+    return enqueue(value);
+  };
+
+  const absorbStop = error => {
+    if (error instanceof Stop) {
+      stopped = true;
+      signalEnd();
+      return true;
+    }
+    return false;
+  };
+
+  const finishWrite = (callback, error) => {
+    if (!error) return callback(null);
+    if (absorbStop(error)) return callback(null);
+    callback(error);
+  };
+
+  stream = new Duplex({
+    writableObjectMode: true,
+    readableObjectMode: true,
+    ...options,
+    write(chunk, encoding, callback) {
+      if (stopped) return callback(null);
+      if (innerFns) {
+        let r;
+        try {
+          r = next(chunk, innerFns, 0, enqueue);
+        } catch (error) {
+          return finishWrite(callback, error);
+        }
+        if (r && typeof r.then == 'function') {
+          r.then(
+            () => callback(null),
+            error => finishWrite(callback, error)
+          );
+        } else {
+          callback(null); // ran fully sync — no promise, no microtask
+        }
+        return;
+      }
+      let r;
+      try {
+        r = processValue(fn(chunk, encoding));
+      } catch (error) {
+        return finishWrite(callback, error);
+      }
+      if (r) {
+        r.then(
+          () => callback(null),
+          error => finishWrite(callback, error)
+        );
+      } else {
+        callback(null);
+      }
+    },
+    final(callback) {
+      const onComplete = () => {
+        signalEnd();
+        callback(null);
+      };
+      if (innerFns) {
+        let r;
+        try {
+          r = flush(innerFns, 0, enqueue);
+        } catch (error) {
+          return finishWrite(callback, error);
+        }
+        if (r && typeof r.then == 'function') {
+          r.then(onComplete, error => finishWrite(callback, error));
+        } else {
+          onComplete();
+        }
+        return;
+      }
+      if (!isFlushable(fn)) {
+        onComplete();
+        return;
+      }
+      let r;
+      try {
+        r = processValue(fn(none, null));
+      } catch (error) {
+        return finishWrite(callback, error);
+      }
+      if (r) {
+        r.then(onComplete, error => finishWrite(callback, error));
+      } else {
+        onComplete();
+      }
+    },
+    read() {
+      resume();
+    },
+    // Unblock any pending paused-promise so an in-flight write can settle —
+    // mirrors asWebStream's controller.signal listener for writer.abort().
+    destroy(error, callback) {
+      stopped = true;
+      resume();
+      callback(error);
+    }
+  });
 
-var hasRequiredParser;
-
-function requireParser () {
-	if (hasRequiredParser) return parser.exports;
-	hasRequiredParser = 1;
-
-	const {asStream, flushable, gen, many, none} = requireSrc$1();
-	const fixUtf8Stream = requireFixUtf8Stream();
-
-	const patterns = {
-	  value1: /[\"\{\[\]\-\d]|true\b|false\b|null\b|\s{1,256}/y,
-	  string: /[^\x00-\x1f\"\\]{1,256}|\\[bfnrt\"\\\/]|\\u[\da-fA-F]{4}|\"/y,
-	  key1: /[\"\}]|\s{1,256}/y,
-	  colon: /\:|\s{1,256}/y,
-	  comma: /[\,\]\}]|\s{1,256}/y,
-	  ws: /\s{1,256}/y,
-	  numberStart: /\d/y,
-	  numberDigit: /\d{0,256}/y,
-	  numberFraction: /[\.eE]/y,
-	  numberExponent: /[eE]/y,
-	  numberExpSign: /[-+]/y
-	};
-	const MAX_PATTERN_SIZE = 16;
-
-	patterns.numberFracStart = patterns.numberExpStart = patterns.numberStart;
-	patterns.numberFracDigit = patterns.numberExpDigit = patterns.numberDigit;
-
-	const expected = {object: 'objectStop', array: 'arrayStop', '': 'done'};
-
-	const tokenStartObject = {name: 'startObject'},
-	  tokenEndObject = {name: 'endObject'},
-	  tokenStartArray = {name: 'startArray'},
-	  tokenEndArray = {name: 'endArray'},
-	  tokenStartString = {name: 'startString'},
-	  tokenEndString = {name: 'endString'},
-	  tokenStartNumber = {name: 'startNumber'},
-	  tokenEndNumber = {name: 'endNumber'},
-	  tokenStartKey = {name: 'startKey'},
-	  tokenEndKey = {name: 'endKey'},
-	  literalTokens = {
-	    true: {name: 'trueValue', value: true},
-	    false: {name: 'falseValue', value: false},
-	    null: {name: 'nullValue', value: null}
-	  };
-
-	// long hexadecimal codes: \uXXXX
-	const fromHex = s => String.fromCharCode(parseInt(s.slice(2), 16));
-
-	// short codes: \b \f \n \r \t \" \\ \/
-	const codes = {b: '\b', f: '\f', n: '\n', r: '\r', t: '\t', '"': '"', '\\': '\\', '/': '/'};
-
-	const jsonParser = options => {
-	  let packKeys = true,
-	    packStrings = true,
-	    packNumbers = true,
-	    streamKeys = true,
-	    streamStrings = true,
-	    streamNumbers = true,
-	    jsonStreaming = false;
-
-	  if (options) {
-	    'packValues' in options && (packKeys = packStrings = packNumbers = options.packValues);
-	    'packKeys' in options && (packKeys = options.packKeys);
-	    'packStrings' in options && (packStrings = options.packStrings);
-	    'packNumbers' in options && (packNumbers = options.packNumbers);
-	    'streamValues' in options && (streamKeys = streamStrings = streamNumbers = options.streamValues);
-	    'streamKeys' in options && (streamKeys = options.streamKeys);
-	    'streamStrings' in options && (streamStrings = options.streamStrings);
-	    'streamNumbers' in options && (streamNumbers = options.streamNumbers);
-	    jsonStreaming = options.jsonStreaming;
-	  }
-
-	  !packKeys && (streamKeys = true);
-	  !packStrings && (streamStrings = true);
-	  !packNumbers && (streamNumbers = true);
-
-	  let done = false,
-	    expect = jsonStreaming ? 'done' : 'value',
-	    parent = '',
-	    openNumber = false,
-	    accumulator = '',
-	    buffer = '';
-
-	  const stack = [];
-
-	  return flushable(buf => {
-	    const tokens = [];
-
-	    if (buf === none) {
-	      done = true;
-	    } else {
-	      buffer += buf;
-	    }
-
-	    let match,
-	      value,
-	      index = 0;
-
-	    main: for (;;) {
-	      switch (expect) {
-	        case 'value1':
-	        case 'value':
-	          patterns.value1.lastIndex = index;
-	          match = patterns.value1.exec(buffer);
-	          if (!match) {
-	            if (done || index + MAX_PATTERN_SIZE < buffer.length) {
-	              if (index < buffer.length) throw new Error('Parser cannot parse input: expected a value');
-	              throw new Error('Parser has expected a value');
-	            }
-	            break main; // wait for more input
-	          }
-	          value = match[0];
-	          switch (value) {
-	            case '"':
-	              if (streamStrings) tokens.push(tokenStartString);
-	              expect = 'string';
-	              break;
-	            case '{':
-	              tokens.push(tokenStartObject);
-	              stack.push(parent);
-	              parent = 'object';
-	              expect = 'key1';
-	              break;
-	            case '[':
-	              tokens.push(tokenStartArray);
-	              stack.push(parent);
-	              parent = 'array';
-	              expect = 'value1';
-	              break;
-	            case ']':
-	              if (expect !== 'value1') throw new Error("Parser cannot parse input: unexpected token ']'");
-	              if (openNumber) {
-	                if (streamNumbers) tokens.push(tokenEndNumber);
-	                openNumber = false;
-	                if (packNumbers) {
-	                  tokens.push({name: 'numberValue', value: accumulator});
-	                  accumulator = '';
-	                }
-	              }
-	              tokens.push(tokenEndArray);
-	              parent = stack.pop();
-	              expect = expected[parent];
-	              break;
-	            case '-':
-	              openNumber = true;
-	              if (streamNumbers) {
-	                tokens.push(tokenStartNumber, {name: 'numberChunk', value: '-'});
-	              }
-	              packNumbers && (accumulator = '-');
-	              expect = 'numberStart';
-	              break;
-	            case '0':
-	              openNumber = true;
-	              if (streamNumbers) {
-	                tokens.push(tokenStartNumber, {name: 'numberChunk', value: '0'});
-	              }
-	              packNumbers && (accumulator = '0');
-	              expect = 'numberFraction';
-	              break;
-	            case '1':
-	            case '2':
-	            case '3':
-	            case '4':
-	            case '5':
-	            case '6':
-	            case '7':
-	            case '8':
-	            case '9':
-	              openNumber = true;
-	              if (streamNumbers) {
-	                tokens.push(tokenStartNumber, {name: 'numberChunk', value});
-	              }
-	              packNumbers && (accumulator = value);
-	              expect = 'numberDigit';
-	              break;
-	            case 'true':
-	            case 'false':
-	            case 'null':
-	              if (buffer.length - index === value.length && !done) break main; // wait for more input
-	              tokens.push(literalTokens[value]);
-	              expect = expected[parent];
-	              break;
-	            // default: // ws
-	          }
-	          index += value.length;
-	          break;
-	        case 'keyVal':
-	        case 'string':
-	          patterns.string.lastIndex = index;
-	          match = patterns.string.exec(buffer);
-	          if (!match) {
-	            if (index < buffer.length && (done || buffer.length - index >= 6)) throw new Error('Parser cannot parse input: escaped characters');
-	            if (done) throw new Error('Parser has expected a string value');
-	            break main; // wait for more input
-	          }
-	          value = match[0];
-	          if (value === '"') {
-	            if (expect === 'keyVal') {
-	              if (streamKeys) tokens.push(tokenEndKey);
-	              if (packKeys) {
-	                tokens.push({name: 'keyValue', value: accumulator});
-	                accumulator = '';
-	              }
-	              expect = 'colon';
-	            } else {
-	              if (streamStrings) tokens.push(tokenEndString);
-	              if (packStrings) {
-	                tokens.push({name: 'stringValue', value: accumulator});
-	                accumulator = '';
-	              }
-	              expect = expected[parent];
-	            }
-	          } else if (value.length > 1 && value.charAt(0) === '\\') {
-	            const t = value.length == 2 ? codes[value.charAt(1)] : fromHex(value);
-	            if (expect === 'keyVal' ? streamKeys : streamStrings) {
-	              tokens.push({name: 'stringChunk', value: t});
-	            }
-	            if (expect === 'keyVal' ? packKeys : packStrings) {
-	              accumulator += t;
-	            }
-	          } else {
-	            if (expect === 'keyVal' ? streamKeys : streamStrings) {
-	              tokens.push({name: 'stringChunk', value});
-	            }
-	            if (expect === 'keyVal' ? packKeys : packStrings) {
-	              accumulator += value;
-	            }
-	          }
-	          index += value.length;
-	          break;
-	        case 'key1':
-	        case 'key':
-	          patterns.key1.lastIndex = index;
-	          match = patterns.key1.exec(buffer);
-	          if (!match) {
-	            if (index < buffer.length || done) throw new Error('Parser cannot parse input: expected an object key');
-	            break main; // wait for more input
-	          }
-	          value = match[0];
-	          if (value === '"') {
-	            if (streamKeys) tokens.push(tokenStartKey);
-	            expect = 'keyVal';
-	          } else if (value === '}') {
-	            if (expect !== 'key1') throw new Error("Parser cannot parse input: unexpected token '}'");
-	            tokens.push(tokenEndObject);
-	            parent = stack.pop();
-	            expect = expected[parent];
-	          }
-	          index += value.length;
-	          break;
-	        case 'colon':
-	          patterns.colon.lastIndex = index;
-	          match = patterns.colon.exec(buffer);
-	          if (!match) {
-	            if (index < buffer.length || done) throw new Error("Parser cannot parse input: expected ':'");
-	            break main; // wait for more input
-	          }
-	          value = match[0];
-	          value === ':' && (expect = 'value');
-	          index += value.length;
-	          break;
-	        case 'arrayStop':
-	        case 'objectStop':
-	          patterns.comma.lastIndex = index;
-	          match = patterns.comma.exec(buffer);
-	          if (!match) {
-	            if (index < buffer.length || done) throw new Error("Parser cannot parse input: expected ','");
-	            break main; // wait for more input
-	          }
-	          if (openNumber) {
-	            if (streamNumbers) tokens.push(tokenEndNumber);
-	            openNumber = false;
-	            if (packNumbers) {
-	              tokens.push({name: 'numberValue', value: accumulator});
-	              accumulator = '';
-	            }
-	          }
-	          value = match[0];
-	          if (value === ',') {
-	            expect = expect === 'arrayStop' ? 'value' : 'key';
-	          } else if (value === '}' || value === ']') {
-	            if (value === '}' ? expect === 'arrayStop' : expect !== 'arrayStop') {
-	              throw new Error("Parser cannot parse input: expected '" + (expect === 'arrayStop' ? ']' : '}') + "'");
-	            }
-	            tokens.push(value === '}' ? tokenEndObject : tokenEndArray);
-	            parent = stack.pop();
-	            expect = expected[parent];
-	          }
-	          index += value.length;
-	          break;
-	        // number chunks
-	        case 'numberStart': // [0-9]
-	          patterns.numberStart.lastIndex = index;
-	          match = patterns.numberStart.exec(buffer);
-	          if (!match) {
-	            if (index < buffer.length || done) throw new Error('Parser cannot parse input: expected a starting digit');
-	            break main; // wait for more input
-	          }
-	          value = match[0];
-	          if (streamNumbers) tokens.push({name: 'numberChunk', value});
-	          packNumbers && (accumulator += value);
-	          expect = value === '0' ? 'numberFraction' : 'numberDigit';
-	          index += value.length;
-	          break;
-	        case 'numberDigit': // [0-9]*
-	          patterns.numberDigit.lastIndex = index;
-	          match = patterns.numberDigit.exec(buffer);
-	          if (!match) {
-	            if (index < buffer.length || done) throw new Error('Parser cannot parse input: expected a digit');
-	            break main; // wait for more input
-	          }
-	          value = match[0];
-	          if (value) {
-	            if (streamNumbers) tokens.push({name: 'numberChunk', value});
-	            packNumbers && (accumulator += value);
-	            index += value.length;
-	          } else {
-	            if (index < buffer.length) {
-	              expect = 'numberFraction';
-	              break;
-	            }
-	            if (done) {
-	              expect = expected[parent];
-	              break;
-	            }
-	            break main; // wait for more input
-	          }
-	          break;
-	        case 'numberFraction': // [\.eE]?
-	          patterns.numberFraction.lastIndex = index;
-	          match = patterns.numberFraction.exec(buffer);
-	          if (!match) {
-	            if (index < buffer.length || done) {
-	              expect = expected[parent];
-	              break;
-	            }
-	            break main; // wait for more input
-	          }
-	          value = match[0];
-	          if (streamNumbers) tokens.push({name: 'numberChunk', value});
-	          packNumbers && (accumulator += value);
-	          expect = value === '.' ? 'numberFracStart' : 'numberExpSign';
-	          index += value.length;
-	          break;
-	        case 'numberFracStart': // [0-9]
-	          patterns.numberFracStart.lastIndex = index;
-	          match = patterns.numberFracStart.exec(buffer);
-	          if (!match) {
-	            if (index < buffer.length || done) throw new Error('Parser cannot parse input: expected a fractional part of a number');
-	            break main; // wait for more input
-	          }
-	          value = match[0];
-	          if (streamNumbers) tokens.push({name: 'numberChunk', value});
-	          packNumbers && (accumulator += value);
-	          expect = 'numberFracDigit';
-	          index += value.length;
-	          break;
-	        case 'numberFracDigit': // [0-9]*
-	          patterns.numberFracDigit.lastIndex = index;
-	          match = patterns.numberFracDigit.exec(buffer);
-	          value = match[0];
-	          if (value) {
-	            if (streamNumbers) tokens.push({name: 'numberChunk', value});
-	            packNumbers && (accumulator += value);
-	            index += value.length;
-	          } else {
-	            if (index < buffer.length) {
-	              expect = 'numberExponent';
-	              break;
-	            }
-	            if (done) {
-	              expect = expected[parent];
-	              break;
-	            }
-	            break main; // wait for more input
-	          }
-	          break;
-	        case 'numberExponent': // [eE]?
-	          patterns.numberExponent.lastIndex = index;
-	          match = patterns.numberExponent.exec(buffer);
-	          if (!match) {
-	            if (index < buffer.length) {
-	              expect = expected[parent];
-	              break;
-	            }
-	            if (done) {
-	              expect = expected[parent];
-	              break;
-	            }
-	            break main; // wait for more input
-	          }
-	          value = match[0];
-	          if (streamNumbers) tokens.push({name: 'numberChunk', value});
-	          packNumbers && (accumulator += value);
-	          expect = 'numberExpSign';
-	          index += value.length;
-	          break;
-	        case 'numberExpSign': // [-+]?
-	          patterns.numberExpSign.lastIndex = index;
-	          match = patterns.numberExpSign.exec(buffer);
-	          if (!match) {
-	            if (index < buffer.length) {
-	              expect = 'numberExpStart';
-	              break;
-	            }
-	            if (done) throw new Error('Parser has expected an exponent value of a number');
-	            break main; // wait for more input
-	          }
-	          value = match[0];
-	          if (streamNumbers) tokens.push({name: 'numberChunk', value});
-	          packNumbers && (accumulator += value);
-	          expect = 'numberExpStart';
-	          index += value.length;
-	          break;
-	        case 'numberExpStart': // [0-9]
-	          patterns.numberExpStart.lastIndex = index;
-	          match = patterns.numberExpStart.exec(buffer);
-	          if (!match) {
-	            if (index < buffer.length || done) throw new Error('Parser cannot parse input: expected an exponent part of a number');
-	            break main; // wait for more input
-	          }
-	          value = match[0];
-	          if (streamNumbers) tokens.push({name: 'numberChunk', value});
-	          packNumbers && (accumulator += value);
-	          expect = 'numberExpDigit';
-	          index += value.length;
-	          break;
-	        case 'numberExpDigit': // [0-9]*
-	          patterns.numberExpDigit.lastIndex = index;
-	          match = patterns.numberExpDigit.exec(buffer);
-	          value = match[0];
-	          if (value) {
-	            if (streamNumbers) tokens.push({name: 'numberChunk', value});
-	            packNumbers && (accumulator += value);
-	            index += value.length;
-	          } else {
-	            if (index < buffer.length || done) {
-	              expect = expected[parent];
-	              break;
-	            }
-	            break main; // wait for more input
-	          }
-	          break;
-	        case 'done':
-	          patterns.ws.lastIndex = index;
-	          match = patterns.ws.exec(buffer);
-	          if (!match) {
-	            if (index < buffer.length) {
-	              if (jsonStreaming) {
-	                if (openNumber) {
-	                  if (streamNumbers) tokens.push(tokenEndNumber);
-	                  openNumber = false;
-	                  if (packNumbers) {
-	                    tokens.push({name: 'numberValue', value: accumulator});
-	                    accumulator = '';
-	                  }
-	                }
-	                expect = 'value';
-	                break;
-	              }
-	              throw new Error('Parser cannot parse input: unexpected characters');
-	            }
-	            break main; // wait for more input
-	          }
-	          value = match[0];
-	          if (openNumber) {
-	            if (streamNumbers) tokens.push(tokenEndNumber);
-	            openNumber = false;
-	            if (packNumbers) {
-	              tokens.push({name: 'numberValue', value: accumulator});
-	              accumulator = '';
-	            }
-	          }
-	          index += value.length;
-	          break;
-	      }
-	    }
-	    if (done && openNumber) {
-	      if (streamNumbers) tokens.push(tokenEndNumber);
-	      openNumber = false;
-	      if (packNumbers) {
-	        tokens.push({name: 'numberValue', value: accumulator});
-	        accumulator = '';
-	      }
-	    }
-	    buffer = buffer.slice(index);
-	    return tokens.length ? many(tokens) : none;
-	  });
-	};
-
-	const parser$1 = options => gen(fixUtf8Stream(), jsonParser(options));
-
-	parser$1.asStream = options => asStream(parser$1(options), options);
-
-	parser.exports = parser$1;
-	parser.exports.parser = parser$1; // for backward compatibility with 1.x
-	return parser.exports;
-}
+  return stream;
+};
 
-var emit_1;
-var hasRequiredEmit;
+// @ts-self-types="./asWebStream.d.ts"
 
-function requireEmit () {
-	if (hasRequiredEmit) return emit_1;
-	hasRequiredEmit = 1;
 
-	const emit = stream => stream.on('data', item => stream.emit(item.name, item.value));
+const asWebStream = (fn, options) => {
+  if (isDuplexWebStream$1(fn) || isReadableWebStream$1(fn) || isWritableWebStream$1(fn)) {
+    return fn;
+  }
+  if (typeof fn !== 'function') {
+    throw new TypeError('Only a function or Web Streams object is accepted as the first argument');
+  }
 
-	emit_1 = emit;
-	return emit_1;
-}
+  // Web Streams' standard `QueuingStrategy` shape ({highWaterMark, size}).
+  // `strategy` is shorthand for "apply to both sides"; per-side wins.
+  const strategy = options?.strategy;
+  const readableStrategy = options?.readableStrategy ?? strategy;
+  const writableStrategy = options?.writableStrategy ?? strategy;
+
+  const innerFns = isFunctionList(fn) ? fn.fList : null;
+
+  let stopped = false;
+  let readableClosed = false;
+  let writableErrored = false;
+  let readableController;
+  let writableController;
+  let pendingDrain = null;
+
+  const unblockDrain = () => {
+    if (!pendingDrain) return;
+    const resolve = pendingDrain;
+    pendingDrain = null;
+    resolve();
+  };
+
+  // Idempotent: cancel() marks `readableClosed` because the consumer side
+  // auto-closes the controller (re-calling close() would throw).
+  const closeReadable = () => {
+    if (readableClosed) return;
+    readableClosed = true;
+    readableController.close();
+  };
+  const errorReadable = reason => {
+    if (readableClosed) return;
+    readableClosed = true;
+    readableController.error(reason);
+  };
+
+  // Mirror TransformStream: cancel on the readable side propagates to the
+  // writable as an error so the producer learns the consumer gave up.
+  const errorWritable = reason => {
+    if (writableErrored || !writableController) return;
+    writableErrored = true;
+    writableController.error(reason);
+  };
+
+  const readable = new ReadableStream(
+    {
+      start(c) {
+        readableController = c;
+      },
+      pull() {
+        unblockDrain();
+      },
+      cancel(reason) {
+        stopped = true;
+        readableClosed = true;
+        unblockDrain();
+        errorWritable(reason);
+      }
+    },
+    readableStrategy
+  );
+
+  // After cancel/abort, enqueue silently no-ops so producers see clean
+  // completion instead of TypeError from enqueue-on-closed-controller.
+  const enqueue = value => {
+    if (stopped) return;
+    readableController.enqueue(value);
+    if (readableController.desiredSize <= 0) {
+      return new Promise(resolve => {
+        pendingDrain = resolve;
+      });
+    }
+  };
+
+  // Slow-path generator queue (preserves iterator state across re-entry) —
+  // used by the single-fn processValue path below.
+  const queue = [];
+
+  const pump = async () => {
+    while (queue.length) {
+      const g = queue[queue.length - 1];
+      let result = g.next();
+      if (result && typeof result.then == 'function') result = await result;
+      if (result.done) {
+        queue.pop();
+        continue;
+      }
+      let value = result.value;
+      if (value && typeof value.then == 'function') value = await value;
+      const r = processValue(value);
+      if (r) await r;
+    }
+  };
+
+  // Sync-when-possible: returns undefined for plain non-backpressured paths,
+  // returns a Promise for promise unwrap / pump drain / backpressure await.
+  // Array-of-Many is iterated directly — no iterator allocation per Many.
+  const processValue = value => {
+    if (value && typeof value.then == 'function') {
+      return value.then(processValue);
+    }
+    if (value == null || value === none) return;
+    if (value === stop) throw new Stop();
+    if (isMany(value)) {
+      const values = getManyValues(value);
+      let promise;
+      for (let i = 0; i < values.length; ++i) {
+        if (promise) {
+          const ii = i;
+          promise = promise.then(() => processValue(values[ii]));
+        } else {
+          const r = processValue(values[i]);
+          if (r) promise = r;
+        }
+      }
+      return promise;
+    }
+    if (isFinalValue(value)) {
+      return processValue(getFinalValue(value));
+    }
+    if (value && typeof value.next == 'function') {
+      queue.push(value);
+      return pump();
+    }
+    return enqueue(value);
+  };
+
+  const absorbStop = error => {
+    if (error instanceof Stop) {
+      stopped = true;
+      return true;
+    }
+    return false;
+  };
+
+  const writable = new WritableStream(
+    {
+      // `controller.signal` aborts during writer.abort() BEFORE the sink's
+      // abort() callback runs. The spec waits for in-flight write() to
+      // settle first — so if write() is awaiting pendingDrain, we'd
+      // deadlock unless the signal listener wakes it.
+      // Optional-chained because Bun ≤1.3.14 returns `undefined` for the
+      // controller's signal (spec-required per WHATWG Streams §4.5.2 but
+      // missing in Bun's builtin — see oven-sh/bun#31156 / PR #31157).
+      // Bun loses the abort-wakeup safety net until that lands, but the
+      // normal write/close/cancel paths still work.
+      start(controller) {
+        writableController = controller;
+        controller.signal?.addEventListener('abort', () => {
+          stopped = true;
+          unblockDrain();
+        });
+      },
+      async write(chunk) {
+        if (stopped) return;
+        try {
+          if (innerFns) {
+            const r = next(chunk, innerFns, 0, enqueue);
+            if (r) await r;
+            return;
+          }
+          const r = processValue(fn(chunk));
+          if (r) await r;
+        } catch (error) {
+          if (absorbStop(error)) return;
+          // Propagate user-function errors to the readable side so downstream
+          // consumers (and pipeTo'd stages) learn — matches TransformStream.
+          errorReadable(error);
+          throw error;
+        }
+      },
+      async close() {
+        try {
+          if (!stopped) {
+            if (innerFns) {
+              const r = flush(innerFns, 0, enqueue);
+              if (r) await r;
+            } else if (isFlushable(fn)) {
+              const r = processValue(fn(none));
+              if (r) await r;
+            }
+          }
+        } catch (error) {
+          if (!absorbStop(error)) {
+            errorReadable(error);
+            throw error;
+          }
+        }
+        closeReadable();
+      },
+      abort(reason) {
+        stopped = true;
+        unblockDrain();
+        errorReadable(reason);
+      }
+    },
+    writableStrategy
+  );
+
+  return {readable, writable};
+};
+
+// @ts-self-types="./dataSource.d.ts"
+
+const dataSource = fn => {
+  if (typeof fn == 'function') return fn;
+  if (fn) {
+    if (typeof fn[Symbol.asyncIterator] == 'function') return fn[Symbol.asyncIterator].bind(fn);
+    if (typeof fn[Symbol.iterator] == 'function') return fn[Symbol.iterator].bind(fn);
+  }
+  throw new TypeError('The argument should be a function or an iterable object.');
+};
+
+// @ts-self-types="./index.d.ts"
+
+
+const {
+  isReadableWebStream,
+  isWritableWebStream,
+  isDuplexWebStream,
+  isReadableNodeStream,
+  isWritableNodeStream,
+  isDuplexNodeStream
+} = defs;
+
+const groupFunctions$1 = (output, fn, index, fns) => {
+  if (
+    isDuplexNodeStream(fn) ||
+    (!index && isReadableNodeStream(fn)) ||
+    (index === fns.length - 1 && isWritableNodeStream(fn))
+  ) {
+    output.push(fn);
+    return output;
+  }
+  if (isDuplexWebStream(fn)) {
+    output.push(Duplex.fromWeb(fn, {objectMode: true}));
+    return output;
+  }
+  if (!index && isReadableWebStream(fn)) {
+    output.push(Readable.fromWeb(fn, {objectMode: true}));
+    return output;
+  }
+  if (index === fns.length - 1 && isWritableWebStream(fn)) {
+    output.push(Writable.fromWeb(fn, {objectMode: true}));
+    return output;
+  }
+  if (typeof fn != 'function')
+    throw TypeError('Item #' + index + ' is not a proper stream, nor a function.');
+  if (!output.length) output.push([]);
+  const last = output[output.length - 1];
+  if (Array.isArray(last)) {
+    last.push(fn);
+  } else {
+    output.push([fn]);
+  }
+  return output;
+};
+
+const produceStreams = item => {
+  if (Array.isArray(item)) {
+    if (!item.length) return null;
+    if (item.length == 1) return item[0] && /** @type {any} */ (chain$2).asStream(item[0]);
+    return /** @type {any} */ (chain$2).asStream(/** @type {any} */ (chain$2).gen(...item));
+  }
+  return item;
+};
+
+const wrapFunctions = (fn, index, fns) => {
+  if (
+    isDuplexNodeStream(fn) ||
+    (!index && isReadableNodeStream(fn)) ||
+    (index === fns.length - 1 && isWritableNodeStream(fn))
+  ) {
+    return fn; // an acceptable stream
+  }
+  if (isDuplexWebStream(fn)) {
+    return Duplex.fromWeb(fn, {objectMode: true});
+  }
+  if (!index && isReadableWebStream(fn)) {
+    return Readable.fromWeb(fn, {objectMode: true});
+  }
+  if (index === fns.length - 1 && isWritableWebStream(fn)) {
+    return Writable.fromWeb(fn, {objectMode: true});
+  }
+  if (typeof fn == 'function') return /** @type {any} */ (chain$2).asStream(fn); // a function
+  throw TypeError('Item #' + index + ' is not a proper stream, nor a function.');
+};
+
+// default implementation of required stream methods
+
+const write = (input, chunk, encoding, callback) => {
+  let error = null;
+  try {
+    input.write(chunk, encoding, e => callback(e || error));
+  } catch (e) {
+    error = e;
+  }
+};
+
+const final = (input, callback) => {
+  let error = null;
+  try {
+    input.end(null, null, e => callback(e || error));
+  } catch (e) {
+    error = e;
+  }
+};
 
-var hasRequiredSrc;
+const read = output => {
+  output.resume();
+};
 
-function requireSrc () {
-	if (hasRequiredSrc) return src$1.exports;
-	hasRequiredSrc = 1;
+// the chain creator
 
-	const parser = requireParser();
-	const emit = requireEmit();
+const chain$2 = (fns, options) => {
+  if (!Array.isArray(fns) || !fns.length) {
+    throw TypeError("Chain's first argument should be a non-empty array.");
+  }
 
-	const make = options => emit(parser.asStream(options));
+  fns = fns.flat(Infinity).filter(fn => fn);
+
+  const streams = (
+      options?.noGrouping
+        ? fns.map(wrapFunctions)
+        : fns
+            .map(fn => (isFunctionList(fn) ? getFunctionList(fn) : fn))
+            .flat(Infinity)
+            .reduce(groupFunctions$1, [])
+            .map(produceStreams)
+    ).filter(s => s),
+    input = streams[0],
+    output = streams.reduce((output, item) => (output && output.pipe(item)) || item);
+
+  let stream = null; // will be assigned later
+
+  let writeMethod = (chunk, encoding, callback) => write(input, chunk, encoding, callback),
+    finalMethod = callback => final(input, callback),
+    readMethod = () => read(output);
+
+  if (!isWritableNodeStream(input)) {
+    writeMethod = (_1, _2, callback) => callback(null);
+    finalMethod = callback => callback(null);
+    input.on('end', () => stream.end());
+  }
 
-	src$1.exports = make;
-	src$1.exports.parser = parser;
-	return src$1.exports;
-}
+  if (isReadableNodeStream(output)) {
+    output.on('data', chunk => !stream.push(chunk) && output.pause());
+    output.on('end', () => stream.push(null));
+  } else {
+    readMethod = () => {}; // nop
+    output.on('finish', () => stream.push(null));
+  }
 
-var srcExports = requireSrc();
-const StreamJSON = /*@__PURE__*/getDefaultExportFromCjs(srcExports);
-
-var assembler = {exports: {}};
-
-const require$1 = createRequire(import.meta.url);
-function __require() { return require$1("node:events"); }
-
-var hasRequiredAssembler;
-
-function requireAssembler () {
-	if (hasRequiredAssembler) return assembler.exports;
-	hasRequiredAssembler = 1;
-
-	const EventEmitter = __require();
-	const {none} = requireSrc$1();
-
-	const startObject = Ctr =>
-	  function () {
-	    if (this.done) {
-	      this.done = false;
-	    } else {
-	      this.stack.push(this.current, this.key);
-	    }
-	    this.current = new Ctr();
-	    this.key = null;
-	  };
-
-	class Assembler extends EventEmitter {
-	  static connectTo(stream, options) {
-	    return new Assembler(options).connectTo(stream);
-	  }
-
-	  constructor(options) {
-	    super();
-	    this.stack = [];
-	    this.current = this.key = null;
-	    this.done = true;
-	    if (options) {
-	      this.reviver = typeof options.reviver == 'function' && options.reviver;
-	      if (this.reviver) {
-	        this.stringValue = this._saveValue = this._saveValueWithReviver;
-	      }
-	      if (options.numberAsString) {
-	        this.numberValue = this.stringValue;
-	      }
-	    }
-
-	    this.tapChain = chunk => {
-	      if (this[chunk.name]) {
-	        this[chunk.name](chunk.value);
-	        if (this.done) return this.current;
-	      }
-	      return none;
-	    };
-	  }
-
-	  connectTo(stream) {
-	    stream.on('data', chunk => {
-	      if (this[chunk.name]) {
-	        this[chunk.name](chunk.value);
-	        if (this.done) this.emit('done', this);
-	      }
-	    });
-	    return this;
-	  }
-
-	  get depth() {
-	    return (this.stack.length >> 1) + (this.done ? 0 : 1);
-	  }
-
-	  get path() {
-	    const path = [];
-	    for (let i = 0; i < this.stack.length; i += 2) {
-	      const key = this.stack[i + 1];
-	      path.push(key === null ? this.stack[i].length : key);
-	    }
-	    return path;
-	  }
-
-	  dropToLevel(level) {
-	    if (level < this.depth) {
-	      if (level > 0) {
-	        const index = (level - 1) << 1;
-	        this.current = this.stack[index];
-	        this.key = this.stack[index + 1];
-	        this.stack.splice(index);
-	      } else {
-	        this.stack = [];
-	        this.current = this.key = null;
-	        this.done = true;
-	      }
-	    }
-	    return this;
-	  }
-
-	  consume(chunk) {
-	    this[chunk.name] && this[chunk.name](chunk.value);
-	    return this;
-	  }
-
-	  keyValue(value) {
-	    this.key = value;
-	  }
-
-	  //stringValue() - aliased below to _saveValue()
-
-	  numberValue(value) {
-	    this._saveValue(parseFloat(value));
-	  }
-	  nullValue() {
-	    this._saveValue(null);
-	  }
-	  trueValue() {
-	    this._saveValue(true);
-	  }
-	  falseValue() {
-	    this._saveValue(false);
-	  }
-
-	  //startObject() - assigned below
-
-	  endObject() {
-	    if (this.stack.length) {
-	      const value = this.current;
-	      this.key = this.stack.pop();
-	      this.current = this.stack.pop();
-	      this._saveValue(value);
-	    } else {
-	      if (this.reviver) {
-	        this.current = this.reviver.call({'': this.current}, '', this.current);
-	      }
-	      this.done = true;
-	    }
-	  }
-
-	  //startArray() - assigned below
-	  //endArray() - aliased below to endObject()
-
-	  _saveValue(value) {
-	    if (this.done) {
-	      this.current = value;
-	      return;
-	    }
-	    if (this.current instanceof Array) {
-	      this.current.push(value);
-	    } else {
-	      this.current[this.key] = value;
-	      this.key = null;
-	    }
-	  }
-	  _saveValueWithReviver(value) {
-	    if (this.done) {
-	      this.current = this.reviver.call({'': value}, '', value);
-	      return;
-	    }
-	    if (this.current instanceof Array) {
-	      this.current.push(value);
-	      value = this.reviver.call(this.current, String(this.current.length - 1), value);
-	      if (value === undefined) {
-	        delete this.current[this.current.length - 1];
-	      } else {
-	        this.current[this.current.length - 1] = value;
-	      }
-	    } else {
-	      value = this.reviver.call(this.current, this.key, value);
-	      if (value !== undefined) {
-	        this.current[this.key] = value;
-	      }
-	      this.key = null;
-	    }
-	  }
-	}
-
-	Assembler.prototype.stringValue = Assembler.prototype._saveValue;
-	Assembler.prototype.startObject = startObject(Object);
-	Assembler.prototype.startArray = startObject(Array);
-	Assembler.prototype.endArray = Assembler.prototype.endObject;
-
-	assembler.exports = Assembler;
-	assembler.exports.assembler = options => new Assembler(options);
-	return assembler.exports;
+  stream = /** @type {Duplex & {streams: any[], input: any, output: any}} */ (
+    new Duplex({
+      writableObjectMode: true,
+      readableObjectMode: true,
+      ...options,
+      readable: isReadableNodeStream(output),
+      writable: isWritableNodeStream(input),
+      write: writeMethod,
+      final: finalMethod,
+      read: readMethod
+    })
+  );
+  stream.streams = streams;
+  stream.input = input;
+  stream.output = output;
+
+  if (!isReadableNodeStream(output)) {
+    stream.resume();
+  }
+
+  // connect events
+  if (!options?.skipEvents) {
+    streams.forEach(item => item.on('error', error => stream.emit('error', error)));
+  }
+
+  return stream;
+};
+
+// from defs.js
+chain$2.none = none;
+chain$2.stop = stop;
+chain$2.Stop = Stop;
+
+chain$2.finalSymbol = finalSymbol;
+chain$2.finalValue = finalValue;
+chain$2.final = final$1;
+chain$2.isFinalValue = isFinalValue;
+chain$2.getFinalValue = getFinalValue;
+
+chain$2.manySymbol = manySymbol;
+chain$2.many = many;
+chain$2.isMany = isMany;
+chain$2.getManyValues = getManyValues;
+
+chain$2.flushSymbol = flushSymbol;
+chain$2.flushable = flushable;
+chain$2.isFlushable = isFlushable;
+
+chain$2.fListSymbol = fListSymbol;
+chain$2.isFunctionList = isFunctionList;
+chain$2.getFunctionList = getFunctionList;
+chain$2.setFunctionList = setFunctionList;
+chain$2.clearFunctionList = clearFunctionList;
+
+chain$2.toMany = toMany;
+chain$2.normalizeMany = normalizeMany;
+chain$2.combineMany = combineMany;
+chain$2.combineManyMut = combineManyMut;
+
+chain$2.chain = chain$2; // for compatibility with 2.x
+chain$2.chainUnchecked = chain$2; // for TypeScript to bypass type checks
+chain$2.gen = gen;
+chain$2.asStream = asStream;
+chain$2.asWebStream = asWebStream;
+
+chain$2.dataSource = dataSource;
+
+// @ts-self-types="./fun.d.ts"
+
+
+const collect = (collect, fns) => {
+  fns = fns
+    .filter(fn => fn)
+    .flat(Infinity)
+    .map(fn => (isFunctionList(fn) ? getFunctionList(fn) : fn))
+    .flat(Infinity);
+  if (!fns.length) {
+    fns = [x => x];
+  }
+  let flushed = false;
+  let g = value => {
+    if (flushed) throw Error('Call to a flushed pipe.');
+    if (value !== none) {
+      return next(value, fns, 0, collect);
+    } else {
+      flushed = true;
+      return flush(fns, 0, collect);
+    }
+  };
+  const needToFlush = fns.some(fn => isFlushable(fn));
+  if (needToFlush) g = flushable(g);
+  return setFunctionList(g, fns);
+};
+
+const asArray = (...fns) => {
+  let results = null;
+  const f = collect(value => results.push(value), fns);
+  let g = value => {
+    results = [];
+    const pending = f(value);
+    if (pending && typeof pending.then == 'function') {
+      return pending.then(() => {
+        const r = results;
+        results = null;
+        return r;
+      });
+    }
+    const r = results;
+    results = null;
+    return r;
+  };
+  if (isFlushable(f)) g = flushable(g);
+  return setFunctionList(g, getFunctionList(f));
+};
+
+const fun = (...fns) => {
+  const f = asArray(...fns);
+  let g = value => {
+    const result = /** @type {any} */ (f(value));
+    if (result && typeof result.then == 'function') {
+      return result.then(results => many(results));
+    }
+    return many(result);
+  };
+  if (isFlushable(f)) g = flushable(g);
+  return setFunctionList(g, getFunctionList(f));
+};
+
+// @ts-self-types="./index.d.ts"
+
+
+// Group consecutive functions into arrays (mirrors /node's groupFunctions) so the
+// produceStages step can bundle each group into a single asWebStream(gen(...group))
+// call — taking asWebStream's fused-executor path (exec.next) instead of one
+// TransformStream per function.
+const groupFunctions = (output, item, index, items) => {
+  if (isDuplexWebStream$1(item)) {
+    output.push(item);
+    return output;
+  }
+  if (!index && isReadableWebStream$1(item)) {
+    output.push({readable: item, writable: null});
+    return output;
+  }
+  if (index === items.length - 1 && isWritableWebStream$1(item)) {
+    output.push({readable: null, writable: item});
+    return output;
+  }
+  if (typeof item !== 'function') {
+    throw new TypeError(`Item #${index} is not a Web Streams object or function.`);
+  }
+  if (!output.length) output.push([]);
+  const last = output[output.length - 1];
+  if (Array.isArray(last)) {
+    last.push(item);
+  } else {
+    output.push([item]);
+  }
+  return output;
+};
+
+// Factory: returns a stage-producer bound to the chain's options. Options are
+// forwarded to every newly-wrapped asWebStream stage (existing stream items
+// passed in by the user keep their own settings — chain doesn't reconfigure them).
+const makeProduceStages = options => item => {
+  if (Array.isArray(item)) {
+    if (!item.length) return null;
+    if (item.length === 1) return /** @type {any} */ (chain$1).asWebStream(item[0], options);
+    return /** @type {any} */ (chain$1).asWebStream(/** @type {any} */ (chain$1).gen(...item), options);
+  }
+  return item;
+};
+
+const chain$1 = (fns, options) => {
+  if (!Array.isArray(fns) || !fns.length) {
+    throw new TypeError("Chain's first argument should be a non-empty array.");
+  }
+
+  fns = fns
+    .flat(Infinity)
+    .filter(Boolean)
+    .map(fn => (isFunctionList(fn) ? getFunctionList(fn) : fn))
+    .flat(Infinity);
+
+  if (!fns.length) {
+    throw new TypeError("Chain's first argument is empty after flattening.");
+  }
+
+  const stages = fns
+    .reduce(groupFunctions, [])
+    .map(makeProduceStages(options))
+    .filter(s => s);
+
+  // Pipe stages together. pipeTo handles backpressure + error propagation.
+  for (let i = 0; i < stages.length - 1; ++i) {
+    const from = stages[i].readable;
+    const to = stages[i + 1].writable;
+    if (!from) {
+      throw new TypeError(`Stage #${i} has no readable side; cannot pipe to next stage.`);
+    }
+    if (!to) {
+      throw new TypeError(`Stage #${i + 1} has no writable side; cannot accept input.`);
+    }
+    from.pipeTo(to).catch(() => {});
+  }
+
+  const c = {
+    readable: stages[stages.length - 1].readable,
+    writable: stages[0].writable,
+    streams: stages,
+    input: stages[0],
+    output: stages[stages.length - 1]
+  };
+
+  return c;
+};
+
+// Override-hook + ChainOutput parity statics (mirrors /node and /core).
+chain$1.none = none;
+chain$1.stop = stop;
+chain$1.Stop = Stop;
+
+chain$1.finalSymbol = finalSymbol;
+chain$1.finalValue = finalValue;
+chain$1.final = final$1;
+chain$1.isFinalValue = isFinalValue;
+chain$1.getFinalValue = getFinalValue;
+
+chain$1.manySymbol = manySymbol;
+chain$1.many = many;
+chain$1.isMany = isMany;
+chain$1.getManyValues = getManyValues;
+
+chain$1.flushSymbol = flushSymbol;
+chain$1.flushable = flushable;
+chain$1.isFlushable = isFlushable;
+
+chain$1.fListSymbol = fListSymbol;
+chain$1.isFunctionList = isFunctionList;
+chain$1.getFunctionList = getFunctionList;
+chain$1.setFunctionList = setFunctionList;
+chain$1.clearFunctionList = clearFunctionList;
+
+chain$1.toMany = toMany;
+chain$1.normalizeMany = normalizeMany;
+chain$1.combineMany = combineMany;
+chain$1.combineManyMut = combineManyMut;
+
+chain$1.chain = chain$1;
+chain$1.chainUnchecked = chain$1;
+chain$1.gen = gen;
+chain$1.fun = fun;
+chain$1.asWebStream = asWebStream;
+chain$1.dataSource = dataSource;
+
+// @ts-self-types="./index.d.ts"
+
+
+const chain = (fns, _options) => {
+  const flat = (Array.isArray(fns) ? fns : [])
+    .flat(Infinity)
+    .filter(Boolean)
+    .map(fn => (isFunctionList(fn) ? getFunctionList(fn) : fn))
+    .flat(Infinity);
+  const g = gen(...flat);
+  const c = async function* (input) {
+    if (input == null) return;
+    if (
+      typeof input === 'string' ||
+      (input[Symbol.asyncIterator] === undefined && input[Symbol.iterator] === undefined)
+    ) {
+      yield* g(input);
+      return;
+    }
+    for await (const value of input) yield* g(value);
+  };
+  c.streams = null;
+  c.input = null;
+  c.output = null;
+  return c;
+};
+
+// Override-hook + ChainOutput parity statics (mirrors the /node entry)
+chain.none = none;
+chain.stop = stop;
+chain.Stop = Stop;
+
+chain.finalSymbol = finalSymbol;
+chain.finalValue = finalValue;
+chain.final = final$1;
+chain.isFinalValue = isFinalValue;
+chain.getFinalValue = getFinalValue;
+
+chain.manySymbol = manySymbol;
+chain.many = many;
+chain.isMany = isMany;
+chain.getManyValues = getManyValues;
+
+chain.flushSymbol = flushSymbol;
+chain.flushable = flushable;
+chain.isFlushable = isFlushable;
+
+chain.fListSymbol = fListSymbol;
+chain.isFunctionList = isFunctionList;
+chain.getFunctionList = getFunctionList;
+chain.setFunctionList = setFunctionList;
+chain.clearFunctionList = clearFunctionList;
+
+chain.toMany = toMany;
+chain.normalizeMany = normalizeMany;
+chain.combineMany = combineMany;
+chain.combineManyMut = combineManyMut;
+
+chain.chain = chain;
+chain.chainUnchecked = chain;
+chain.gen = gen;
+chain.fun = fun;
+chain.dataSource = dataSource;
+
+// @ts-self-types="./fixUtf8Stream.d.ts"
+
+
+const makeTextDecoderImpl = () => {
+  const textDecoder = new TextDecoder();
+  let input = '';
+  return flushable(chunk => {
+    if (chunk === none) {
+      const result = input + textDecoder.decode();
+      input = '';
+      return result;
+    }
+    if (typeof chunk == 'string') {
+      if (!input) return chunk;
+      const result = input + chunk;
+      input = '';
+      return result;
+    }
+    if (chunk instanceof Uint8Array) {
+      const result = input + textDecoder.decode(chunk, {stream: true});
+      input = '';
+      return result;
+    }
+    throw new TypeError('Expected a string or a Uint8Array');
+  });
+};
+
+const makeStringDecoderImpl = StringDecoder => () => {
+  const stringDecoder = new StringDecoder();
+  let input = '';
+  return flushable(chunk => {
+    if (chunk === none) {
+      const result = input + stringDecoder.end();
+      input = '';
+      return result;
+    }
+    if (typeof chunk == 'string') {
+      if (!input) return chunk;
+      const result = input + chunk;
+      input = '';
+      return result;
+    }
+    if (chunk instanceof Uint8Array) {
+      const result = input + stringDecoder.write(chunk);
+      input = '';
+      return result;
+    }
+    throw new TypeError('Expected a string or a Uint8Array');
+  });
+};
+
+// Default to TextDecoder — works in every runtime (Node, Bun, Deno, browser).
+// On Node, asynchronously upgrade to StringDecoder which is 2–4× faster on the
+// decoder hot path. Fire-and-forget: composing fixUtf8Stream() before the
+// upgrade lands yields a TextDecoder-backed stage (still correct); after, a
+// StringDecoder-backed one. Callers needing the fast path on Node can
+// `await whenReady()` before composition.
+//
+// Bun and Deno stay on TextDecoder per benchmarks: Bun is a wash, Deno
+// actively prefers TextDecoder over its node-compat StringDecoder.
+
+let impl = makeTextDecoderImpl;
+
+const isDeno = typeof globalThis['Deno'] == 'object' && globalThis['Deno']?.version;
+const isBun = typeof globalThis['Bun'] == 'object' && globalThis['Bun']?.version;
+const isNode = !isDeno && !isBun && typeof process == 'object' && process?.versions?.node;
+
+isNode
+  ? import('node:string_decoder').then(
+      ({StringDecoder}) => {
+        impl = makeStringDecoderImpl(StringDecoder);
+      },
+      () => {} // squelch — stick with TextDecoder
+    )
+  : Promise.resolve();
+
+const fixUtf8Stream = () => impl();
+
+// @ts-self-types="./parser.d.ts"
+
+
+const patterns = {
+  value1: /[\"\{\[\]\-\d]|true\b|false\b|null\b|\s{1,256}/y,
+  string: /[^\x00-\x1f\"\\]{1,256}|\\[bfnrt\"\\\/]|\\u[\da-fA-F]{4}|\"/y,
+  numberStart: /\d/y,
+  numberDigit: /\d{0,256}/y,
+  numberFraction: /[\.eE]/y,
+  numberExponent: /[eE]/y,
+  numberExpSign: /[-+]/y
+};
+const MAX_PATTERN_SIZE = 16;
+
+patterns.numberFracStart = patterns.numberExpStart = patterns.numberStart;
+patterns.numberFracDigit = patterns.numberExpDigit = patterns.numberDigit;
+
+const expected = {object: 'objectStop', array: 'arrayStop', '': 'done'};
+
+const tokenStartObject = {name: 'startObject'},
+  tokenEndObject = {name: 'endObject'},
+  tokenStartArray = {name: 'startArray'},
+  tokenEndArray = {name: 'endArray'},
+  tokenStartString = {name: 'startString'},
+  tokenEndString = {name: 'endString'},
+  tokenStartNumber = {name: 'startNumber'},
+  tokenEndNumber = {name: 'endNumber'},
+  tokenStartKey = {name: 'startKey'},
+  tokenEndKey = {name: 'endKey'},
+  literalTokens = {
+    true: {name: 'trueValue', value: true},
+    false: {name: 'falseValue', value: false},
+    null: {name: 'nullValue', value: null}
+  };
+
+// long hexadecimal codes: \uXXXX
+const fromHex = s => String.fromCharCode(parseInt(s.slice(2), 16));
+
+// short codes: \b \f \n \r \t \" \\ \/
+const codes = {b: '\b', f: '\f', n: '\n', r: '\r', t: '\t', '"': '"', '\\': '\\', '/': '/'};
+
+// ASCII code points of the JSON syntax characters (each folds to a constant at load)
+const ASCII_TAB = '\t'.charCodeAt(0),
+  ASCII_LF = '\n'.charCodeAt(0),
+  ASCII_CR = '\r'.charCodeAt(0),
+  ASCII_SPACE = ' '.charCodeAt(0),
+  ASCII_QUOTE = '"'.charCodeAt(0),
+  ASCII_BACKSLASH = '\\'.charCodeAt(0),
+  ASCII_OPEN_BRACE = '{'.charCodeAt(0),
+  ASCII_CLOSE_BRACE = '}'.charCodeAt(0),
+  ASCII_OPEN_BRACKET = '['.charCodeAt(0),
+  ASCII_CLOSE_BRACKET = ']'.charCodeAt(0),
+  ASCII_MINUS = '-'.charCodeAt(0),
+  ASCII_COLON = ':'.charCodeAt(0),
+  ASCII_COMMA = ','.charCodeAt(0),
+  ASCII_ZERO = '0'.charCodeAt(0),
+  ASCII_NINE = '9'.charCodeAt(0),
+  ASCII_UPPER_A = 'A'.charCodeAt(0),
+  ASCII_UPPER_F = 'F'.charCodeAt(0),
+  ASCII_LOWER_A = 'a'.charCodeAt(0),
+  ASCII_LOWER_F = 'f'.charCodeAt(0),
+  ASCII_LOWER_N = 'n'.charCodeAt(0),
+  ASCII_LOWER_T = 't'.charCodeAt(0),
+  ASCII_LOWER_U = 'u'.charCodeAt(0);
+
+// fast-path helpers
+// char codes that legally terminate a number lexeme: , } ] and JSON whitespace
+const TERM = [];
+for (const ch of ',}] \t\n\r') TERM[ch.charCodeAt(0)] = 1;
+const numberFull = /-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][-+]?\d+)?/y;
+const HEX = c => (c >= ASCII_ZERO && c <= ASCII_NINE) || (c >= ASCII_UPPER_A && c <= ASCII_UPPER_F) || (c >= ASCII_LOWER_A && c <= ASCII_LOWER_F);
+
+const jsonParser = options => {
+  let packKeys = true,
+    packStrings = true,
+    packNumbers = true,
+    streamKeys = true,
+    streamStrings = true,
+    streamNumbers = true,
+    jsonStreaming = false;
+
+  if (options) {
+    'packValues' in options && (packKeys = packStrings = packNumbers = options.packValues);
+    'packKeys' in options && (packKeys = options.packKeys);
+    'packStrings' in options && (packStrings = options.packStrings);
+    'packNumbers' in options && (packNumbers = options.packNumbers);
+    'streamValues' in options && (streamKeys = streamStrings = streamNumbers = options.streamValues);
+    'streamKeys' in options && (streamKeys = options.streamKeys);
+    'streamStrings' in options && (streamStrings = options.streamStrings);
+    'streamNumbers' in options && (streamNumbers = options.streamNumbers);
+    jsonStreaming = options.jsonStreaming;
+  }
+
+  !packKeys && (streamKeys = true);
+  !packStrings && (streamStrings = true);
+  !packNumbers && (streamNumbers = true);
+
+  let done = false,
+    expect = jsonStreaming ? 'done' : 'value',
+    parent = '',
+    openNumber = false,
+    accumulator = '',
+    buffer = '';
+
+  const stack = [];
+
+  return flushable(buf => {
+    const tokens = [];
+
+    if (buf === none) {
+      done = true;
+    } else {
+      buffer += buf;
+    }
+
+    let match,
+      fm,
+      s,
+      e,
+      q,
+      rs,
+      cc,
+      value,
+      index = 0;
+
+    main: for (;;) {
+      switch (expect) {
+        case 'value1':
+        case 'value': {
+          // skip whitespace
+          while (index < buffer.length) {
+            cc = buffer.charCodeAt(index);
+            if (cc === ASCII_SPACE || cc === ASCII_TAB || cc === ASCII_LF || cc === ASCII_CR) {
+              ++index;
+              continue;
+            }
+            break;
+          }
+          if (index >= buffer.length) {
+            if (done) throw new Error('Parser has expected a value');
+            break main; // wait for more input
+          }
+          cc = buffer.charCodeAt(index);
+          if (cc === ASCII_QUOTE) {
+            // string: charCodeAt whole-string scan (decodes escapes)
+            q = index + 1;
+            rs = q;
+            s = '';
+            for (;;) {
+              if (q >= buffer.length) {
+                q = -1;
+                break;
+              }
+              e = buffer.charCodeAt(q);
+              if (e === ASCII_QUOTE) {
+                s += buffer.slice(rs, q);
+                break;
+              }
+              if (e < ASCII_SPACE) {
+                q = -1;
+                break;
+              }
+              if (e === ASCII_BACKSLASH) {
+                if (q + 1 >= buffer.length) {
+                  q = -1;
+                  break;
+                }
+                cc = buffer.charCodeAt(q + 1);
+                if (cc === ASCII_LOWER_U) {
+                  if (
+                    q + 6 > buffer.length ||
+                    !(HEX(buffer.charCodeAt(q + 2)) && HEX(buffer.charCodeAt(q + 3)) && HEX(buffer.charCodeAt(q + 4)) && HEX(buffer.charCodeAt(q + 5)))
+                  ) {
+                    q = -1;
+                    break;
+                  }
+                  s += buffer.slice(rs, q) + String.fromCharCode(parseInt(buffer.slice(q + 2, q + 6), 16));
+                  q += 6;
+                } else {
+                  value = codes[buffer.charAt(q + 1)];
+                  if (value === undefined) {
+                    q = -1;
+                    break;
+                  }
+                  s += buffer.slice(rs, q) + value;
+                  q += 2;
+                }
+                rs = q;
+                continue;
+              }
+              ++q;
+            }
+            if (q >= 0) {
+              if (streamStrings) {
+                tokens.push(tokenStartString);
+                if (s) tokens.push({name: 'stringChunk', value: s});
+                tokens.push(tokenEndString);
+              }
+              if (packStrings) tokens.push({name: 'stringValue', value: s});
+              index = q + 1;
+              expect = expected[parent];
+              continue main;
+            }
+            // fall back to incremental string machine
+            if (streamStrings) tokens.push(tokenStartString);
+            expect = 'string';
+            ++index;
+            continue main;
+          }
+          if (cc === ASCII_OPEN_BRACE) {
+            tokens.push(tokenStartObject);
+            stack.push(parent);
+            parent = 'object';
+            expect = 'key1';
+            ++index;
+            continue main;
+          }
+          if (cc === ASCII_OPEN_BRACKET) {
+            tokens.push(tokenStartArray);
+            stack.push(parent);
+            parent = 'array';
+            expect = 'value1';
+            ++index;
+            continue main;
+          }
+          if (cc === ASCII_CLOSE_BRACKET) {
+            if (expect !== 'value1') throw new Error("Parser cannot parse input: unexpected token ']'");
+            tokens.push(tokenEndArray);
+            parent = stack.pop();
+            expect = expected[parent];
+            ++index;
+            continue main;
+          }
+          if (cc === ASCII_MINUS || (cc >= ASCII_ZERO && cc <= ASCII_NINE)) {
+            // number: try whole-number fast path (only with a clear terminator in buffer)
+            numberFull.lastIndex = index;
+            fm = numberFull.exec(buffer);
+            if (fm) {
+              e = index + fm[0].length;
+              if (e < buffer.length && TERM[buffer.charCodeAt(e)]) {
+                s = fm[0];
+                if (streamNumbers) tokens.push(tokenStartNumber, {name: 'numberChunk', value: s}, tokenEndNumber);
+                if (packNumbers) tokens.push({name: 'numberValue', value: s});
+                index = e;
+                expect = expected[parent];
+                continue main;
+              }
+            }
+            // fall back to incremental number machine (mirrors the value1 branches)
+            openNumber = true;
+            if (cc === ASCII_MINUS) {
+              if (streamNumbers) tokens.push(tokenStartNumber, {name: 'numberChunk', value: '-'});
+              packNumbers && (accumulator = '-');
+              expect = 'numberStart';
+            } else if (cc === ASCII_ZERO) {
+              if (streamNumbers) tokens.push(tokenStartNumber, {name: 'numberChunk', value: '0'});
+              packNumbers && (accumulator = '0');
+              expect = 'numberFraction';
+            } else {
+              s = buffer.charAt(index);
+              if (streamNumbers) tokens.push(tokenStartNumber, {name: 'numberChunk', value: s});
+              packNumbers && (accumulator = s);
+              expect = 'numberDigit';
+            }
+            ++index;
+            continue main;
+          }
+          if (cc === ASCII_LOWER_T || cc === ASCII_LOWER_F || cc === ASCII_LOWER_N) {
+            // true / false / null — reuse the value1 regex for exact \b + wait semantics
+            patterns.value1.lastIndex = index;
+            match = patterns.value1.exec(buffer);
+            if (!match) {
+              if (done || index + MAX_PATTERN_SIZE < buffer.length) {
+                throw new Error('Parser cannot parse input: expected a value');
+              }
+              break main; // wait for more input
+            }
+            value = match[0];
+            if (buffer.length - index === value.length && !done) break main; // wait for boundary
+            tokens.push(literalTokens[value]);
+            expect = expected[parent];
+            index += value.length;
+            continue main;
+          }
+          throw new Error('Parser cannot parse input: expected a value');
+        }
+        // incremental string body (escapes / long / cross-chunk)
+        case 'keyVal':
+        case 'string':
+          patterns.string.lastIndex = index;
+          match = patterns.string.exec(buffer);
+          if (!match) {
+            if (index < buffer.length && (done || buffer.length - index >= 6)) throw new Error('Parser cannot parse input: escaped characters');
+            if (done) throw new Error('Parser has expected a string value');
+            break main; // wait for more input
+          }
+          value = match[0];
+          if (value === '"') {
+            if (expect === 'keyVal') {
+              if (streamKeys) tokens.push(tokenEndKey);
+              if (packKeys) {
+                tokens.push({name: 'keyValue', value: accumulator});
+                accumulator = '';
+              }
+              expect = 'colon';
+            } else {
+              if (streamStrings) tokens.push(tokenEndString);
+              if (packStrings) {
+                tokens.push({name: 'stringValue', value: accumulator});
+                accumulator = '';
+              }
+              expect = expected[parent];
+            }
+          } else if (value.length > 1 && value.charAt(0) === '\\') {
+            const t = value.length == 2 ? codes[value.charAt(1)] : fromHex(value);
+            if (expect === 'keyVal' ? streamKeys : streamStrings) {
+              tokens.push({name: 'stringChunk', value: t});
+            }
+            if (expect === 'keyVal' ? packKeys : packStrings) {
+              accumulator += t;
+            }
+          } else {
+            if (expect === 'keyVal' ? streamKeys : streamStrings) {
+              tokens.push({name: 'stringChunk', value});
+            }
+            if (expect === 'keyVal' ? packKeys : packStrings) {
+              accumulator += value;
+            }
+          }
+          index += value.length;
+          break;
+        case 'key1':
+        case 'key': {
+          while (index < buffer.length) {
+            cc = buffer.charCodeAt(index);
+            if (cc === ASCII_SPACE || cc === ASCII_TAB || cc === ASCII_LF || cc === ASCII_CR) {
+              ++index;
+              continue;
+            }
+            break;
+          }
+          if (index >= buffer.length) {
+            if (done) throw new Error('Parser cannot parse input: expected an object key');
+            break main; // wait for more input
+          }
+          cc = buffer.charCodeAt(index);
+          if (cc === ASCII_QUOTE) {
+            // key string: charCodeAt whole-key scan (decodes escapes)
+            q = index + 1;
+            rs = q;
+            s = '';
+            for (;;) {
+              if (q >= buffer.length) {
+                q = -1;
+                break;
+              }
+              e = buffer.charCodeAt(q);
+              if (e === ASCII_QUOTE) {
+                s += buffer.slice(rs, q);
+                break;
+              }
+              if (e < ASCII_SPACE) {
+                q = -1;
+                break;
+              }
+              if (e === ASCII_BACKSLASH) {
+                if (q + 1 >= buffer.length) {
+                  q = -1;
+                  break;
+                }
+                cc = buffer.charCodeAt(q + 1);
+                if (cc === ASCII_LOWER_U) {
+                  if (
+                    q + 6 > buffer.length ||
+                    !(HEX(buffer.charCodeAt(q + 2)) && HEX(buffer.charCodeAt(q + 3)) && HEX(buffer.charCodeAt(q + 4)) && HEX(buffer.charCodeAt(q + 5)))
+                  ) {
+                    q = -1;
+                    break;
+                  }
+                  s += buffer.slice(rs, q) + String.fromCharCode(parseInt(buffer.slice(q + 2, q + 6), 16));
+                  q += 6;
+                } else {
+                  value = codes[buffer.charAt(q + 1)];
+                  if (value === undefined) {
+                    q = -1;
+                    break;
+                  }
+                  s += buffer.slice(rs, q) + value;
+                  q += 2;
+                }
+                rs = q;
+                continue;
+              }
+              ++q;
+            }
+            if (q >= 0) {
+              if (streamKeys) {
+                tokens.push(tokenStartKey);
+                if (s) tokens.push({name: 'stringChunk', value: s});
+                tokens.push(tokenEndKey);
+              }
+              if (packKeys) tokens.push({name: 'keyValue', value: s});
+              index = q + 1;
+              expect = 'colon';
+              continue main;
+            }
+            if (streamKeys) tokens.push(tokenStartKey);
+            expect = 'keyVal';
+            ++index;
+            continue main;
+          }
+          if (cc === ASCII_CLOSE_BRACE) {
+            if (expect !== 'key1') throw new Error("Parser cannot parse input: unexpected token '}'");
+            tokens.push(tokenEndObject);
+            parent = stack.pop();
+            expect = expected[parent];
+            ++index;
+            continue main;
+          }
+          throw new Error('Parser cannot parse input: expected an object key');
+        }
+        case 'colon': {
+          while (index < buffer.length) {
+            cc = buffer.charCodeAt(index);
+            if (cc === ASCII_SPACE || cc === ASCII_TAB || cc === ASCII_LF || cc === ASCII_CR) {
+              ++index;
+              continue;
+            }
+            break;
+          }
+          if (index >= buffer.length) {
+            if (done) throw new Error("Parser cannot parse input: expected ':'");
+            break main; // wait for more input
+          }
+          cc = buffer.charCodeAt(index);
+          if (cc === ASCII_COLON) {
+            expect = 'value';
+            ++index;
+            continue main;
+          }
+          throw new Error("Parser cannot parse input: expected ':'");
+        }
+        case 'arrayStop':
+        case 'objectStop': {
+          while (index < buffer.length) {
+            cc = buffer.charCodeAt(index);
+            if (cc === ASCII_SPACE || cc === ASCII_TAB || cc === ASCII_LF || cc === ASCII_CR) {
+              ++index;
+              continue;
+            }
+            break;
+          }
+          if (index >= buffer.length) {
+            if (done) throw new Error("Parser cannot parse input: expected ','");
+            break main; // wait for more input
+          }
+          if (openNumber) {
+            if (streamNumbers) tokens.push(tokenEndNumber);
+            openNumber = false;
+            if (packNumbers) {
+              tokens.push({name: 'numberValue', value: accumulator});
+              accumulator = '';
+            }
+          }
+          cc = buffer.charCodeAt(index);
+          if (cc === ASCII_COMMA) {
+            expect = expect === 'arrayStop' ? 'value' : 'key';
+            ++index;
+            continue main;
+          }
+          if (cc === ASCII_CLOSE_BRACE || cc === ASCII_CLOSE_BRACKET) {
+            if (cc === ASCII_CLOSE_BRACE ? expect === 'arrayStop' : expect !== 'arrayStop') {
+              throw new Error("Parser cannot parse input: expected '" + (expect === 'arrayStop' ? ']' : '}') + "'");
+            }
+            tokens.push(cc === ASCII_CLOSE_BRACE ? tokenEndObject : tokenEndArray);
+            parent = stack.pop();
+            expect = expected[parent];
+            ++index;
+            continue main;
+          }
+          throw new Error("Parser cannot parse input: expected ','");
+        }
+        // number chunks — cross-chunk / fallback
+        case 'numberStart': // [0-9]
+          patterns.numberStart.lastIndex = index;
+          match = patterns.numberStart.exec(buffer);
+          if (!match) {
+            if (index < buffer.length || done) throw new Error('Parser cannot parse input: expected a starting digit');
+            break main; // wait for more input
+          }
+          value = match[0];
+          if (streamNumbers) tokens.push({name: 'numberChunk', value});
+          packNumbers && (accumulator += value);
+          expect = value === '0' ? 'numberFraction' : 'numberDigit';
+          index += value.length;
+          break;
+        case 'numberDigit': // [0-9]*
+          patterns.numberDigit.lastIndex = index;
+          match = patterns.numberDigit.exec(buffer);
+          if (!match) {
+            if (index < buffer.length || done) throw new Error('Parser cannot parse input: expected a digit');
+            break main; // wait for more input
+          }
+          value = match[0];
+          if (value) {
+            if (streamNumbers) tokens.push({name: 'numberChunk', value});
+            packNumbers && (accumulator += value);
+            index += value.length;
+          } else {
+            if (index < buffer.length) {
+              expect = 'numberFraction';
+              break;
+            }
+            if (done) {
+              expect = expected[parent];
+              break;
+            }
+            break main; // wait for more input
+          }
+          break;
+        case 'numberFraction': // [\.eE]?
+          patterns.numberFraction.lastIndex = index;
+          match = patterns.numberFraction.exec(buffer);
+          if (!match) {
+            if (index < buffer.length || done) {
+              expect = expected[parent];
+              break;
+            }
+            break main; // wait for more input
+          }
+          value = match[0];
+          if (streamNumbers) tokens.push({name: 'numberChunk', value});
+          packNumbers && (accumulator += value);
+          expect = value === '.' ? 'numberFracStart' : 'numberExpSign';
+          index += value.length;
+          break;
+        case 'numberFracStart': // [0-9]
+          patterns.numberFracStart.lastIndex = index;
+          match = patterns.numberFracStart.exec(buffer);
+          if (!match) {
+            if (index < buffer.length || done) throw new Error('Parser cannot parse input: expected a fractional part of a number');
+            break main; // wait for more input
+          }
+          value = match[0];
+          if (streamNumbers) tokens.push({name: 'numberChunk', value});
+          packNumbers && (accumulator += value);
+          expect = 'numberFracDigit';
+          index += value.length;
+          break;
+        case 'numberFracDigit': // [0-9]*
+          patterns.numberFracDigit.lastIndex = index;
+          match = patterns.numberFracDigit.exec(buffer);
+          value = match[0];
+          if (value) {
+            if (streamNumbers) tokens.push({name: 'numberChunk', value});
+            packNumbers && (accumulator += value);
+            index += value.length;
+          } else {
+            if (index < buffer.length) {
+              expect = 'numberExponent';
+              break;
+            }
+            if (done) {
+              expect = expected[parent];
+              break;
+            }
+            break main; // wait for more input
+          }
+          break;
+        case 'numberExponent': // [eE]?
+          patterns.numberExponent.lastIndex = index;
+          match = patterns.numberExponent.exec(buffer);
+          if (!match) {
+            if (index < buffer.length) {
+              expect = expected[parent];
+              break;
+            }
+            if (done) {
+              expect = expected[parent];
+              break;
+            }
+            break main; // wait for more input
+          }
+          value = match[0];
+          if (streamNumbers) tokens.push({name: 'numberChunk', value});
+          packNumbers && (accumulator += value);
+          expect = 'numberExpSign';
+          index += value.length;
+          break;
+        case 'numberExpSign': // [-+]?
+          patterns.numberExpSign.lastIndex = index;
+          match = patterns.numberExpSign.exec(buffer);
+          if (!match) {
+            if (index < buffer.length) {
+              expect = 'numberExpStart';
+              break;
+            }
+            if (done) throw new Error('Parser has expected an exponent value of a number');
+            break main; // wait for more input
+          }
+          value = match[0];
+          if (streamNumbers) tokens.push({name: 'numberChunk', value});
+          packNumbers && (accumulator += value);
+          expect = 'numberExpStart';
+          index += value.length;
+          break;
+        case 'numberExpStart': // [0-9]
+          patterns.numberExpStart.lastIndex = index;
+          match = patterns.numberExpStart.exec(buffer);
+          if (!match) {
+            if (index < buffer.length || done) throw new Error('Parser cannot parse input: expected an exponent part of a number');
+            break main; // wait for more input
+          }
+          value = match[0];
+          if (streamNumbers) tokens.push({name: 'numberChunk', value});
+          packNumbers && (accumulator += value);
+          expect = 'numberExpDigit';
+          index += value.length;
+          break;
+        case 'numberExpDigit': // [0-9]*
+          patterns.numberExpDigit.lastIndex = index;
+          match = patterns.numberExpDigit.exec(buffer);
+          value = match[0];
+          if (value) {
+            if (streamNumbers) tokens.push({name: 'numberChunk', value});
+            packNumbers && (accumulator += value);
+            index += value.length;
+          } else {
+            if (index < buffer.length || done) {
+              expect = expected[parent];
+              break;
+            }
+            break main; // wait for more input
+          }
+          break;
+        case 'done': {
+          while (index < buffer.length) {
+            cc = buffer.charCodeAt(index);
+            if (cc === ASCII_SPACE || cc === ASCII_TAB || cc === ASCII_LF || cc === ASCII_CR) {
+              if (openNumber) {
+                if (streamNumbers) tokens.push(tokenEndNumber);
+                openNumber = false;
+                if (packNumbers) {
+                  tokens.push({name: 'numberValue', value: accumulator});
+                  accumulator = '';
+                }
+              }
+              ++index;
+              continue;
+            }
+            break;
+          }
+          if (index >= buffer.length) break main; // wait for more input / end
+          if (jsonStreaming) {
+            if (openNumber) {
+              if (streamNumbers) tokens.push(tokenEndNumber);
+              openNumber = false;
+              if (packNumbers) {
+                tokens.push({name: 'numberValue', value: accumulator});
+                accumulator = '';
+              }
+            }
+            expect = 'value';
+            continue main;
+          }
+          throw new Error('Parser cannot parse input: unexpected characters');
+        }
+      }
+    }
+    if (done && openNumber) {
+      if (streamNumbers) tokens.push(tokenEndNumber);
+      openNumber = false;
+      if (packNumbers) {
+        tokens.push({name: 'numberValue', value: accumulator});
+        accumulator = '';
+      }
+    }
+    buffer = buffer.slice(index);
+    return tokens.length ? many(tokens) : none;
+  });
+};
+
+const parser = options => gen(fixUtf8Stream(), jsonParser(options));
+
+parser.parser = parser; // for backward compatibility with 1.x
+
+// @ts-self-types="./parser.d.ts"
+
+
+/** @type {any} */ (parser).asStream = options => asStream(parser(options), {writableObjectMode: true, readableObjectMode: true, ...options});
+/** @type {any} */ (parser).asWebStream = options => asWebStream(parser(options), {...options});
+
+// @ts-self-types="./index.d.ts"
+
+
+parser.asStream;
+
+// @ts-self-types="./assembler.d.ts"
+
+
+const startObject = Ctr =>
+  /** @this {Assembler} */
+  function () {
+    if (this.done) {
+      this.done = false;
+    } else {
+      this.stack.push(this.current, this.key);
+    }
+    this.current = new Ctr();
+    this.key = null;
+  };
+
+class Assembler {
+  static connectTo(stream, options) {
+    return new Assembler(options).connectTo(stream);
+  }
+
+  constructor(options) {
+    this.stack = [];
+    this.current = this.key = null;
+    this.done = true;
+    this._onDone = null;
+    if (options) {
+      this.reviver = typeof options.reviver == 'function' && options.reviver;
+      if (this.reviver) {
+        this.stringValue = this._saveValue = this._saveValueWithReviver;
+      }
+      if (options.numberAsString) {
+        this.numberValue = this.stringValue;
+      }
+      if (typeof options.onDone == 'function') {
+        this._onDone = options.onDone;
+      }
+    }
+
+    this.tapChain = chunk => {
+      if (this[chunk.name]) {
+        this[chunk.name](chunk.value);
+        if (this.done) return this.current;
+      }
+      return none;
+    };
+  }
+
+  connectTo(stream) {
+    const consume = chunk => {
+      if (this[chunk.name]) {
+        this[chunk.name](chunk.value);
+        if (this.done) this._onDone?.(this);
+      }
+    };
+    if (typeof stream?.getReader === 'function') {
+      const reader = stream.getReader();
+      (async () => {
+        try {
+          for (;;) {
+            const {done, value} = await reader.read();
+            if (done) return;
+            consume(value);
+          }
+        } finally {
+          reader.releaseLock();
+        }
+      })();
+    } else {
+      stream.on('data', consume);
+    }
+    return this;
+  }
+
+  onDone(fn) {
+    this._onDone = typeof fn == 'function' ? fn : null;
+    return this;
+  }
+
+  get depth() {
+    return (this.stack.length >> 1) + (this.done ? 0 : 1);
+  }
+
+  get path() {
+    const path = [];
+    for (let i = 0; i < this.stack.length; i += 2) {
+      const key = this.stack[i + 1];
+      path.push(key === null ? this.stack[i].length : key);
+    }
+    return path;
+  }
+
+  dropToLevel(level) {
+    if (level < this.depth) {
+      if (level > 0) {
+        const index = (level - 1) << 1;
+        this.current = this.stack[index];
+        this.key = this.stack[index + 1];
+        this.stack.splice(index);
+      } else {
+        this.stack = [];
+        this.current = this.key = null;
+        this.done = true;
+      }
+    }
+    return this;
+  }
+
+  consume(chunk) {
+    this[chunk.name]?.(chunk.value);
+    return this;
+  }
+
+  keyValue(value) {
+    this.key = value;
+  }
+
+  //stringValue() - aliased below to _saveValue()
+
+  numberValue(value) {
+    this._saveValue(parseFloat(value));
+  }
+  nullValue() {
+    this._saveValue(null);
+  }
+  trueValue() {
+    this._saveValue(true);
+  }
+  falseValue() {
+    this._saveValue(false);
+  }
+
+  //startObject() - assigned below
+
+  endObject() {
+    if (this.stack.length) {
+      const value = this.current;
+      this.key = this.stack.pop();
+      this.current = this.stack.pop();
+      this._saveValue(value);
+    } else {
+      if (this.reviver) {
+        this.current = this.reviver.call({'': this.current}, '', this.current);
+      }
+      this.done = true;
+    }
+  }
+
+  //startArray() - assigned below
+  //endArray() - aliased below to endObject()
+
+  _saveValue(value) {
+    if (this.done) {
+      this.current = value;
+      return;
+    }
+    if (this.current instanceof Array) {
+      this.current.push(value);
+    } else {
+      this.current[this.key] = value;
+      this.key = null;
+    }
+  }
+  _saveValueWithReviver(value) {
+    if (this.done) {
+      this.current = this.reviver.call({'': value}, '', value);
+      return;
+    }
+    if (this.current instanceof Array) {
+      this.current.push(value);
+      value = this.reviver.call(this.current, String(this.current.length - 1), value);
+      if (value === undefined) {
+        delete this.current[this.current.length - 1];
+      } else {
+        this.current[this.current.length - 1] = value;
+      }
+    } else {
+      value = this.reviver.call(this.current, this.key, value);
+      if (value !== undefined) {
+        this.current[this.key] = value;
+      }
+      this.key = null;
+    }
+  }
 }
 
-var assemblerExports = requireAssembler();
-const Assembler = /*@__PURE__*/getDefaultExportFromCjs(assemblerExports);
+Assembler.prototype.stringValue = Assembler.prototype._saveValue;
+Assembler.prototype.startObject = startObject(Object);
+Assembler.prototype.startArray = startObject(Array);
+Assembler.prototype.endArray = Assembler.prototype.endObject;
+
+const assembler = options => new Assembler(options);
+Assembler.assembler = assembler;
 
 class JsonParseStreamError extends Error {
   constructor(message, data) {
@@ -1621,25 +2269,25 @@ class JsonParseStreamError extends Error {
 }
 function parseJsonStream(stream) {
   const assembler = new Assembler();
-  const parser = StreamJSON.parser.asStream();
+  const parser$1 = parser.asStream();
   return new Promise((resolve) => {
-    parser.on("data", (chunk) => {
+    parser$1.on("data", (chunk) => {
       assembler[chunk.name]?.(chunk.value);
     });
-    stream.pipe(parser);
-    parser.on("end", () => {
+    stream.pipe(parser$1);
+    parser$1.on("end", () => {
       resolve(assembler.current);
     });
   });
 }
 function parseJsonStreamWithConcatArrays(stream, sourceName) {
   const assembler = new Assembler();
-  const parser = StreamJSON.parser.asStream({
+  const parser$1 = parser.asStream({
     jsonStreaming: true
   });
   const values = [];
   return new Promise((resolve) => {
-    parser.on("data", (chunk) => {
+    parser$1.on("data", (chunk) => {
       assembler[chunk.name]?.(chunk.value);
       if (assembler.done) {
         if (!Array.isArray(assembler.current)) {
@@ -1650,8 +2298,8 @@ function parseJsonStreamWithConcatArrays(stream, sourceName) {
         values.push(...assembler.current);
       }
     });
-    stream.pipe(parser);
-    parser.on("end", () => {
+    stream.pipe(parser$1);
+    parser$1.on("end", () => {
       resolve(values);
     });
   });