node-modules-tools 1.4.2 → 2.0.0-beta.1

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

@@ -1,118 +1,947 @@
-import require$$0 from 'stream';
-import require$$1 from 'string_decoder';
-import require$$0$1 from 'events';
+import { createRequire } from 'node:module';
+import require$$0 from 'string_decoder';
 
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
 
-var Utf8Stream_1;
-var hasRequiredUtf8Stream;
+var src$1 = {exports: {}};
 
-function requireUtf8Stream () {
-	if (hasRequiredUtf8Stream) return Utf8Stream_1;
-	hasRequiredUtf8Stream = 1;
+var parser = {exports: {}};
 
-	const {Transform} = require$$0;
-	const {StringDecoder} = require$$1;
+var src = {exports: {}};
 
-	class Utf8Stream extends Transform {
-	  constructor(options) {
-	    super(Object.assign({}, options, {writableObjectMode: false}));
-	    this._buffer = '';
+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;
+	};
 
-	  _transform(chunk, encoding, callback) {
-	    if (typeof chunk == 'string') {
-	      this._transform = this._transformString;
+	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 {
-	      this._stringDecoder = new StringDecoder();
-	      this._transform = this._transformBuffer;
+	      values.push(a);
 	    }
-	    this._transform(chunk, encoding, callback);
 	  }
+	  return many(values);
+	};
 
-	  _transformBuffer(chunk, _, callback) {
-	    this._buffer += this._stringDecoder.write(chunk);
-	    this._processBuffer(callback);
+	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);
+	};
 
-	  _transformString(chunk, _, callback) {
-	    this._buffer += chunk.toString();
-	    this._processBuffer(callback);
-	  }
+	// 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;
 
-	  _processBuffer(callback) {
-	    if (this._buffer) {
-	      this.push(this._buffer, 'utf8');
-	      this._buffer = '';
+	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;
+}
+
+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;
 	    }
-	    callback(null);
+	    const f = fns[i];
+	    value = f(value);
 	  }
+	};
 
-	  _flushInput() {
-	    // meant to be called from _flush()
-	    if (this._stringDecoder) {
-	      this._buffer += this._stringDecoder.end();
+	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;
+}
+
+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;
+	};
 
-	  _flush(callback) {
-	    this._flushInput();
-	    this._processBuffer(callback);
+	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;
 
-	Utf8Stream_1 = Utf8Stream;
-	return Utf8Stream_1;
+	// 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;
+}
+
+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;
 }
 
