text: (function (global, factory) {
      typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
      typeof define === 'function' && define.amd ? define(factory) :
      (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.jsonExt = factory());
  }(this, (function () { 'use strict';
  
      var name = "@discoveryjs/json-ext";
      var version = "0.5.5";
      var description = "A set of utilities that extend the use of JSON";
      var keywords = [
      	"json",
      	"utils",
      	"stream",
      	"async",
      	"promise",
      	"stringify",
      	"info"
      ];
      var author = "Roman Dvornov <rdvornov@gmail.com> (https://github.com/lahmatiy)";
      var license = "MIT";
      var repository = "discoveryjs/json-ext";
      var main = "./src/index";
      var browser = {
      	"./src/stringify-stream.js": "./src/stringify-stream-browser.js",
      	"./src/text-decoder.js": "./src/text-decoder-browser.js"
      };
      var types = "./index.d.ts";
      var scripts = {
      	test: "mocha --reporter progress",
      	lint: "eslint src test",
      	"lint-and-test": "npm run lint && npm test",
      	build: "rollup --config",
      	"test:all": "npm run test:src && npm run test:dist",
      	"test:src": "npm test",
      	"test:dist": "cross-env MODE=dist npm test && cross-env MODE=dist-min npm test",
      	"build-and-test": "npm run build && npm run test:dist",
      	coverage: "nyc npm test",
      	travis: "nyc npm run lint-and-test && npm run build-and-test && npm run coveralls",
      	coveralls: "nyc report --reporter=text-lcov | coveralls",
      	prepublishOnly: "npm run build"
      };
      var dependencies = {
      };
      var devDependencies = {
      	"@rollup/plugin-commonjs": "^15.1.0",
      	"@rollup/plugin-json": "^4.1.0",
      	"@rollup/plugin-node-resolve": "^9.0.0",
      	chalk: "^4.1.0",
      	coveralls: "^3.1.0",
      	"cross-env": "^7.0.3",
      	eslint: "^7.6.0",
      	mocha: "^8.1.1",
      	nyc: "^15.1.0",
      	rollup: "^2.28.2",
      	"rollup-plugin-terser": "^7.0.2"
      };
      var engines = {
      	node: ">=10.0.0"
      };
      var files = [
      	"dist",
      	"src",
      	"index.d.ts"
      ];
      var require$$0 = {
      	name: name,
      	version: version,
      	description: description,
      	keywords: keywords,
      	author: author,
      	license: license,
      	repository: repository,
      	main: main,
      	browser: browser,
      	types: types,
      	scripts: scripts,
      	dependencies: dependencies,
      	devDependencies: devDependencies,
      	engines: engines,
      	files: files
      };
  
      const PrimitiveType = 1;
      const ObjectType = 2;
      const ArrayType = 3;
      const PromiseType = 4;
      const ReadableStringType = 5;
      const ReadableObjectType = 6;
      // https://tc39.es/ecma262/#table-json-single-character-escapes
      const escapableCharCodeSubstitution$1 = { // JSON Single Character Escape Sequences
          0x08: '\\b',
          0x09: '\\t',
          0x0a: '\\n',
          0x0c: '\\f',
          0x0d: '\\r',
          0x22: '\\\"',
          0x5c: '\\\\'
      };
  
      function isLeadingSurrogate$1(code) {
          return code >= 0xD800 && code <= 0xDBFF;
      }
  
      function isTrailingSurrogate$1(code) {
          return code >= 0xDC00 && code <= 0xDFFF;
      }
  
      function isReadableStream$1(value) {
          return (
              typeof value.pipe === 'function' &&
              typeof value._read === 'function' &&
              typeof value._readableState === 'object' && value._readableState !== null
          );
      }
  
      function replaceValue$1(holder, key, value, replacer) {
          if (value && typeof value.toJSON === 'function') {
              value = value.toJSON();
          }
  
          if (replacer !== null) {
              value = replacer.call(holder, String(key), value);
          }
  
          switch (typeof value) {
              case 'function':
              case 'symbol':
                  value = undefined;
                  break;
  
              case 'object':
                  if (value !== null) {
                      const cls = value.constructor;
                      if (cls === String || cls === Number || cls === Boolean) {
                          value = value.valueOf();
                      }
                  }
                  break;
          }
  
          return value;
      }
  
      function getTypeNative$1(value) {
          if (value === null || typeof value !== 'object') {
              return PrimitiveType;
          }
  
          if (Array.isArray(value)) {
              return ArrayType;
          }
  
          return ObjectType;
      }
  
      function getTypeAsync$1(value) {
          if (value === null || typeof value !== 'object') {
              return PrimitiveType;
          }
  
          if (typeof value.then === 'function') {
              return PromiseType;
          }
  
          if (isReadableStream$1(value)) {
              return value._readableState.objectMode ? ReadableObjectType : ReadableStringType;
          }
  
          if (Array.isArray(value)) {
              return ArrayType;
          }
  
          return ObjectType;
      }
  
      function normalizeReplacer$1(replacer) {
          if (typeof replacer === 'function') {
              return replacer;
          }
  
          if (Array.isArray(replacer)) {
              const allowlist = new Set(replacer
                  .map(item => {
                      const cls = item && item.constructor;
                      return cls === String || cls === Number ? String(item) : null;
                  })
                  .filter(item => typeof item === 'string')
              );
  
              return [...allowlist];
          }
  
          return null;
      }
  
      function normalizeSpace$1(space) {
          if (typeof space === 'number') {
              if (!Number.isFinite(space) || space < 1) {
                  return false;
              }
  
              return ' '.repeat(Math.min(space, 10));
          }
  
          if (typeof space === 'string') {
              return space.slice(0, 10) || false;
          }
  
          return false;
      }
  
      var utils = {
          escapableCharCodeSubstitution: escapableCharCodeSubstitution$1,
          isLeadingSurrogate: isLeadingSurrogate$1,
          isTrailingSurrogate: isTrailingSurrogate$1,
          type: {
              PRIMITIVE: PrimitiveType,
              PROMISE: PromiseType,
              ARRAY: ArrayType,
              OBJECT: ObjectType,
              STRING_STREAM: ReadableStringType,
              OBJECT_STREAM: ReadableObjectType
          },
  
          isReadableStream: isReadableStream$1,
          replaceValue: replaceValue$1,
          getTypeNative: getTypeNative$1,
          getTypeAsync: getTypeAsync$1,
          normalizeReplacer: normalizeReplacer$1,
          normalizeSpace: normalizeSpace$1
      };
  
      const {
          normalizeReplacer,
          normalizeSpace,
          replaceValue,
          getTypeNative,
          getTypeAsync,
          isLeadingSurrogate,
          isTrailingSurrogate,
          escapableCharCodeSubstitution,
          type: {
              PRIMITIVE,
              OBJECT,
              ARRAY,
              PROMISE,
              STRING_STREAM,
              OBJECT_STREAM
          }
      } = utils;
      const charLength2048 = Array.from({ length: 2048 }).map((_, code) => {
          if (escapableCharCodeSubstitution.hasOwnProperty(code)) {
              return 2; // \X
          }
  
          if (code < 0x20) {
              return 6; // \uXXXX
          }
  
          return code < 128 ? 1 : 2; // UTF8 bytes
      });
  
      function stringLength(str) {
          let len = 0;
          let prevLeadingSurrogate = false;
  
          for (let i = 0; i < str.length; i++) {
              const code = str.charCodeAt(i);
  
              if (code < 2048) {
                  len += charLength2048[code];
              } else if (isLeadingSurrogate(code)) {
                  len += 6; // \uXXXX since no pair with trailing surrogate yet
                  prevLeadingSurrogate = true;
                  continue;
              } else if (isTrailingSurrogate(code)) {
                  len = prevLeadingSurrogate
                      ? len - 2  // surrogate pair (4 bytes), since we calculate prev leading surrogate as 6 bytes, substruct 2 bytes
                      : len + 6; // \uXXXX
              } else {
                  len += 3; // code >= 2048 is 3 bytes length for UTF8
              }
  
              prevLeadingSurrogate = false;
          }
  
          return len + 2; // +2 for quotes
      }
  
      function primitiveLength(value) {
          switch (typeof value) {
              case 'string':
                  return stringLength(value);
  
              case 'number':
                  return Number.isFinite(value) ? String(value).length : 4 /* null */;
  
              case 'boolean':
                  return value ? 4 /* true */ : 5 /* false */;
  
              case 'undefined':
              case 'object':
                  return 4; /* null */
  
              default:
                  return 0;
          }
      }
  
      function spaceLength(space) {
          space = normalizeSpace(space);
          return typeof space === 'string' ? space.length : 0;
      }
  
      var stringifyInfo = function jsonStringifyInfo(value, replacer, space, options) {
          function walk(holder, key, value) {
              if (stop) {
                  return;
              }
  
              value = replaceValue(holder, key, value, replacer);
  
              let type = getType(value);
  
              // check for circular structure
              if (type !== PRIMITIVE && stack.has(value)) {
                  circular.add(value);
                  length += 4; // treat as null
  
                  if (!options.continueOnCircular) {
                      stop = true;
                  }
  
                  return;
              }
  
              switch (type) {
                  case PRIMITIVE:
                      if (value !== undefined || Array.isArray(holder)) {
                          length += primitiveLength(value);
                      } else if (holder === root) {
                          length += 9; // FIXME: that's the length of undefined, should we normalize behaviour to convert it to null?
                      }
                      break;
  
                  case OBJECT: {
                      if (visited.has(value)) {
                          duplicate.add(value);
                          length += visited.get(value);
                          break;
                      }
  
                      const valueLength = length;
                      let entries = 0;
  
                      length += 2; // {}
  
                      stack.add(value);
  
                      for (const key in value) {
                          if (hasOwnProperty.call(value, key) && (allowlist === null || allowlist.has(key))) {
                              const prevLength = length;
                              walk(value, key, value[key]);
  
                              if (prevLength !== length) {
                                  // value is printed
                                  length += stringLength(key) + 1; // "key":
                                  entries++;
                              }
                          }
                      }
  
                      if (entries > 1) {
                          length += entries - 1; // commas
                      }
  
                      stack.delete(value);
  
                      if (space > 0 && entries > 0) {
                          length += (1 + (stack.size + 1) * space + 1) * entries; // for each key-value: \n{space}
                          length += 1 + stack.size * space; // for }
                      }
  
                      visited.set(value, length - valueLength);
  
                      break;
                  }
  
                  case ARRAY: {
                      if (visited.has(value)) {
                          duplicate.add(value);
                          length += visited.get(value);
                          break;
                      }
  
                      const valueLength = length;
  
                      length += 2; // []
  
                      stack.add(value);
  
                      for (let i = 0; i < value.length; i++) {
                          walk(value, i, value[i]);
                      }
  
                      if (value.length > 1) {
                          length += value.length - 1; // commas
                      }
  
                      stack.delete(value);
  
                      if (space > 0 && value.length > 0) {
                          length += (1 + (stack.size + 1) * space) * value.length; // for each element: \n{space}
                          length += 1 + stack.size * space; // for ]
                      }
  
                      visited.set(value, length - valueLength);
  
                      break;
                  }
  
                  case PROMISE:
                  case STRING_STREAM:
                      async.add(value);
                      break;
  
                  case OBJECT_STREAM:
                      length += 2; // []
                      async.add(value);
                      break;
              }
          }
  
          let allowlist = null;
          replacer = normalizeReplacer(replacer);
  
          if (Array.isArray(replacer)) {
              allowlist = new Set(replacer);
              replacer = null;
          }
  
          space = spaceLength(space);
          options = options || {};
  
          const visited = new Map();
          const stack = new Set();
          const duplicate = new Set();
          const circular = new Set();
          const async = new Set();
          const getType = options.async ? getTypeAsync : getTypeNative;
          const root = { '': value };
          let stop = false;
          let length = 0;
  
          walk(root, '', value);
  
          return {
              minLength: isNaN(length) ? Infinity : length,
              circular: [...circular],
              duplicate: [...duplicate],
              async: [...async]
          };
      };
  
      var stringifyStreamBrowser = () => {
          throw new Error('Method is not supported');
      };
  
      var textDecoderBrowser = TextDecoder;
  
      const { isReadableStream } = utils;
  
  
      const STACK_OBJECT = 1;
      const STACK_ARRAY = 2;
      const decoder = new textDecoderBrowser();
  
      function isObject(value) {
          return value !== null && typeof value === 'object';
      }
  
      function adjustPosition(error, parser) {
          if (error.name === 'SyntaxError' && parser.jsonParseOffset) {
              error.message = error.message.replace(/at position (\d+)/, (_, pos) =>
                  'at position ' + (Number(pos) + parser.jsonParseOffset)
              );
          }
  
          return error;
      }
  
      function append(array, elements) {
          // Note: Avoid to use array.push(...elements) since it may lead to
          // "RangeError: Maximum call stack size exceeded" for a long arrays
          const initialLength = array.length;
          array.length += elements.length;
  
          for (let i = 0; i < elements.length; i++) {
              array[initialLength + i] = elements[i];
          }
      }
  
      var parseChunked = function(chunkEmitter) {
          let parser = new ChunkParser();
  
          if (isObject(chunkEmitter) && isReadableStream(chunkEmitter)) {
              return new Promise((resolve, reject) => {
                  chunkEmitter
                      .on('data', chunk => {
                          try {
                              parser.push(chunk);
                          } catch (e) {
                              reject(adjustPosition(e, parser));
                              parser = null;
                          }
                      })
                      .on('error', (e) => {
                          parser = null;
                          reject(e);
                      })
                      .on('end', () => {
                          try {
                              resolve(parser.finish());
                          } catch (e) {
                              reject(adjustPosition(e, parser));
                          } finally {
                              parser = null;
                          }
                      });
              });
          }
  
          if (typeof chunkEmitter === 'function') {
              const iterator = chunkEmitter();
  
              if (isObject(iterator) && (Symbol.iterator in iterator || Symbol.asyncIterator in iterator)) {
                  return new Promise(async (resolve, reject) => {
                      try {
                          for await (const chunk of iterator) {
                              parser.push(chunk);
                          }
  
                          resolve(parser.finish());
                      } catch (e) {
                          reject(adjustPosition(e, parser));
                      } finally {
                          parser = null;
                      }
                  });
              }
          }
  
          throw new Error(
              'Chunk emitter should be readable stream, generator, ' +
              'async generator or function returning an iterable object'
          );
      };
  
      class ChunkParser {
          constructor() {
              this.value = undefined;
              this.valueStack = null;
  
              this.stack = new Array(100);
              this.lastFlushDepth = 0;
              this.flushDepth = 0;
              this.stateString = false;
              this.stateStringEscape = false;
              this.pendingByteSeq = null;
              this.pendingChunk = null;
              this.chunkOffset = 0;
              this.jsonParseOffset = 0;
          }
  
          parseAndAppend(fragment, wrap) {
              // Append new entries or elements
              if (this.stack[this.lastFlushDepth - 1] === STACK_OBJECT) {
                  if (wrap) {
                      this.jsonParseOffset--;
                      fragment = '{' + fragment + '}';
                  }
  
                  Object.assign(this.valueStack.value, JSON.parse(fragment));
              } else {
                  if (wrap) {
                      this.jsonParseOffset--;
                      fragment = '[' + fragment + ']';
                  }
  
                  append(this.valueStack.value, JSON.parse(fragment));
              }
          }
  
          prepareAddition(fragment) {
              const { value } = this.valueStack;
              const expectComma = Array.isArray(value)
                  ? value.length !== 0
                  : Object.keys(value).length !== 0;
  
              if (expectComma) {
                  // Skip a comma at the beginning of fragment, otherwise it would
                  // fail to parse
                  if (fragment[0] === ',') {
                      this.jsonParseOffset++;
                      return fragment.slice(1);
                  }
  
                  // When value (an object or array) is not empty and a fragment
                  // doesn't start with a comma, a single valid fragment starting
                  // is a closing bracket. If it's not, a prefix is adding to fail
                  // parsing. Otherwise, the sequence of chunks can be successfully
                  // parsed, although it should not, e.g. ["[{}", "{}]"]
                  if (fragment[0] !== '}' && fragment[0] !== ']') {
                      this.jsonParseOffset -= 3;
                      return '[[]' + fragment;
                  }
              }
  
              return fragment;
          }
  
          flush(chunk, start, end) {
              let fragment = chunk.slice(start, end);
  
              // Save position correction an error in JSON.parse() if any
              this.jsonParseOffset = this.chunkOffset + start;
  
              // Prepend pending chunk if any
              if (this.pendingChunk !== null) {
                  fragment = this.pendingChunk + fragment;
                  this.jsonParseOffset -= this.pendingChunk.length;
                  this.pendingChunk = null;
              }
  
              if (this.flushDepth === this.lastFlushDepth) {
                  // Depth didn't changed, so it's a root value or entry/element set
                  if (this.flushDepth > 0) {
                      this.parseAndAppend(this.prepareAddition(fragment), true);
                  } else {
                      // That's an entire value on a top level
                      this.value = JSON.parse(fragment);
                      this.valueStack = {
                          value: this.value,
                          prev: null
                      };
                  }
              } else if (this.flushDepth > this.lastFlushDepth) {
                  // Add missed closing brackets/parentheses
                  for (let i = this.flushDepth - 1; i >= this.lastFlushDepth; i--) {
                      fragment += this.stack[i] === STACK_OBJECT ? '}' : ']';
                  }
  
                  if (this.lastFlushDepth === 0) {
                      // That's a root value
                      this.value = JSON.parse(fragment);
                      this.valueStack = {
                          value: this.value,
                          prev: null
                      };
                  } else {
                      this.parseAndAppend(this.prepareAddition(fragment), true);
                  }
  
                  // Move down to the depths to the last object/array, which is current now
                  for (let i = this.lastFlushDepth || 1; i < this.flushDepth; i++) {
                      let value = this.valueStack.value;
  
                      if (this.stack[i - 1] === STACK_OBJECT) {
                          // find last entry
                          let key;
                          // eslint-disable-next-line curly
                          for (key in value);
                          value = value[key];
                      } else {
                          // last element
                          value = value[value.length - 1];
                      }
  
                      this.valueStack = {
                          value,
                          prev: this.valueStack
                      };
                  }
              } else /* this.flushDepth < this.lastFlushDepth */ {
                  fragment = this.prepareAddition(fragment);
  
                  // Add missed opening brackets/parentheses
                  for (let i = this.lastFlushDepth - 1; i >= this.flushDepth; i--) {
                      this.jsonParseOffset--;
                      fragment = (this.stack[i] === STACK_OBJECT ? '{' : '[') + fragment;
                  }
  
                  this.parseAndAppend(fragment, false);
  
                  for (let i = this.lastFlushDepth - 1; i >= this.flushDepth; i--) {
                      this.valueStack = this.valueStack.prev;
                  }
              }
  
              this.lastFlushDepth = this.flushDepth;
          }
  
          push(chunk) {
              if (typeof chunk !== 'string') {
                  // Suppose chunk is Buffer or Uint8Array
  
                  // Prepend uncompleted byte sequence if any
                  if (this.pendingByteSeq !== null) {
                      const origRawChunk = chunk;
                      chunk = new Uint8Array(this.pendingByteSeq.length + origRawChunk.length);
                      chunk.set(this.pendingByteSeq);
                      chunk.set(origRawChunk, this.pendingByteSeq.length);
                      this.pendingByteSeq = null;
                  }
  
                  // In case Buffer/Uint8Array, an input is encoded in UTF8
                  // Seek for parts of uncompleted UTF8 symbol on the ending
                  // This makes sense only if we expect more chunks and last char is not multi-bytes
                  if (chunk[chunk.length - 1] > 127) {
                      for (let seqLength = 0; seqLength < chunk.length; seqLength++) {
                          const byte = chunk[chunk.length - 1 - seqLength];
  
                          // 10xxxxxx - 2nd, 3rd or 4th byte
                          // 110xxxxx – first byte of 2-byte sequence
                          // 1110xxxx - first byte of 3-byte sequence
                          // 11110xxx - first byte of 4-byte sequence
                          if (byte >> 6 === 3) {
                              seqLength++;
  
                              // If the sequence is really incomplete, then preserve it
                              // for the future chunk and cut off it from the current chunk
                              if ((seqLength !== 4 && byte >> 3 === 0b11110) ||
                                  (seqLength !== 3 && byte >> 4 === 0b1110) ||
                                  (seqLength !== 2 && byte >> 5 === 0b110)) {
                                  this.pendingByteSeq = chunk.slice(chunk.length - seqLength);
                                  chunk = chunk.slice(0, -seqLength);
                              }
  
                              break;
                          }
                      }
                  }
  
                  // Convert chunk to a string, since single decode per chunk
                  // is much effective than decode multiple small substrings
                  chunk = decoder.decode(chunk);
              }
  
              const chunkLength = chunk.length;
              let lastFlushPoint = 0;
              let flushPoint = 0;
  
              // Main scan loop
              scan: for (let i = 0; i < chunkLength; i++) {
                  if (this.stateString) {
                      for (; i < chunkLength; i++) {
                          if (this.stateStringEscape) {
                              this.stateStringEscape = false;
                          } else {
                              switch (chunk.charCodeAt(i)) {
                                  case 0x22: /* " */
                                      this.stateString = false;
                                      continue scan;
  
                                  case 0x5C: /* \ */
                                      this.stateStringEscape = true;
                              }
                          }
                      }
  
                      break;
                  }
  
                  switch (chunk.charCodeAt(i)) {
                      case 0x22: /* " */
                          this.stateString = true;
                          this.stateStringEscape = false;
                          break;
  
                      case 0x2C: /* , */
                          flushPoint = i;
                          break;
  
                      case 0x7B: /* { */
                          // Open an object
                          flushPoint = i + 1;
                          this.stack[this.flushDepth++] = STACK_OBJECT;
                          break;
  
                      case 0x5B: /* [ */
                          // Open an array
                          flushPoint = i + 1;
                          this.stack[this.flushDepth++] = STACK_ARRAY;
                          break;
  
                      case 0x5D: /* ] */
                      case 0x7D: /* } */
                          // Close an object or array
                          flushPoint = i + 1;
                          this.flushDepth--;
  
                          if (this.flushDepth < this.lastFlushDepth) {
                              this.flush(chunk, lastFlushPoint, flushPoint);
                              lastFlushPoint = flushPoint;
                          }
  
                          break;
  
                      case 0x09: /* \t */
                      case 0x0A: /* \n */
                      case 0x0D: /* \r */
                      case 0x20: /* space */
                          // Move points forward when they points on current position and it's a whitespace
                          if (lastFlushPoint === i) {
                              lastFlushPoint++;
                          }
  
                          if (flushPoint === i) {
                              flushPoint++;
                          }
  
                          break;
                  }
              }
  
              if (flushPoint > lastFlushPoint) {
                  this.flush(chunk, lastFlushPoint, flushPoint);
              }
  
              // Produce pendingChunk if something left
              if (flushPoint < chunkLength) {
                  if (this.pendingChunk !== null) {
                      // When there is already a pending chunk then no flush happened,
                      // appending entire chunk to pending one
                      this.pendingChunk += chunk;
                  } else {
                      // Create a pending chunk, it will start with non-whitespace since
                      // flushPoint was moved forward away from whitespaces on scan
                      this.pendingChunk = chunk.slice(flushPoint, chunkLength);
                  }
              }
  
              this.chunkOffset += chunkLength;
          }
  
          finish() {
              if (this.pendingChunk !== null) {
                  this.flush('', 0, 0);
                  this.pendingChunk = null;
              }
  
              return this.value;
          }
      }
  
      var src = {
          version: require$$0.version,
          stringifyInfo: stringifyInfo,
          stringifyStream: stringifyStreamBrowser,
          parseChunked: parseChunked
      };
  
      return src;
  
  })));
  