-var Parser_1;
 var hasRequiredParser;
 
 function requireParser () {
-	if (hasRequiredParser) return Parser_1;
+	if (hasRequiredParser) return parser.exports;
 	hasRequiredParser = 1;
 
-	const Utf8Stream = requireUtf8Stream();
+	const {asStream, flushable, gen, many, none} = requireSrc$1();
+	const fixUtf8Stream = requireFixUtf8Stream();
 
 	const patterns = {
-	  value1: /^(?:[\"\{\[\]\-\d]|true\b|false\b|null\b|\s{1,256})/,
-	  string: /^(?:[^\x00-\x1f\"\\]{1,256}|\\[bfnrt\"\\\/]|\\u[\da-fA-F]{4}|\")/,
-	  key1: /^(?:[\"\}]|\s{1,256})/,
-	  colon: /^(?:\:|\s{1,256})/,
-	  comma: /^(?:[\,\]\}]|\s{1,256})/,
-	  ws: /^\s{1,256}/,
-	  numberStart: /^\d/,
-	  numberDigit: /^\d{0,256}/,
-	  numberFraction: /^[\.eE]/,
-	  numberExponent: /^[eE]/,
-	  numberExpSign: /^[-+]/
+	  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;
 
-	let noSticky = true;
-	try {
-	  new RegExp('.', 'y');
-	  noSticky = false;
-	} catch (e) {
-	  // suppress
-	}
-
-	!noSticky &&
-	  Object.keys(patterns).forEach(key => {
-	    let src = patterns[key].source.slice(1); // lop off ^
-	    if (src.slice(0, 3) === '(?:' && src.slice(-1) === ')') {
-	      src = src.slice(3, -1);
-	    }
-	    patterns[key] = new RegExp(src, 'y');
-	  });
-
 	patterns.numberFracStart = patterns.numberExpStart = patterns.numberStart;
 	patterns.numberFracDigit = patterns.numberExpDigit = patterns.numberDigit;
 
-	const values = {true: true, false: false, null: null},
-	  expected = {object: 'objectStop', array: 'arrayStop', '': 'done'};
+	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));
@@ -120,122 +949,113 @@ function requireParser () {
 	// short codes: \b \f \n \r \t \" \\ \/
 	const codes = {b: '\b', f: '\f', n: '\n', r: '\r', t: '\t', '"': '"', '\\': '\\', '/': '/'};
 
-	class Parser extends Utf8Stream {
-	  static make(options) {
-	    return new Parser(options);
+	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;
 	  }
 
-	  constructor(options) {
-	    super(Object.assign({}, options, {readableObjectMode: true}));
+	  !packKeys && (streamKeys = true);
+	  !packStrings && (streamStrings = true);
+	  !packNumbers && (streamNumbers = true);
 
-	    this._packKeys = this._packStrings = this._packNumbers = this._streamKeys = this._streamStrings = this._streamNumbers = true;
-	    if (options) {
-	      'packValues' in options && (this._packKeys = this._packStrings = this._packNumbers = options.packValues);
-	      'packKeys' in options && (this._packKeys = options.packKeys);
-	      'packStrings' in options && (this._packStrings = options.packStrings);
-	      'packNumbers' in options && (this._packNumbers = options.packNumbers);
-	      'streamValues' in options && (this._streamKeys = this._streamStrings = this._streamNumbers = options.streamValues);
-	      'streamKeys' in options && (this._streamKeys = options.streamKeys);
-	      'streamStrings' in options && (this._streamStrings = options.streamStrings);
-	      'streamNumbers' in options && (this._streamNumbers = options.streamNumbers);
-	      this._jsonStreaming = options.jsonStreaming;
-	    }
-	    !this._packKeys && (this._streamKeys = true);
-	    !this._packStrings && (this._streamStrings = true);
-	    !this._packNumbers && (this._streamNumbers = true);
-
-	    this._done = false;
-	    this._expect = this._jsonStreaming ? 'done' : 'value';
-	    this._stack = [];
-	    this._parent = '';
-	    this._open_number = false;
-	    this._accumulator = '';
-	  }
-
-	  _flush(callback) {
-	    this._done = true;
-	    super._flush(error => {
-	      if (error) return callback(error);
-	      if (this._open_number) {
-	        if (this._streamNumbers) {
-	          this.push({name: 'endNumber'});
-	        }
-	        this._open_number = false;
-	        if (this._packNumbers) {
-	          this.push({name: 'numberValue', value: this._accumulator});
-	          this._accumulator = '';
-	        }
-	      }
-	      callback(null);
-	    });
-	  }
+	  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;
+	    }
 
-	  _processBuffer(callback) {
 	    let match,
 	      value,
 	      index = 0;
+
 	    main: for (;;) {
-	      switch (this._expect) {
+	      switch (expect) {
 	        case 'value1':
 	        case 'value':
 	          patterns.value1.lastIndex = index;
-	          match = patterns.value1.exec(this._buffer);
+	          match = patterns.value1.exec(buffer);
 	          if (!match) {
-	            if (this._done || index + MAX_PATTERN_SIZE < this._buffer.length) {
-	              if (index < this._buffer.length) return callback(new Error('Parser cannot parse input: expected a value'));
-	              return callback(new Error('Parser has expected a value'));
+	            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 '"':
-	              this._streamStrings && this.push({name: 'startString'});
-	              this._expect = 'string';
+	              if (streamStrings) tokens.push(tokenStartString);
+	              expect = 'string';
 	              break;
 	            case '{':
-	              this.push({name: 'startObject'});
-	              this._stack.push(this._parent);
-	              this._parent = 'object';
-	              this._expect = 'key1';
+	              tokens.push(tokenStartObject);
+	              stack.push(parent);
+	              parent = 'object';
+	              expect = 'key1';
 	              break;
 	            case '[':
-	              this.push({name: 'startArray'});
-	              this._stack.push(this._parent);
-	              this._parent = 'array';
-	              this._expect = 'value1';
+	              tokens.push(tokenStartArray);
+	              stack.push(parent);
+	              parent = 'array';
+	              expect = 'value1';
 	              break;
 	            case ']':
-	              if (this._expect !== 'value1') return callback(new Error("Parser cannot parse input: unexpected token ']'"));
-	              if (this._open_number) {
-	                this._streamNumbers && this.push({name: 'endNumber'});
-	                this._open_number = false;
-	                if (this._packNumbers) {
-	                  this.push({name: 'numberValue', value: this._accumulator});
-	                  this._accumulator = '';
+	              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 = '';
 	                }
 	              }
-	              this.push({name: 'endArray'});
-	              this._parent = this._stack.pop();
-	              this._expect = expected[this._parent];
+	              tokens.push(tokenEndArray);
+	              parent = stack.pop();
+	              expect = expected[parent];
 	              break;
 	            case '-':
-	              this._open_number = true;
-	              if (this._streamNumbers) {
-	                this.push({name: 'startNumber'});
-	                this.push({name: 'numberChunk', value: '-'});
+	              openNumber = true;
+	              if (streamNumbers) {
+	                tokens.push(tokenStartNumber, {name: 'numberChunk', value: '-'});
 	              }
-	              this._packNumbers && (this._accumulator = '-');
-	              this._expect = 'numberStart';
+	              packNumbers && (accumulator = '-');
+	              expect = 'numberStart';
 	              break;
 	            case '0':
-	              this._open_number = true;
-	              if (this._streamNumbers) {
-	                this.push({name: 'startNumber'});
-	                this.push({name: 'numberChunk', value: '0'});
+	              openNumber = true;
+	              if (streamNumbers) {
+	                tokens.push(tokenStartNumber, {name: 'numberChunk', value: '0'});
 	              }
-	              this._packNumbers && (this._accumulator = '0');
-	              this._expect = 'numberFraction';
+	              packNumbers && (accumulator = '0');
+	              expect = 'numberFraction';
 	              break;
 	            case '1':
 	            case '2':
@@ -246,191 +1066,161 @@ function requireParser () {
 	            case '7':
 	            case '8':
 	            case '9':
-	              this._open_number = true;
-	              if (this._streamNumbers) {
-	                this.push({name: 'startNumber'});
-	                this.push({name: 'numberChunk', value: value});
+	              openNumber = true;
+	              if (streamNumbers) {
+	                tokens.push(tokenStartNumber, {name: 'numberChunk', value});
 	              }
-	              this._packNumbers && (this._accumulator = value);
-	              this._expect = 'numberDigit';
+	              packNumbers && (accumulator = value);
+	              expect = 'numberDigit';
 	              break;
 	            case 'true':
 	            case 'false':
 	            case 'null':
-	              if (this._buffer.length - index === value.length && !this._done) break main; // wait for more input
-	              this.push({name: value + 'Value', value: values[value]});
-	              this._expect = expected[this._parent];
+	              if (buffer.length - index === value.length && !done) break main; // wait for more input
+	              tokens.push(literalTokens[value]);
+	              expect = expected[parent];
 	              break;
 	            // default: // ws
 	          }
-	          if (noSticky) {
-	            this._buffer = this._buffer.slice(value.length);
-	          } else {
-	            index += value.length;
-	          }
+	          index += value.length;
 	          break;
 	        case 'keyVal':
 	        case 'string':
 	          patterns.string.lastIndex = index;
-	          match = patterns.string.exec(this._buffer);
+	          match = patterns.string.exec(buffer);
 	          if (!match) {
-	            if (index < this._buffer.length && (this._done || this._buffer.length - index >= 6))
-	              return callback(new Error('Parser cannot parse input: escaped characters'));
-	            if (this._done) return callback(new Error('Parser has expected a string value'));
+	            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 (this._expect === 'keyVal') {
-	              this._streamKeys && this.push({name: 'endKey'});
-	              if (this._packKeys) {
-	                this.push({name: 'keyValue', value: this._accumulator});
-	                this._accumulator = '';
+	            if (expect === 'keyVal') {
+	              if (streamKeys) tokens.push(tokenEndKey);
+	              if (packKeys) {
+	                tokens.push({name: 'keyValue', value: accumulator});
+	                accumulator = '';
 	              }
-	              this._expect = 'colon';
+	              expect = 'colon';
 	            } else {
-	              this._streamStrings && this.push({name: 'endString'});
-	              if (this._packStrings) {
-	                this.push({name: 'stringValue', value: this._accumulator});
-	                this._accumulator = '';
+	              if (streamStrings) tokens.push(tokenEndString);
+	              if (packStrings) {
+	                tokens.push({name: 'stringValue', value: accumulator});
+	                accumulator = '';
 	              }
-	              this._expect = expected[this._parent];
+	              expect = expected[parent];
 	            }
 	          } else if (value.length > 1 && value.charAt(0) === '\\') {
 	            const t = value.length == 2 ? codes[value.charAt(1)] : fromHex(value);
-	            if (this._expect === 'keyVal' ? this._streamKeys : this._streamStrings) {
-	              this.push({name: 'stringChunk', value: t});
+	            if (expect === 'keyVal' ? streamKeys : streamStrings) {
+	              tokens.push({name: 'stringChunk', value: t});
 	            }
-	            if (this._expect === 'keyVal' ? this._packKeys : this._packStrings) {
-	              this._accumulator += t;
+	            if (expect === 'keyVal' ? packKeys : packStrings) {
+	              accumulator += t;
 	            }
 	          } else {
-	            if (this._expect === 'keyVal' ? this._streamKeys : this._streamStrings) {
-	              this.push({name: 'stringChunk', value: value});
+	            if (expect === 'keyVal' ? streamKeys : streamStrings) {
+	              tokens.push({name: 'stringChunk', value});
 	            }
-	            if (this._expect === 'keyVal' ? this._packKeys : this._packStrings) {
-	              this._accumulator += value;
+	            if (expect === 'keyVal' ? packKeys : packStrings) {
+	              accumulator += value;
 	            }
 	          }
-	          if (noSticky) {
-	            this._buffer = this._buffer.slice(value.length);
-	          } else {
-	            index += value.length;
-	          }
+	          index += value.length;
 	          break;
 	        case 'key1':
 	        case 'key':
 	          patterns.key1.lastIndex = index;
-	          match = patterns.key1.exec(this._buffer);
+	          match = patterns.key1.exec(buffer);
 	          if (!match) {
-	            if (index < this._buffer.length || this._done) return callback(new Error('Parser cannot parse input: expected an object key'));
+	            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 === '"') {
-	            this._streamKeys && this.push({name: 'startKey'});
-	            this._expect = 'keyVal';
+	            if (streamKeys) tokens.push(tokenStartKey);
+	            expect = 'keyVal';
 	          } else if (value === '}') {
-	            if (this._expect !== 'key1') return callback(new Error("Parser cannot parse input: unexpected token '}'"));
-	            this.push({name: 'endObject'});
-	            this._parent = this._stack.pop();
-	            this._expect = expected[this._parent];
-	          }
-	          if (noSticky) {
-	            this._buffer = this._buffer.slice(value.length);
-	          } else {
-	            index += value.length;
+	            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(this._buffer);
+	          match = patterns.colon.exec(buffer);
 	          if (!match) {
-	            if (index < this._buffer.length || this._done) return callback(new Error("Parser cannot parse input: expected ':'"));
+	            if (index < buffer.length || done) throw new Error("Parser cannot parse input: expected ':'");
 	            break main; // wait for more input
 	          }
 	          value = match[0];
-	          value === ':' && (this._expect = 'value');
-	          if (noSticky) {
-	            this._buffer = this._buffer.slice(value.length);
-	          } else {
-	            index += value.length;
-	          }
+	          value === ':' && (expect = 'value');
+	          index += value.length;
 	          break;
 	        case 'arrayStop':
 	        case 'objectStop':
 	          patterns.comma.lastIndex = index;
-	          match = patterns.comma.exec(this._buffer);
+	          match = patterns.comma.exec(buffer);
 	          if (!match) {
-	            if (index < this._buffer.length || this._done) return callback(new Error("Parser cannot parse input: expected ','"));
+	            if (index < buffer.length || done) throw new Error("Parser cannot parse input: expected ','");
 	            break main; // wait for more input
 	          }
-	          if (this._open_number) {
-	            this._streamNumbers && this.push({name: 'endNumber'});
-	            this._open_number = false;
-	            if (this._packNumbers) {
-	              this.push({name: 'numberValue', value: this._accumulator});
-	              this._accumulator = '';
+	          if (openNumber) {
+	            if (streamNumbers) tokens.push(tokenEndNumber);
+	            openNumber = false;
+	            if (packNumbers) {
+	              tokens.push({name: 'numberValue', value: accumulator});
+	              accumulator = '';
 	            }
 	          }
 	          value = match[0];
 	          if (value === ',') {
-	            this._expect = this._expect === 'arrayStop' ? 'value' : 'key';
+	            expect = expect === 'arrayStop' ? 'value' : 'key';
 	          } else if (value === '}' || value === ']') {
-	            if (value === '}' ? this._expect === 'arrayStop' : this._expect !== 'arrayStop') {
-	              return callback(new Error("Parser cannot parse input: expected '" + (this._expect === 'arrayStop' ? ']' : '}') + "'"));
+	            if (value === '}' ? expect === 'arrayStop' : expect !== 'arrayStop') {
+	              throw new Error("Parser cannot parse input: expected '" + (expect === 'arrayStop' ? ']' : '}') + "'");
 	            }
-	            this.push({name: value === '}' ? 'endObject' : 'endArray'});
-	            this._parent = this._stack.pop();
-	            this._expect = expected[this._parent];
-	          }
-	          if (noSticky) {
-	            this._buffer = this._buffer.slice(value.length);
-	          } else {
-	            index += value.length;
+	            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(this._buffer);
+	          match = patterns.numberStart.exec(buffer);
 	          if (!match) {
-	            if (index < this._buffer.length || this._done) return callback(new Error('Parser cannot parse input: expected a starting digit'));
+	            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];
-	          this._streamNumbers && this.push({name: 'numberChunk', value: value});
-	          this._packNumbers && (this._accumulator += value);
-	          this._expect = value === '0' ? 'numberFraction' : 'numberDigit';
-	          if (noSticky) {
-	            this._buffer = this._buffer.slice(value.length);
-	          } else {
-	            index += value.length;
-	          }
+	          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(this._buffer);
+	          match = patterns.numberDigit.exec(buffer);
 	          if (!match) {
-	            if (index < this._buffer.length || this._done) return callback(new Error('Parser cannot parse input: expected a digit'));
+	            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) {
-	            this._streamNumbers && this.push({name: 'numberChunk', value: value});
-	            this._packNumbers && (this._accumulator += value);
-	            if (noSticky) {
-	              this._buffer = this._buffer.slice(value.length);
-	            } else {
-	              index += value.length;
-	            }
+	            if (streamNumbers) tokens.push({name: 'numberChunk', value});
+	            packNumbers && (accumulator += value);
+	            index += value.length;
 	          } else {
-	            if (index < this._buffer.length) {
-	              this._expect = 'numberFraction';
+	            if (index < buffer.length) {
+	              expect = 'numberFraction';
 	              break;
 	            }
-	            if (this._done) {
-	              this._expect = expected[this._parent];
+	            if (done) {
+	              expect = expected[parent];
 	              break;
 	            }
 	            break main; // wait for more input
@@ -438,60 +1228,48 @@ function requireParser () {
 	          break;
 	        case 'numberFraction': // [\.eE]?
 	          patterns.numberFraction.lastIndex = index;
-	          match = patterns.numberFraction.exec(this._buffer);
+	          match = patterns.numberFraction.exec(buffer);
 	          if (!match) {
-	            if (index < this._buffer.length || this._done) {
-	              this._expect = expected[this._parent];
+	            if (index < buffer.length || done) {
+	              expect = expected[parent];
 	              break;
 	            }
 	            break main; // wait for more input
 	          }
 	          value = match[0];
-	          this._streamNumbers && this.push({name: 'numberChunk', value: value});
-	          this._packNumbers && (this._accumulator += value);
-	          this._expect = value === '.' ? 'numberFracStart' : 'numberExpSign';
-	          if (noSticky) {
-	            this._buffer = this._buffer.slice(value.length);
-	          } else {
-	            index += value.length;
-	          }
+	          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(this._buffer);
+	          match = patterns.numberFracStart.exec(buffer);
 	          if (!match) {
-	            if (index < this._buffer.length || this._done) return callback(new Error('Parser cannot parse input: expected a fractional part of a number'));
+	            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];
-	          this._streamNumbers && this.push({name: 'numberChunk', value: value});
-	          this._packNumbers && (this._accumulator += value);
-	          this._expect = 'numberFracDigit';
-	          if (noSticky) {
-	            this._buffer = this._buffer.slice(value.length);
-	          } else {
-	            index += value.length;
-	          }
+	          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(this._buffer);
+	          match = patterns.numberFracDigit.exec(buffer);
 	          value = match[0];
 	          if (value) {
-	            this._streamNumbers && this.push({name: 'numberChunk', value: value});
-	            this._packNumbers && (this._accumulator += value);
-	            if (noSticky) {
-	              this._buffer = this._buffer.slice(value.length);
-	            } else {
-	              index += value.length;
-	            }
+	            if (streamNumbers) tokens.push({name: 'numberChunk', value});
+	            packNumbers && (accumulator += value);
+	            index += value.length;
 	          } else {
-	            if (index < this._buffer.length) {
-	              this._expect = 'numberExponent';
+	            if (index < buffer.length) {
+	              expect = 'numberExponent';
 	              break;
 	            }
-	            if (this._done) {
-	              this._expect = expected[this._parent];
+	            if (done) {
+	              expect = expected[parent];
 	              break;
 	            }
 	            break main; // wait for more input
@@ -499,81 +1277,65 @@ function requireParser () {
 	          break;
 	        case 'numberExponent': // [eE]?
 	          patterns.numberExponent.lastIndex = index;
-	          match = patterns.numberExponent.exec(this._buffer);
+	          match = patterns.numberExponent.exec(buffer);
 	          if (!match) {
-	            if (index < this._buffer.length) {
-	              this._expect = expected[this._parent];
+	            if (index < buffer.length) {
+	              expect = expected[parent];
 	              break;
 	            }
-	            if (this._done) {
-	              this._expect = 'done';
+	            if (done) {
+	              expect = expected[parent];
 	              break;
 	            }
 	            break main; // wait for more input
 	          }
 	          value = match[0];
-	          this._streamNumbers && this.push({name: 'numberChunk', value: value});
-	          this._packNumbers && (this._accumulator += value);
-	          this._expect = 'numberExpSign';
-	          if (noSticky) {
-	            this._buffer = this._buffer.slice(value.length);
-	          } else {
-	            index += value.length;
-	          }
+	          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(this._buffer);
+	          match = patterns.numberExpSign.exec(buffer);
 	          if (!match) {
-	            if (index < this._buffer.length) {
-	              this._expect = 'numberExpStart';
+	            if (index < buffer.length) {
+	              expect = 'numberExpStart';
 	              break;
 	            }
-	            if (this._done) return callback(new Error('Parser has expected an exponent value of a number'));
+	            if (done) throw new Error('Parser has expected an exponent value of a number');
 	            break main; // wait for more input
 	          }
 	          value = match[0];
-	          this._streamNumbers && this.push({name: 'numberChunk', value: value});
-	          this._packNumbers && (this._accumulator += value);
-	          this._expect = 'numberExpStart';
-	          if (noSticky) {
-	            this._buffer = this._buffer.slice(value.length);
-	          } else {
-	            index += value.length;
-	          }
+	          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(this._buffer);
+	          match = patterns.numberExpStart.exec(buffer);
 	          if (!match) {
-	            if (index < this._buffer.length || this._done) return callback(new Error('Parser cannot parse input: expected an exponent part of a number'));
+	            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];
-	          this._streamNumbers && this.push({name: 'numberChunk', value: value});
-	          this._packNumbers && (this._accumulator += value);
-	          this._expect = 'numberExpDigit';
-	          if (noSticky) {
-	            this._buffer = this._buffer.slice(value.length);
-	          } else {
-	            index += value.length;
-	          }
+	          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(this._buffer);
+	          match = patterns.numberExpDigit.exec(buffer);
 	          value = match[0];
 	          if (value) {
-	            this._streamNumbers && this.push({name: 'numberChunk', value: value});
-	            this._packNumbers && (this._accumulator += value);
-	            if (noSticky) {
-	              this._buffer = this._buffer.slice(value.length);
-	            } else {
-	              index += value.length;
-	            }
+	            if (streamNumbers) tokens.push({name: 'numberChunk', value});
+	            packNumbers && (accumulator += value);
+	            index += value.length;
 	          } else {
-	            if (index < this._buffer.length || this._done) {
-	              this._expect = expected[this._parent];
+	            if (index < buffer.length || done) {
+	              expect = expected[parent];
 	              break;
 	            }
 	            break main; // wait for more input
@@ -581,43 +1343,58 @@ function requireParser () {
 	          break;
 	        case 'done':
 	          patterns.ws.lastIndex = index;
-	          match = patterns.ws.exec(this._buffer);
+	          match = patterns.ws.exec(buffer);
 	          if (!match) {
-	            if (index < this._buffer.length) {
-	              if (this._jsonStreaming) {
-	                this._expect = 'value';
+	            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;
 	              }
-	              return callback(new Error('Parser cannot parse input: unexpected characters'));
+	              throw new Error('Parser cannot parse input: unexpected characters');
 	            }
 	            break main; // wait for more input
 	          }
 	          value = match[0];
-	          if (this._open_number) {
-	            this._streamNumbers && this.push({name: 'endNumber'});
-	            this._open_number = false;
-	            if (this._packNumbers) {
-	              this.push({name: 'numberValue', value: this._accumulator});
-	              this._accumulator = '';
+	          if (openNumber) {
+	            if (streamNumbers) tokens.push(tokenEndNumber);
+	            openNumber = false;
+	            if (packNumbers) {
+	              tokens.push({name: 'numberValue', value: accumulator});
+	              accumulator = '';
 	            }
 	          }
-	          if (noSticky) {
-	            this._buffer = this._buffer.slice(value.length);
-	          } else {
-	            index += value.length;
-	          }
+	          index += value.length;
 	          break;
 	      }
 	    }
-	    !noSticky && (this._buffer = this._buffer.slice(index));
-	    callback(null);
-	  }
-	}
-	Parser.parser = Parser.make;
-	Parser.make.Constructor = Parser;
+	    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 = Parser;
-	return Parser_1;
+	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;
 }
 
 var emit_1;
@@ -633,36 +1410,38 @@ function requireEmit () {
 	return emit_1;
 }
 
-var streamJson;
-var hasRequiredStreamJson;
+var hasRequiredSrc;
 
-function requireStreamJson () {
-	if (hasRequiredStreamJson) return streamJson;
-	hasRequiredStreamJson = 1;
+function requireSrc () {
+	if (hasRequiredSrc) return src$1.exports;
+	hasRequiredSrc = 1;
 
-	const Parser = requireParser();
+	const parser = requireParser();
 	const emit = requireEmit();
 
-	const make = options => emit(new Parser(options));
-
-	make.Parser = Parser;
-	make.parser = Parser.parser;
+	const make = options => emit(parser.asStream(options));
 
-	streamJson = make;
-	return streamJson;
+	src$1.exports = make;
+	src$1.exports.parser = parser;
+	return src$1.exports;
 }
 
-var streamJsonExports = requireStreamJson();
-const StreamJSON = /*@__PURE__*/getDefaultExportFromCjs(streamJsonExports);
+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 Assembler_1;
 var hasRequiredAssembler;
 
 function requireAssembler () {
-	if (hasRequiredAssembler) return Assembler_1;
+	if (hasRequiredAssembler) return assembler.exports;
 	hasRequiredAssembler = 1;
 
-	const EventEmitter = require$$0$1;
+	const EventEmitter = __require();
+	const {none} = requireSrc$1();
 
 	const startObject = Ctr =>
 	  function () {
@@ -694,6 +1473,14 @@ function requireAssembler () {
 	        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) {
@@ -721,7 +1508,7 @@ function requireAssembler () {
 
 	  dropToLevel(level) {
 	    if (level < this.depth) {
-	      if (level) {
+	      if (level > 0) {
 	        const index = (level - 1) << 1;
 	        this.current = this.stack[index];
 	        this.key = this.stack[index + 1];
@@ -768,6 +1555,9 @@ function requireAssembler () {
 	      this.current = this.stack.pop();
 	      this._saveValue(value);
 	    } else {
+	      if (this.reviver) {
+	        this.current = this.reviver.call({'': this.current}, '', this.current);
+	      }
 	      this.done = true;
 	    }
 	  }
@@ -778,32 +1568,34 @@ function requireAssembler () {
 	  _saveValue(value) {
 	    if (this.done) {
 	      this.current = value;
+	      return;
+	    }
+	    if (this.current instanceof Array) {
+	      this.current.push(value);
 	    } else {
-	      if (this.current instanceof Array) {
-	        this.current.push(value);
-	      } else {
-	        this.current[this.key] = value;
-	        this.key = null;
-	      }
+	      this.current[this.key] = value;
+	      this.key = null;
 	    }
 	  }
 	  _saveValueWithReviver(value) {
 	    if (this.done) {
-	      this.current = this.reviver('', value);
-	    } else {
-	      if (this.current instanceof Array) {
-	        value = this.reviver('' + this.current.length, value);
-	        this.current.push(value);
-	        if (value === undefined) {
-	          delete this.current[this.current.length - 1];
-	        }
+	      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 {
-	        value = this.reviver(this.key, value);
-	        if (value !== undefined) {
-	          this.current[this.key] = value;
-	        }
-	        this.key = null;
+	        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;
 	    }
 	  }
 	}
@@ -813,22 +1605,24 @@ function requireAssembler () {
 	Assembler.prototype.startArray = startObject(Array);
 	Assembler.prototype.endArray = Assembler.prototype.endObject;
 
-	Assembler_1 = Assembler;
-	return Assembler_1;
+	assembler.exports = Assembler;
+	assembler.exports.assembler = options => new Assembler(options);
+	return assembler.exports;
 }
 
-var AssemblerExports = requireAssembler();
-const Assembler = /*@__PURE__*/getDefaultExportFromCjs(AssemblerExports);
+var assemblerExports = requireAssembler();
+const Assembler = /*@__PURE__*/getDefaultExportFromCjs(assemblerExports);
 
 class JsonParseStreamError extends Error {
   constructor(message, data) {
     super(message);
     this.data = data;
   }
+  data;
 }
 function parseJsonStream(stream) {
   const assembler = new Assembler();
-  const parser = StreamJSON.parser();
+  const parser = StreamJSON.parser.asStream();
   return new Promise((resolve) => {
     parser.on("data", (chunk) => {
       assembler[chunk.name]?.(chunk.value);
@@ -841,7 +1635,7 @@ function parseJsonStream(stream) {
 }
 function parseJsonStreamWithConcatArrays(stream, sourceName) {
   const assembler = new Assembler();
-  const parser = StreamJSON.parser({
+  const parser = StreamJSON.parser.asStream({
     jsonStreaming: true
   });
   const values = [];