@salesforce/core-bundle 7.3.3 → 7.3.10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (7) hide show
  1. package/lib/index.d.ts +1 -1
  2. package/lib/index.js +1788 -2730
  3. package/lib/pino-file.js +125 -73
  4. package/lib/pino-pretty.js +889 -442
  5. package/lib/pino-worker.js +610 -348
  6. package/lib/transformStream.js +3 -3
  7. package/package.json +6 -6
package/lib/pino-worker.js CHANGED
@@ -516,11 +516,19 @@ var require_redactor = __commonJS({
516
516
  ${strictImpl(strict, serialize)}
517
517
  }
518
518
  const { censor, secret } = this
519
+ const originalSecret = {}
520
+ const secretKeys = Object.keys(secret)
521
+ for (var i = 0; i < secretKeys.length; i++) {
522
+ originalSecret[secretKeys[i]] = secret[secretKeys[i]]
523
+ }
524
+
519
525
  ${redactTmpl(secret, isCensorFct, censorFctTakesPath)}
520
526
  this.compileRestore()
521
527
  ${dynamicRedactTmpl(wcLen > 0, isCensorFct, censorFctTakesPath)}
528
+ this.secret = originalSecret
522
529
  ${resultTmpl(serialize)}
523
530
  `).bind(state);
531
+ redact.state = state;
524
532
  if (serialize === false) {
525
533
  redact.restore = (o) => state.restore(o);
526
534
  }
@@ -606,7 +614,7 @@ var require_modifiers = __commonJS({
606
614
  nestedRestore
607
615
  };
608
616
  function groupRestore({ keys, values, target }) {
609
- if (target == null)
617
+ if (target == null || typeof target === "string")
610
618
  return;
611
619
  const length = keys.length;
612
620
  for (var i = 0; i < length; i++) {
@@ -616,8 +624,8 @@ var require_modifiers = __commonJS({
616
624
  }
617
625
  function groupRedact(o, path, censor, isCensorFct, censorFctTakesPath) {
618
626
  const target = get(o, path);
619
- if (target == null)
620
- return { keys: null, values: null, target: null, flat: true };
627
+ if (target == null || typeof target === "string")
628
+ return { keys: null, values: null, target, flat: true };
621
629
  const keys = Object.keys(target);
622
630
  const keysLength = keys.length;
623
631
  const pathLength = path.length;
@@ -637,27 +645,14 @@ var require_modifiers = __commonJS({
637
645
  }
638
646
  return { keys, values, target, flat: true };
639
647
  }
640
- function nestedRestore(arr) {
641
- const length = arr.length;
642
- for (var i = 0; i < length; i++) {
643
- const { key, target, value, level } = arr[i];
644
- if (level === 0 || level === 1) {
645
- if (has(target, key)) {
646
- target[key] = value;
647
- }
648
- if (typeof target === "object") {
649
- const targetKeys = Object.keys(target);
650
- for (var j = 0; j < targetKeys.length; j++) {
651
- const tKey = targetKeys[j];
652
- const subTarget = target[tKey];
653
- if (has(subTarget, key)) {
654
- subTarget[key] = value;
655
- }
656
- }
657
- }
658
- } else {
659
- restoreNthLevel(key, target, value, level);
648
+ function nestedRestore(instructions) {
649
+ for (let i = 0; i < instructions.length; i++) {
650
+ const { target, path, value } = instructions[i];
651
+ let current = target;
652
+ for (let i2 = path.length - 1; i2 > 0; i2--) {
653
+ current = current[path[i2]];
660
654
  }
655
+ current[path[0]] = value;
661
656
  }
662
657
  }
663
658
  function nestedRedact(store, o, path, ns, censor, isCensorFct, censorFctTakesPath) {
@@ -668,17 +663,14 @@ var require_modifiers = __commonJS({
668
663
  const keysLength = keys.length;
669
664
  for (var i = 0; i < keysLength; i++) {
670
665
  const key = keys[i];
671
- const { value, parent, exists, level } = specialSet(target, key, path, ns, censor, isCensorFct, censorFctTakesPath);
672
- if (exists === true && parent !== null) {
673
- store.push({ key: ns[ns.length - 1], target: parent, value, level });
674
- }
666
+ specialSet(store, target, key, path, ns, censor, isCensorFct, censorFctTakesPath);
675
667
  }
676
668
  return store;
677
669
  }
678
670
  function has(obj, prop) {
679
671
  return obj !== void 0 && obj !== null ? "hasOwn" in Object ? Object.hasOwn(obj, prop) : Object.prototype.hasOwnProperty.call(obj, prop) : false;
680
672
  }
681
- function specialSet(o, k, path, afterPath, censor, isCensorFct, censorFctTakesPath) {
673
+ function specialSet(store, o, k, path, afterPath, censor, isCensorFct, censorFctTakesPath) {
682
674
  const afterPathLen = afterPath.length;
683
675
  const lastPathIndex = afterPathLen - 1;
684
676
  const originalKey = k;
@@ -687,20 +679,21 @@ var require_modifiers = __commonJS({
687
679
  var nv;
688
680
  var ov;
689
681
  var oov = null;
690
- var exists = true;
691
682
  var wc = null;
692
683
  var kIsWc;
693
684
  var wcov;
694
685
  var consecutive = false;
695
686
  var level = 0;
687
+ var depth = 0;
688
+ var redactPathCurrent = tree();
696
689
  ov = n = o[k];
697
690
  if (typeof n !== "object")
698
- return { value: null, parent: null, exists };
691
+ return;
699
692
  while (n != null && ++i < afterPathLen) {
693
+ depth += 1;
700
694
  k = afterPath[i];
701
695
  oov = ov;
702
696
  if (k !== "*" && !wc && !(typeof n === "object" && k in n)) {
703
- exists = false;
704
697
  break;
705
698
  }
706
699
  if (k === "*") {
@@ -719,8 +712,9 @@ var require_modifiers = __commonJS({
719
712
  wcov = n[wck];
720
713
  kIsWc = k === "*";
721
714
  if (consecutive) {
715
+ redactPathCurrent = node(redactPathCurrent, wck, depth);
722
716
  level = i;
723
- ov = iterateNthLevel(wcov, level - 1, k, path, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n, nv, ov, kIsWc, wck, i, lastPathIndex, exists);
717
+ ov = iterateNthLevel(wcov, level - 1, k, path, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n, nv, ov, kIsWc, wck, i, lastPathIndex, redactPathCurrent, store, o[originalKey], depth + 1);
724
718
  } else {
725
719
  if (kIsWc || typeof wcov === "object" && wcov !== null && k in wcov) {
726
720
  if (kIsWc) {
@@ -730,12 +724,18 @@ var require_modifiers = __commonJS({
730
724
  }
731
725
  nv = i !== lastPathIndex ? ov : isCensorFct ? censorFctTakesPath ? censor(ov, [...path, originalKey, ...afterPath]) : censor(ov) : censor;
732
726
  if (kIsWc) {
727
+ const rv = restoreInstr(node(redactPathCurrent, wck, depth), ov, o[originalKey]);
728
+ store.push(rv);
733
729
  n[wck] = nv;
734
730
  } else {
735
731
  if (wcov[k] === nv) {
736
- exists = false;
732
+ } else if (nv === void 0 && censor !== void 0 || has(wcov, k) && nv === ov) {
733
+ redactPathCurrent = node(redactPathCurrent, wck, depth);
737
734
  } else {
738
- wcov[k] = nv === void 0 && censor !== void 0 || has(wcov, k) && nv === ov ? wcov[k] : nv;
735
+ redactPathCurrent = node(redactPathCurrent, wck, depth);
736
+ const rv = restoreInstr(node(redactPathCurrent, k, depth + 1), ov, o[originalKey]);
737
+ store.push(rv);
738
+ wcov[k] = nv;
739
739
  }
740
740
  }
741
741
  }
@@ -744,17 +744,21 @@ var require_modifiers = __commonJS({
744
744
  wc = null;
745
745
  } else {
746
746
  ov = n[k];
747
+ redactPathCurrent = node(redactPathCurrent, k, depth);
747
748
  nv = i !== lastPathIndex ? ov : isCensorFct ? censorFctTakesPath ? censor(ov, [...path, originalKey, ...afterPath]) : censor(ov) : censor;
748
- n[k] = has(n, k) && nv === ov || nv === void 0 && censor !== void 0 ? n[k] : nv;
749
+ if (has(n, k) && nv === ov || nv === void 0 && censor !== void 0) {
750
+ } else {
751
+ const rv = restoreInstr(redactPathCurrent, ov, o[originalKey]);
752
+ store.push(rv);
753
+ n[k] = nv;
754
+ }
749
755
  n = n[k];
750
756
  }
751
757
  if (typeof n !== "object")
752
758
  break;
753
759
  if (ov === oov || typeof ov === "undefined") {
754
- exists = false;
755
760
  }
756
761
  }
757
- return { value: ov, parent: oov, exists, level };
758
762
  }
759
763
  function get(o, p) {
760
764
  var i = -1;
@@ -765,7 +769,7 @@ var require_modifiers = __commonJS({
765
769
  }
766
770
  return n;
767
771
  }
768
- function iterateNthLevel(wcov, level, k, path, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n, nv, ov, kIsWc, wck, i, lastPathIndex, exists) {
772
+ function iterateNthLevel(wcov, level, k, path, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n, nv, ov, kIsWc, wck, i, lastPathIndex, redactPathCurrent, store, parent, depth) {
769
773
  if (level === 0) {
770
774
  if (kIsWc || typeof wcov === "object" && wcov !== null && k in wcov) {
771
775
  if (kIsWc) {
@@ -775,36 +779,51 @@ var require_modifiers = __commonJS({
775
779
  }
776
780
  nv = i !== lastPathIndex ? ov : isCensorFct ? censorFctTakesPath ? censor(ov, [...path, originalKey, ...afterPath]) : censor(ov) : censor;
777
781
  if (kIsWc) {
782
+ const rv = restoreInstr(redactPathCurrent, ov, parent);
783
+ store.push(rv);
778
784
  n[wck] = nv;
779
785
  } else {
780
786
  if (wcov[k] === nv) {
781
- exists = false;
787
+ } else if (nv === void 0 && censor !== void 0 || has(wcov, k) && nv === ov) {
782
788
  } else {
783
- wcov[k] = nv === void 0 && censor !== void 0 || has(wcov, k) && nv === ov ? wcov[k] : nv;
789
+ const rv = restoreInstr(node(redactPathCurrent, k, depth + 1), ov, parent);
790
+ store.push(rv);
791
+ wcov[k] = nv;
784
792
  }
785
793
  }
786
794
  }
787
- return ov;
788
795
  }
789
796
  for (const key in wcov) {
790
797
  if (typeof wcov[key] === "object") {
791
- var temp = iterateNthLevel(wcov[key], level - 1, k, path, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n, nv, ov, kIsWc, wck, i, lastPathIndex, exists);
792
- return temp;
798
+ redactPathCurrent = node(redactPathCurrent, key, depth);
799
+ iterateNthLevel(wcov[key], level - 1, k, path, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n, nv, ov, kIsWc, wck, i, lastPathIndex, redactPathCurrent, store, parent, depth + 1);
793
800
  }
794
801
  }
795
802
  }
796
- function restoreNthLevel(key, target, value, level) {
797
- if (level === 0) {
798
- if (has(target, key)) {
799
- target[key] = value;
800
- }
801
- return;
802
- }
803
- for (const objKey in target) {
804
- if (typeof target[objKey] === "object") {
805
- restoreNthLevel(key, target[objKey], value, level - 1);
806
- }
803
+ function tree() {
804
+ return { parent: null, key: null, children: [], depth: 0 };
805
+ }
806
+ function node(parent, key, depth) {
807
+ if (parent.depth === depth) {
808
+ return node(parent.parent, key, depth);
807
809
  }
810
+ var child = {
811
+ parent,
812
+ key,
813
+ depth,
814
+ children: []
815
+ };
816
+ parent.children.push(child);
817
+ return child;
818
+ }
819
+ function restoreInstr(node2, value, target) {
820
+ let current = node2;
821
+ const path = [];
822
+ do {
823
+ path.push(current.key);
824
+ current = current.parent;
825
+ } while (current.parent != null);
826
+ return { path, value, target };
808
827
  }
809
828
  }
810
829
  });
@@ -815,10 +834,13 @@ var require_restorer = __commonJS({
815
834
  "use strict";
816
835
  var { groupRestore, nestedRestore } = require_modifiers();
817
836
  module2.exports = restorer;
818
- function restorer({ secret, wcLen }) {
837
+ function restorer() {
819
838
  return function compileRestore() {
820
- if (this.restore)
839
+ if (this.restore) {
840
+ this.restore.state.secret = this.secret;
821
841
  return;
842
+ }
843
+ const { secret, wcLen } = this;
822
844
  const paths = Object.keys(secret);
823
845
  const resetters = resetTmpl(secret, paths);
824
846
  const hasWildcards = wcLen > 0;
@@ -827,6 +849,7 @@ var require_restorer = __commonJS({
827
849
  "o",
828
850
  restoreTmpl(resetters, paths, hasWildcards)
829
851
  ).bind(state);
852
+ this.restore.state = state;
830
853
  };
831
854
  }
832
855
  function resetTmpl(secret, paths) {
@@ -850,9 +873,11 @@ var require_restorer = __commonJS({
850
873
  for (var i = len - 1; i >= ${paths.length}; i--) {
851
874
  const k = keys[i]
852
875
  const o = secret[k]
853
- if (o.flat === true) this.groupRestore(o)
854
- else this.nestedRestore(o)
855
- secret[k] = null
876
+ if (o) {
877
+ if (o.flat === true) this.groupRestore(o)
878
+ else this.nestedRestore(o)
879
+ secret[k] = null
880
+ }
856
881
  }
857
882
  ` : "";
858
883
  return `
@@ -923,7 +948,7 @@ var require_fast_redact = __commonJS({
923
948
  return serialize || noop;
924
949
  validate({ paths, serialize, censor });
925
950
  const { wildcards, wcLen, secret } = parse({ paths, censor });
926
- const compileRestore = restorer({ secret, wcLen });
951
+ const compileRestore = restorer();
927
952
  const strict = "strict" in opts ? opts.strict : true;
928
953
  return redactor({ secret, wcLen, serialize, strict, isCensorFct, censorFctTakesPath }, state({
929
954
  secret,
@@ -1300,6 +1325,7 @@ var require_sonic_boom = __commonJS({
1300
1325
  }
1301
1326
  return;
1302
1327
  }
1328
+ const reopening = sonic._reopening;
1303
1329
  sonic.fd = fd;
1304
1330
  sonic.file = file;
1305
1331
  sonic._reopening = false;
@@ -1310,11 +1336,13 @@ var require_sonic_boom = __commonJS({
1310
1336
  } else {
1311
1337
  sonic.emit("ready");
1312
1338
  }
1313
- if (sonic._reopening || sonic.destroyed) {
1339
+ if (sonic.destroyed) {
1314
1340
  return;
1315
1341
  }
1316
1342
  if (!sonic._writing && sonic._len > sonic.minLength || sonic._flushPending) {
1317
1343
  sonic._actualWrite();
1344
+ } else if (reopening) {
1345
+ process.nextTick(() => sonic.emit("drain"));
1318
1346
  }
1319
1347
  }
1320
1348
  const flags = sonic.append ? "a" : "w";
@@ -1419,11 +1447,9 @@ var require_sonic_boom = __commonJS({
1419
1447
  return;
1420
1448
  }
1421
1449
  this.emit("write", n);
1422
- this._len -= n;
1423
- if (this._len < 0) {
1424
- this._len = 0;
1425
- }
1426
- this._writingBuf = this._writingBuf.slice(n);
1450
+ const releasedBufObj = releaseWritingBuf(this._writingBuf, this._len, n);
1451
+ this._len = releasedBufObj.len;
1452
+ this._writingBuf = releasedBufObj.writingBuf;
1427
1453
  if (this._writingBuf.length) {
1428
1454
  if (!this.sync) {
1429
1455
  fsWrite();
@@ -1432,8 +1458,9 @@ var require_sonic_boom = __commonJS({
1432
1458
  try {
1433
1459
  do {
1434
1460
  const n2 = fsWriteSync();
1435
- this._len -= n2;
1436
- this._writingBuf = this._writingBuf.slice(n2);
1461
+ const releasedBufObj2 = releaseWritingBuf(this._writingBuf, this._len, n2);
1462
+ this._len = releasedBufObj2.len;
1463
+ this._writingBuf = releasedBufObj2.writingBuf;
1437
1464
  } while (this._writingBuf.length);
1438
1465
  } catch (err2) {
1439
1466
  this.release(err2);
@@ -1475,6 +1502,14 @@ var require_sonic_boom = __commonJS({
1475
1502
  }
1476
1503
  });
1477
1504
  }
1505
+ function releaseWritingBuf(writingBuf, len, n) {
1506
+ if (typeof writingBuf === "string" && Buffer.byteLength(writingBuf) !== n) {
1507
+ n = Buffer.from(writingBuf).subarray(0, n).toString().length;
1508
+ }
1509
+ len = Math.max(len - n, 0);
1510
+ writingBuf = writingBuf.slice(n);
1511
+ return { writingBuf, len };
1512
+ }
1478
1513
  function emitDrain(sonic) {
1479
1514
  const hasListeners = sonic.listenerCount("drain") > 0;
1480
1515
  if (!hasListeners)
@@ -1630,6 +1665,9 @@ var require_sonic_boom = __commonJS({
1630
1665
  if (!this.file) {
1631
1666
  throw new Error("Unable to reopen a file descriptor, you must pass a file to SonicBoom");
1632
1667
  }
1668
+ if (file) {
1669
+ this.file = file;
1670
+ }
1633
1671
  this._reopening = true;
1634
1672
  if (this._writing) {
1635
1673
  return;
@@ -1644,7 +1682,7 @@ var require_sonic_boom = __commonJS({
1644
1682
  });
1645
1683
  }
1646
1684
  });
1647
- openFile(file || this.file, this);
1685
+ openFile(this.file, this);
1648
1686
  };
1649
1687
  SonicBoom.prototype.end = function() {
1650
1688
  if (this.destroyed) {
@@ -1687,8 +1725,9 @@ var require_sonic_boom = __commonJS({
1687
1725
  }
1688
1726
  try {
1689
1727
  const n = fs.writeSync(this.fd, buf, "utf8");
1690
- buf = buf.slice(n);
1691
- this._len = Math.max(this._len - n, 0);
1728
+ const releasedBufObj = releaseWritingBuf(buf, this._len, n);
1729
+ buf = releasedBufObj.writingBuf;
1730
+ this._len = releasedBufObj.len;
1692
1731
  if (buf.length <= 0) {
1693
1732
  this._bufs.shift();
1694
1733
  }
@@ -1819,7 +1858,12 @@ var require_on_exit_leak_free = __commonJS({
1819
1858
  exit: onExit,
1820
1859
  beforeExit: onBeforeExit
1821
1860
  };
1822
- var registry = new FinalizationRegistry(clear);
1861
+ var registry;
1862
+ function ensureRegistry() {
1863
+ if (registry === void 0) {
1864
+ registry = new FinalizationRegistry(clear);
1865
+ }
1866
+ }
1823
1867
  function install(event) {
1824
1868
  if (refs[event].length > 0) {
1825
1869
  return;
@@ -1831,6 +1875,9 @@ var require_on_exit_leak_free = __commonJS({
1831
1875
  return;
1832
1876
  }
1833
1877
  process.removeListener(event, functions[event]);
1878
+ if (refs.exit.length === 0 && refs.beforeExit.length === 0) {
1879
+ registry = void 0;
1880
+ }
1834
1881
  }
1835
1882
  function onExit() {
1836
1883
  callRefs("exit");
@@ -1846,6 +1893,7 @@ var require_on_exit_leak_free = __commonJS({
1846
1893
  fn(obj, event);
1847
1894
  }
1848
1895
  }
1896
+ refs[event] = [];
1849
1897
  }
1850
1898
  function clear(ref) {
1851
1899
  for (const event of ["exit", "beforeExit"]) {
@@ -1861,6 +1909,7 @@ var require_on_exit_leak_free = __commonJS({
1861
1909
  install(event);
1862
1910
  const ref = new WeakRef(obj);
1863
1911
  ref.fn = fn;
1912
+ ensureRegistry();
1864
1913
  registry.register(obj, ref);
1865
1914
  refs[event].push(ref);
1866
1915
  }
@@ -1871,6 +1920,9 @@ var require_on_exit_leak_free = __commonJS({
1871
1920
  _register("beforeExit", obj, fn);
1872
1921
  }
1873
1922
  function unregister(obj) {
1923
+ if (registry === void 0) {
1924
+ return;
1925
+ }
1874
1926
  registry.unregister(obj);
1875
1927
  for (const event of ["exit", "beforeExit"]) {
1876
1928
  refs[event] = refs[event].filter((ref) => {
@@ -4449,6 +4501,9 @@ var require_primordials = __commonJS({
4449
4501
  PromiseReject(err) {
4450
4502
  return Promise.reject(err);
4451
4503
  },
4504
+ PromiseResolve(val) {
4505
+ return Promise.resolve(val);
4506
+ },
4452
4507
  ReflectApply: Reflect.apply,
4453
4508
  RegExpPrototypeTest(self, value) {
4454
4509
  return self.test(value);
@@ -4472,138 +4527,17 @@ var require_primordials = __commonJS({
4472
4527
  SymbolAsyncIterator: Symbol.asyncIterator,
4473
4528
  SymbolHasInstance: Symbol.hasInstance,
4474
4529
  SymbolIterator: Symbol.iterator,
4530
+ SymbolDispose: Symbol.dispose || Symbol("Symbol.dispose"),
4531
+ SymbolAsyncDispose: Symbol.asyncDispose || Symbol("Symbol.asyncDispose"),
4475
4532
  TypedArrayPrototypeSet(self, buf, len) {
4476
4533
  return self.set(buf, len);
4477
4534
  },
4535
+ Boolean,
4478
4536
  Uint8Array
4479
4537
  };
4480
4538
  }
4481
4539
  });
4482
4540
 
4483
- // node_modules/pino-abstract-transport/node_modules/readable-stream/lib/ours/util.js
4484
- var require_util = __commonJS({
4485
- "node_modules/pino-abstract-transport/node_modules/readable-stream/lib/ours/util.js"(exports2, module2) {
4486
- "use strict";
4487
- var bufferModule = require("buffer");
4488
- var AsyncFunction = Object.getPrototypeOf(async function() {
4489
- }).constructor;
4490
- var Blob = globalThis.Blob || bufferModule.Blob;
4491
- var isBlob = typeof Blob !== "undefined" ? function isBlob2(b) {
4492
- return b instanceof Blob;
4493
- } : function isBlob2(b) {
4494
- return false;
4495
- };
4496
- var AggregateError = class extends Error {
4497
- constructor(errors) {
4498
- if (!Array.isArray(errors)) {
4499
- throw new TypeError(`Expected input to be an Array, got ${typeof errors}`);
4500
- }
4501
- let message = "";
4502
- for (let i = 0; i < errors.length; i++) {
4503
- message += ` ${errors[i].stack}
4504
- `;
4505
- }
4506
- super(message);
4507
- this.name = "AggregateError";
4508
- this.errors = errors;
4509
- }
4510
- };
4511
- module2.exports = {
4512
- AggregateError,
4513
- kEmptyObject: Object.freeze({}),
4514
- once(callback) {
4515
- let called = false;
4516
- return function(...args) {
4517
- if (called) {
4518
- return;
4519
- }
4520
- called = true;
4521
- callback.apply(this, args);
4522
- };
4523
- },
4524
- createDeferredPromise: function() {
4525
- let resolve;
4526
- let reject;
4527
- const promise = new Promise((res, rej) => {
4528
- resolve = res;
4529
- reject = rej;
4530
- });
4531
- return {
4532
- promise,
4533
- resolve,
4534
- reject
4535
- };
4536
- },
4537
- promisify(fn) {
4538
- return new Promise((resolve, reject) => {
4539
- fn((err, ...args) => {
4540
- if (err) {
4541
- return reject(err);
4542
- }
4543
- return resolve(...args);
4544
- });
4545
- });
4546
- },
4547
- debuglog() {
4548
- return function() {
4549
- };
4550
- },
4551
- format(format, ...args) {
4552
- return format.replace(/%([sdifj])/g, function(...[_unused, type]) {
4553
- const replacement = args.shift();
4554
- if (type === "f") {
4555
- return replacement.toFixed(6);
4556
- } else if (type === "j") {
4557
- return JSON.stringify(replacement);
4558
- } else if (type === "s" && typeof replacement === "object") {
4559
- const ctor = replacement.constructor !== Object ? replacement.constructor.name : "";
4560
- return `${ctor} {}`.trim();
4561
- } else {
4562
- return replacement.toString();
4563
- }
4564
- });
4565
- },
4566
- inspect(value) {
4567
- switch (typeof value) {
4568
- case "string":
4569
- if (value.includes("'")) {
4570
- if (!value.includes('"')) {
4571
- return `"${value}"`;
4572
- } else if (!value.includes("`") && !value.includes("${")) {
4573
- return `\`${value}\``;
4574
- }
4575
- }
4576
- return `'${value}'`;
4577
- case "number":
4578
- if (isNaN(value)) {
4579
- return "NaN";
4580
- } else if (Object.is(value, -0)) {
4581
- return String(value);
4582
- }
4583
- return value;
4584
- case "bigint":
4585
- return `${String(value)}n`;
4586
- case "boolean":
4587
- case "undefined":
4588
- return String(value);
4589
- case "object":
4590
- return "{}";
4591
- }
4592
- },
4593
- types: {
4594
- isAsyncFunction(fn) {
4595
- return fn instanceof AsyncFunction;
4596
- },
4597
- isArrayBufferView(arr) {
4598
- return ArrayBuffer.isView(arr);
4599
- }
4600
- },
4601
- isBlob
4602
- };
4603
- module2.exports.promisify.custom = Symbol.for("nodejs.util.promisify.custom");
4604
- }
4605
- });
4606
-
4607
4541
  // node_modules/event-target-shim/dist/event-target-shim.js
4608
4542
  var require_event_target_shim = __commonJS({
4609
4543
  "node_modules/event-target-shim/dist/event-target-shim.js"(exports2, module2) {
@@ -5272,6 +5206,195 @@ var require_abort_controller = __commonJS({
5272
5206
  }
5273
5207
  });
5274
5208
 
5209
+ // node_modules/pino-abstract-transport/node_modules/readable-stream/lib/ours/util.js
5210
+ var require_util = __commonJS({
5211
+ "node_modules/pino-abstract-transport/node_modules/readable-stream/lib/ours/util.js"(exports2, module2) {
5212
+ "use strict";
5213
+ var bufferModule = require("buffer");
5214
+ var { kResistStopPropagation, SymbolDispose } = require_primordials();
5215
+ var AbortSignal = globalThis.AbortSignal || require_abort_controller().AbortSignal;
5216
+ var AbortController = globalThis.AbortController || require_abort_controller().AbortController;
5217
+ var AsyncFunction = Object.getPrototypeOf(async function() {
5218
+ }).constructor;
5219
+ var Blob = globalThis.Blob || bufferModule.Blob;
5220
+ var isBlob = typeof Blob !== "undefined" ? function isBlob2(b) {
5221
+ return b instanceof Blob;
5222
+ } : function isBlob2(b) {
5223
+ return false;
5224
+ };
5225
+ var validateAbortSignal = (signal, name) => {
5226
+ if (signal !== void 0 && (signal === null || typeof signal !== "object" || !("aborted" in signal))) {
5227
+ throw new ERR_INVALID_ARG_TYPE(name, "AbortSignal", signal);
5228
+ }
5229
+ };
5230
+ var validateFunction = (value, name) => {
5231
+ if (typeof value !== "function")
5232
+ throw new ERR_INVALID_ARG_TYPE(name, "Function", value);
5233
+ };
5234
+ var AggregateError = class extends Error {
5235
+ constructor(errors) {
5236
+ if (!Array.isArray(errors)) {
5237
+ throw new TypeError(`Expected input to be an Array, got ${typeof errors}`);
5238
+ }
5239
+ let message = "";
5240
+ for (let i = 0; i < errors.length; i++) {
5241
+ message += ` ${errors[i].stack}
5242
+ `;
5243
+ }
5244
+ super(message);
5245
+ this.name = "AggregateError";
5246
+ this.errors = errors;
5247
+ }
5248
+ };
5249
+ module2.exports = {
5250
+ AggregateError,
5251
+ kEmptyObject: Object.freeze({}),
5252
+ once(callback) {
5253
+ let called = false;
5254
+ return function(...args) {
5255
+ if (called) {
5256
+ return;
5257
+ }
5258
+ called = true;
5259
+ callback.apply(this, args);
5260
+ };
5261
+ },
5262
+ createDeferredPromise: function() {
5263
+ let resolve;
5264
+ let reject;
5265
+ const promise = new Promise((res, rej) => {
5266
+ resolve = res;
5267
+ reject = rej;
5268
+ });
5269
+ return {
5270
+ promise,
5271
+ resolve,
5272
+ reject
5273
+ };
5274
+ },
5275
+ promisify(fn) {
5276
+ return new Promise((resolve, reject) => {
5277
+ fn((err, ...args) => {
5278
+ if (err) {
5279
+ return reject(err);
5280
+ }
5281
+ return resolve(...args);
5282
+ });
5283
+ });
5284
+ },
5285
+ debuglog() {
5286
+ return function() {
5287
+ };
5288
+ },
5289
+ format(format, ...args) {
5290
+ return format.replace(/%([sdifj])/g, function(...[_unused, type]) {
5291
+ const replacement = args.shift();
5292
+ if (type === "f") {
5293
+ return replacement.toFixed(6);
5294
+ } else if (type === "j") {
5295
+ return JSON.stringify(replacement);
5296
+ } else if (type === "s" && typeof replacement === "object") {
5297
+ const ctor = replacement.constructor !== Object ? replacement.constructor.name : "";
5298
+ return `${ctor} {}`.trim();
5299
+ } else {
5300
+ return replacement.toString();
5301
+ }
5302
+ });
5303
+ },
5304
+ inspect(value) {
5305
+ switch (typeof value) {
5306
+ case "string":
5307
+ if (value.includes("'")) {
5308
+ if (!value.includes('"')) {
5309
+ return `"${value}"`;
5310
+ } else if (!value.includes("`") && !value.includes("${")) {
5311
+ return `\`${value}\``;
5312
+ }
5313
+ }
5314
+ return `'${value}'`;
5315
+ case "number":
5316
+ if (isNaN(value)) {
5317
+ return "NaN";
5318
+ } else if (Object.is(value, -0)) {
5319
+ return String(value);
5320
+ }
5321
+ return value;
5322
+ case "bigint":
5323
+ return `${String(value)}n`;
5324
+ case "boolean":
5325
+ case "undefined":
5326
+ return String(value);
5327
+ case "object":
5328
+ return "{}";
5329
+ }
5330
+ },
5331
+ types: {
5332
+ isAsyncFunction(fn) {
5333
+ return fn instanceof AsyncFunction;
5334
+ },
5335
+ isArrayBufferView(arr) {
5336
+ return ArrayBuffer.isView(arr);
5337
+ }
5338
+ },
5339
+ isBlob,
5340
+ deprecate(fn, message) {
5341
+ return fn;
5342
+ },
5343
+ addAbortListener: require("events").addAbortListener || function addAbortListener(signal, listener) {
5344
+ if (signal === void 0) {
5345
+ throw new ERR_INVALID_ARG_TYPE("signal", "AbortSignal", signal);
5346
+ }
5347
+ validateAbortSignal(signal, "signal");
5348
+ validateFunction(listener, "listener");
5349
+ let removeEventListener;
5350
+ if (signal.aborted) {
5351
+ queueMicrotask(() => listener());
5352
+ } else {
5353
+ signal.addEventListener("abort", listener, {
5354
+ __proto__: null,
5355
+ once: true,
5356
+ [kResistStopPropagation]: true
5357
+ });
5358
+ removeEventListener = () => {
5359
+ signal.removeEventListener("abort", listener);
5360
+ };
5361
+ }
5362
+ return {
5363
+ __proto__: null,
5364
+ [SymbolDispose]() {
5365
+ var _removeEventListener;
5366
+ (_removeEventListener = removeEventListener) === null || _removeEventListener === void 0 ? void 0 : _removeEventListener();
5367
+ }
5368
+ };
5369
+ },
5370
+ AbortSignalAny: AbortSignal.any || function AbortSignalAny(signals) {
5371
+ if (signals.length === 1) {
5372
+ return signals[0];
5373
+ }
5374
+ const ac = new AbortController();
5375
+ const abort = () => ac.abort();
5376
+ signals.forEach((signal) => {
5377
+ validateAbortSignal(signal, "signals");
5378
+ signal.addEventListener("abort", abort, {
5379
+ once: true
5380
+ });
5381
+ });
5382
+ ac.signal.addEventListener(
5383
+ "abort",
5384
+ () => {
5385
+ signals.forEach((signal) => signal.removeEventListener("abort", abort));
5386
+ },
5387
+ {
5388
+ once: true
5389
+ }
5390
+ );
5391
+ return ac.signal;
5392
+ }
5393
+ };
5394
+ module2.exports.promisify.custom = Symbol.for("nodejs.util.promisify.custom");
5395
+ }
5396
+ });
5397
+
5275
5398
  // node_modules/pino-abstract-transport/node_modules/readable-stream/lib/ours/errors.js
5276
5399
  var require_errors = __commonJS({
5277
5400
  "node_modules/pino-abstract-transport/node_modules/readable-stream/lib/ours/errors.js"(exports2, module2) {
@@ -5610,7 +5733,7 @@ var require_validators = __commonJS({
5610
5733
  } = require_primordials();
5611
5734
  var {
5612
5735
  hideStackFrames,
5613
- codes: { ERR_SOCKET_BAD_PORT, ERR_INVALID_ARG_TYPE, ERR_INVALID_ARG_VALUE, ERR_OUT_OF_RANGE, ERR_UNKNOWN_SIGNAL }
5736
+ codes: { ERR_SOCKET_BAD_PORT, ERR_INVALID_ARG_TYPE: ERR_INVALID_ARG_TYPE2, ERR_INVALID_ARG_VALUE, ERR_OUT_OF_RANGE, ERR_UNKNOWN_SIGNAL }
5614
5737
  } = require_errors();
5615
5738
  var { normalizeEncoding } = require_util();
5616
5739
  var { isAsyncFunction, isArrayBufferView } = require_util().types;
@@ -5638,7 +5761,7 @@ var require_validators = __commonJS({
5638
5761
  }
5639
5762
  var validateInteger = hideStackFrames((value, name, min = NumberMIN_SAFE_INTEGER, max = NumberMAX_SAFE_INTEGER) => {
5640
5763
  if (typeof value !== "number")
5641
- throw new ERR_INVALID_ARG_TYPE(name, "number", value);
5764
+ throw new ERR_INVALID_ARG_TYPE2(name, "number", value);
5642
5765
  if (!NumberIsInteger(value))
5643
5766
  throw new ERR_OUT_OF_RANGE(name, "an integer", value);
5644
5767
  if (value < min || value > max)
@@ -5646,7 +5769,7 @@ var require_validators = __commonJS({
5646
5769
  });
5647
5770
  var validateInt32 = hideStackFrames((value, name, min = -2147483648, max = 2147483647) => {
5648
5771
  if (typeof value !== "number") {
5649
- throw new ERR_INVALID_ARG_TYPE(name, "number", value);
5772
+ throw new ERR_INVALID_ARG_TYPE2(name, "number", value);
5650
5773
  }
5651
5774
  if (!NumberIsInteger(value)) {
5652
5775
  throw new ERR_OUT_OF_RANGE(name, "an integer", value);
@@ -5657,7 +5780,7 @@ var require_validators = __commonJS({
5657
5780
  });
5658
5781
  var validateUint32 = hideStackFrames((value, name, positive = false) => {
5659
5782
  if (typeof value !== "number") {
5660
- throw new ERR_INVALID_ARG_TYPE(name, "number", value);
5783
+ throw new ERR_INVALID_ARG_TYPE2(name, "number", value);
5661
5784
  }
5662
5785
  if (!NumberIsInteger(value)) {
5663
5786
  throw new ERR_OUT_OF_RANGE(name, "an integer", value);
@@ -5670,11 +5793,11 @@ var require_validators = __commonJS({
5670
5793
  });
5671
5794
  function validateString(value, name) {
5672
5795
  if (typeof value !== "string")
5673
- throw new ERR_INVALID_ARG_TYPE(name, "string", value);
5796
+ throw new ERR_INVALID_ARG_TYPE2(name, "string", value);
5674
5797
  }
5675
5798
  function validateNumber(value, name, min = void 0, max) {
5676
5799
  if (typeof value !== "number")
5677
- throw new ERR_INVALID_ARG_TYPE(name, "number", value);
5800
+ throw new ERR_INVALID_ARG_TYPE2(name, "number", value);
5678
5801
  if (min != null && value < min || max != null && value > max || (min != null || max != null) && NumberIsNaN(value)) {
5679
5802
  throw new ERR_OUT_OF_RANGE(
5680
5803
  name,
@@ -5695,7 +5818,7 @@ var require_validators = __commonJS({
5695
5818
  });
5696
5819
  function validateBoolean(value, name) {
5697
5820
  if (typeof value !== "boolean")
5698
- throw new ERR_INVALID_ARG_TYPE(name, "boolean", value);
5821
+ throw new ERR_INVALID_ARG_TYPE2(name, "boolean", value);
5699
5822
  }
5700
5823
  function getOwnPropertyValueOrDefault(options, key, defaultValue) {
5701
5824
  return options == null || !ObjectPrototypeHasOwnProperty(options, key) ? defaultValue : options[key];
@@ -5705,17 +5828,17 @@ var require_validators = __commonJS({
5705
5828
  const allowFunction = getOwnPropertyValueOrDefault(options, "allowFunction", false);
5706
5829
  const nullable = getOwnPropertyValueOrDefault(options, "nullable", false);
5707
5830
  if (!nullable && value === null || !allowArray && ArrayIsArray(value) || typeof value !== "object" && (!allowFunction || typeof value !== "function")) {
5708
- throw new ERR_INVALID_ARG_TYPE(name, "Object", value);
5831
+ throw new ERR_INVALID_ARG_TYPE2(name, "Object", value);
5709
5832
  }
5710
5833
  });
5711
5834
  var validateDictionary = hideStackFrames((value, name) => {
5712
5835
  if (value != null && typeof value !== "object" && typeof value !== "function") {
5713
- throw new ERR_INVALID_ARG_TYPE(name, "a dictionary", value);
5836
+ throw new ERR_INVALID_ARG_TYPE2(name, "a dictionary", value);
5714
5837
  }
5715
5838
  });
5716
5839
  var validateArray = hideStackFrames((value, name, minLength = 0) => {
5717
5840
  if (!ArrayIsArray(value)) {
5718
- throw new ERR_INVALID_ARG_TYPE(name, "Array", value);
5841
+ throw new ERR_INVALID_ARG_TYPE2(name, "Array", value);
5719
5842
  }
5720
5843
  if (value.length < minLength) {
5721
5844
  const reason = `must be longer than ${minLength}`;
@@ -5734,6 +5857,17 @@ var require_validators = __commonJS({
5734
5857
  validateBoolean(value[i], `${name}[${i}]`);
5735
5858
  }
5736
5859
  }
5860
+ function validateAbortSignalArray(value, name) {
5861
+ validateArray(value, name);
5862
+ for (let i = 0; i < value.length; i++) {
5863
+ const signal = value[i];
5864
+ const indexedName = `${name}[${i}]`;
5865
+ if (signal == null) {
5866
+ throw new ERR_INVALID_ARG_TYPE2(indexedName, "AbortSignal", signal);
5867
+ }
5868
+ validateAbortSignal(signal, indexedName);
5869
+ }
5870
+ }
5737
5871
  function validateSignalName(signal, name = "signal") {
5738
5872
  validateString(signal, name);
5739
5873
  if (signals[signal] === void 0) {
@@ -5745,7 +5879,7 @@ var require_validators = __commonJS({
5745
5879
  }
5746
5880
  var validateBuffer = hideStackFrames((buffer, name = "buffer") => {
5747
5881
  if (!isArrayBufferView(buffer)) {
5748
- throw new ERR_INVALID_ARG_TYPE(name, ["Buffer", "TypedArray", "DataView"], buffer);
5882
+ throw new ERR_INVALID_ARG_TYPE2(name, ["Buffer", "TypedArray", "DataView"], buffer);
5749
5883
  }
5750
5884
  });
5751
5885
  function validateEncoding(data, encoding) {
@@ -5763,24 +5897,24 @@ var require_validators = __commonJS({
5763
5897
  }
5764
5898
  var validateAbortSignal = hideStackFrames((signal, name) => {
5765
5899
  if (signal !== void 0 && (signal === null || typeof signal !== "object" || !("aborted" in signal))) {
5766
- throw new ERR_INVALID_ARG_TYPE(name, "AbortSignal", signal);
5900
+ throw new ERR_INVALID_ARG_TYPE2(name, "AbortSignal", signal);
5767
5901
  }
5768
5902
  });
5769
5903
  var validateFunction = hideStackFrames((value, name) => {
5770
5904
  if (typeof value !== "function")
5771
- throw new ERR_INVALID_ARG_TYPE(name, "Function", value);
5905
+ throw new ERR_INVALID_ARG_TYPE2(name, "Function", value);
5772
5906
  });
5773
5907
  var validatePlainFunction = hideStackFrames((value, name) => {
5774
5908
  if (typeof value !== "function" || isAsyncFunction(value))
5775
- throw new ERR_INVALID_ARG_TYPE(name, "Function", value);
5909
+ throw new ERR_INVALID_ARG_TYPE2(name, "Function", value);
5776
5910
  });
5777
5911
  var validateUndefined = hideStackFrames((value, name) => {
5778
5912
  if (value !== void 0)
5779
- throw new ERR_INVALID_ARG_TYPE(name, "undefined", value);
5913
+ throw new ERR_INVALID_ARG_TYPE2(name, "undefined", value);
5780
5914
  });
5781
5915
  function validateUnion(value, name, union) {
5782
5916
  if (!ArrayPrototypeIncludes(union, value)) {
5783
- throw new ERR_INVALID_ARG_TYPE(name, `('${ArrayPrototypeJoin(union, "|")}')`, value);
5917
+ throw new ERR_INVALID_ARG_TYPE2(name, `('${ArrayPrototypeJoin(union, "|")}')`, value);
5784
5918
  }
5785
5919
  }
5786
5920
  var linkValueRegExp = /^(?:<[^>]*>)(?:\s*;\s*[^;"\s]+(?:=(")?[^;"\s]*\1)?)*$/;
@@ -5826,6 +5960,7 @@ var require_validators = __commonJS({
5826
5960
  validateArray,
5827
5961
  validateStringArray,
5828
5962
  validateBooleanArray,
5963
+ validateAbortSignalArray,
5829
5964
  validateBoolean,
5830
5965
  validateBuffer,
5831
5966
  validateDictionary,
@@ -5860,11 +5995,12 @@ var require_process = __commonJS({
5860
5995
  var require_utils = __commonJS({
5861
5996
  "node_modules/pino-abstract-transport/node_modules/readable-stream/lib/internal/streams/utils.js"(exports2, module2) {
5862
5997
  "use strict";
5863
- var { Symbol: Symbol2, SymbolAsyncIterator, SymbolIterator, SymbolFor } = require_primordials();
5864
- var kDestroyed = Symbol2("kDestroyed");
5865
- var kIsErrored = Symbol2("kIsErrored");
5866
- var kIsReadable = Symbol2("kIsReadable");
5867
- var kIsDisturbed = Symbol2("kIsDisturbed");
5998
+ var { SymbolAsyncIterator, SymbolIterator, SymbolFor } = require_primordials();
5999
+ var kIsDestroyed = SymbolFor("nodejs.stream.destroyed");
6000
+ var kIsErrored = SymbolFor("nodejs.stream.errored");
6001
+ var kIsReadable = SymbolFor("nodejs.stream.readable");
6002
+ var kIsWritable = SymbolFor("nodejs.stream.writable");
6003
+ var kIsDisturbed = SymbolFor("nodejs.stream.disturbed");
5868
6004
  var kIsClosedPromise = SymbolFor("nodejs.webstream.isClosedPromise");
5869
6005
  var kControllerErrorFunction = SymbolFor("nodejs.webstream.controllerErrorFunction");
5870
6006
  function isReadableNodeStream(obj, strict = false) {
@@ -5909,7 +6045,7 @@ var require_utils = __commonJS({
5909
6045
  const wState = stream._writableState;
5910
6046
  const rState = stream._readableState;
5911
6047
  const state = wState || rState;
5912
- return !!(stream.destroyed || stream[kDestroyed] || state !== null && state !== void 0 && state.destroyed);
6048
+ return !!(stream.destroyed || stream[kIsDestroyed] || state !== null && state !== void 0 && state.destroyed);
5913
6049
  }
5914
6050
  function isWritableEnded(stream) {
5915
6051
  if (!isWritableNodeStream(stream))
@@ -5967,6 +6103,8 @@ var require_utils = __commonJS({
5967
6103
  return isReadableNodeStream(stream) && stream.readable && !isReadableFinished(stream);
5968
6104
  }
5969
6105
  function isWritable(stream) {
6106
+ if (stream && stream[kIsWritable] != null)
6107
+ return stream[kIsWritable];
5970
6108
  if (typeof (stream === null || stream === void 0 ? void 0 : stream.writable) !== "boolean")
5971
6109
  return null;
5972
6110
  if (isDestroyed(stream))
@@ -6052,7 +6190,8 @@ var require_utils = __commonJS({
6052
6190
  return !!(stream && ((_ref = (_ref2 = (_ref3 = (_ref4 = (_ref5 = (_stream$kIsErrored = stream[kIsErrored]) !== null && _stream$kIsErrored !== void 0 ? _stream$kIsErrored : stream.readableErrored) !== null && _ref5 !== void 0 ? _ref5 : stream.writableErrored) !== null && _ref4 !== void 0 ? _ref4 : (_stream$_readableStat3 = stream._readableState) === null || _stream$_readableStat3 === void 0 ? void 0 : _stream$_readableStat3.errorEmitted) !== null && _ref3 !== void 0 ? _ref3 : (_stream$_writableStat3 = stream._writableState) === null || _stream$_writableStat3 === void 0 ? void 0 : _stream$_writableStat3.errorEmitted) !== null && _ref2 !== void 0 ? _ref2 : (_stream$_readableStat4 = stream._readableState) === null || _stream$_readableStat4 === void 0 ? void 0 : _stream$_readableStat4.errored) !== null && _ref !== void 0 ? _ref : (_stream$_writableStat4 = stream._writableState) === null || _stream$_writableStat4 === void 0 ? void 0 : _stream$_writableStat4.errored));
6053
6191
  }
6054
6192
  module2.exports = {
6055
- kDestroyed,
6193
+ isDestroyed,
6194
+ kIsDestroyed,
6056
6195
  isDisturbed,
6057
6196
  kIsDisturbed,
6058
6197
  isErrored,
@@ -6061,8 +6200,8 @@ var require_utils = __commonJS({
6061
6200
  kIsReadable,
6062
6201
  kIsClosedPromise,
6063
6202
  kControllerErrorFunction,
6203
+ kIsWritable,
6064
6204
  isClosed,
6065
- isDestroyed,
6066
6205
  isDuplexNodeStream,
6067
6206
  isFinished,
6068
6207
  isIterable,
@@ -6092,10 +6231,10 @@ var require_end_of_stream = __commonJS({
6092
6231
  "node_modules/pino-abstract-transport/node_modules/readable-stream/lib/internal/streams/end-of-stream.js"(exports2, module2) {
6093
6232
  var process2 = require_process();
6094
6233
  var { AbortError, codes } = require_errors();
6095
- var { ERR_INVALID_ARG_TYPE, ERR_STREAM_PREMATURE_CLOSE } = codes;
6234
+ var { ERR_INVALID_ARG_TYPE: ERR_INVALID_ARG_TYPE2, ERR_STREAM_PREMATURE_CLOSE } = codes;
6096
6235
  var { kEmptyObject, once } = require_util();
6097
6236
  var { validateAbortSignal, validateFunction, validateObject, validateBoolean } = require_validators();
6098
- var { Promise: Promise2, PromisePrototypeThen } = require_primordials();
6237
+ var { Promise: Promise2, PromisePrototypeThen, SymbolDispose } = require_primordials();
6099
6238
  var {
6100
6239
  isClosed,
6101
6240
  isReadable,
@@ -6112,6 +6251,7 @@ var require_end_of_stream = __commonJS({
6112
6251
  willEmitClose: _willEmitClose,
6113
6252
  kIsClosedPromise
6114
6253
  } = require_utils();
6254
+ var addAbortListener;
6115
6255
  function isRequest(stream) {
6116
6256
  return stream.setHeader && typeof stream.abort === "function";
6117
6257
  }
@@ -6134,7 +6274,7 @@ var require_end_of_stream = __commonJS({
6134
6274
  return eosWeb(stream, options, callback);
6135
6275
  }
6136
6276
  if (!isNodeStream(stream)) {
6137
- throw new ERR_INVALID_ARG_TYPE("stream", ["ReadableStream", "WritableStream", "Stream"], stream);
6277
+ throw new ERR_INVALID_ARG_TYPE2("stream", ["ReadableStream", "WritableStream", "Stream"], stream);
6138
6278
  }
6139
6279
  const readable = (_options$readable = options.readable) !== null && _options$readable !== void 0 ? _options$readable : isReadableNodeStream(stream);
6140
6280
  const writable = (_options$writable = options.writable) !== null && _options$writable !== void 0 ? _options$writable : isWritableNodeStream(stream);
@@ -6268,12 +6408,13 @@ var require_end_of_stream = __commonJS({
6268
6408
  if (options.signal.aborted) {
6269
6409
  process2.nextTick(abort);
6270
6410
  } else {
6411
+ addAbortListener = addAbortListener || require_util().addAbortListener;
6412
+ const disposable = addAbortListener(options.signal, abort);
6271
6413
  const originalCallback = callback;
6272
6414
  callback = once((...args) => {
6273
- options.signal.removeEventListener("abort", abort);
6415
+ disposable[SymbolDispose]();
6274
6416
  originalCallback.apply(stream, args);
6275
6417
  });
6276
- options.signal.addEventListener("abort", abort);
6277
6418
  }
6278
6419
  }
6279
6420
  return cleanup;
@@ -6294,12 +6435,13 @@ var require_end_of_stream = __commonJS({
6294
6435
  if (options.signal.aborted) {
6295
6436
  process2.nextTick(abort);
6296
6437
  } else {
6438
+ addAbortListener = addAbortListener || require_util().addAbortListener;
6439
+ const disposable = addAbortListener(options.signal, abort);
6297
6440
  const originalCallback = callback;
6298
6441
  callback = once((...args) => {
6299
- options.signal.removeEventListener("abort", abort);
6442
+ disposable[SymbolDispose]();
6300
6443
  originalCallback.apply(stream, args);
6301
6444
  });
6302
- options.signal.addEventListener("abort", abort);
6303
6445
  }
6304
6446
  }
6305
6447
  const resolverFn = (...args) => {
@@ -6349,7 +6491,7 @@ var require_destroy = __commonJS({
6349
6491
  AbortError
6350
6492
  } = require_errors();
6351
6493
  var { Symbol: Symbol2 } = require_primordials();
6352
- var { kDestroyed, isDestroyed, isFinished, isServerRequest } = require_utils();
6494
+ var { kIsDestroyed, isDestroyed, isFinished, isServerRequest } = require_utils();
6353
6495
  var kDestroy = Symbol2("kDestroy");
6354
6496
  var kConstruct = Symbol2("kConstruct");
6355
6497
  function checkError(err, w, r) {
@@ -6590,7 +6732,7 @@ var require_destroy = __commonJS({
6590
6732
  process2.nextTick(emitCloseLegacy, stream);
6591
6733
  }
6592
6734
  if (!stream.destroyed) {
6593
- stream[kDestroyed] = true;
6735
+ stream[kIsDestroyed] = true;
6594
6736
  }
6595
6737
  }
6596
6738
  module2.exports = {
@@ -6692,19 +6834,21 @@ var require_legacy = __commonJS({
6692
6834
  var require_add_abort_signal = __commonJS({
6693
6835
  "node_modules/pino-abstract-transport/node_modules/readable-stream/lib/internal/streams/add-abort-signal.js"(exports2, module2) {
6694
6836
  "use strict";
6837
+ var { SymbolDispose } = require_primordials();
6695
6838
  var { AbortError, codes } = require_errors();
6696
6839
  var { isNodeStream, isWebStream, kControllerErrorFunction } = require_utils();
6697
6840
  var eos = require_end_of_stream();
6698
- var { ERR_INVALID_ARG_TYPE } = codes;
6841
+ var { ERR_INVALID_ARG_TYPE: ERR_INVALID_ARG_TYPE2 } = codes;
6842
+ var addAbortListener;
6699
6843
  var validateAbortSignal = (signal, name) => {
6700
6844
  if (typeof signal !== "object" || !("aborted" in signal)) {
6701
- throw new ERR_INVALID_ARG_TYPE(name, "AbortSignal", signal);
6845
+ throw new ERR_INVALID_ARG_TYPE2(name, "AbortSignal", signal);
6702
6846
  }
6703
6847
  };
6704
6848
  module2.exports.addAbortSignal = function addAbortSignal(signal, stream) {
6705
6849
  validateAbortSignal(signal, "signal");
6706
6850
  if (!isNodeStream(stream) && !isWebStream(stream)) {
6707
- throw new ERR_INVALID_ARG_TYPE("stream", ["ReadableStream", "WritableStream", "Stream"], stream);
6851
+ throw new ERR_INVALID_ARG_TYPE2("stream", ["ReadableStream", "WritableStream", "Stream"], stream);
6708
6852
  }
6709
6853
  return module2.exports.addAbortSignalNoValidate(signal, stream);
6710
6854
  };
@@ -6728,8 +6872,9 @@ var require_add_abort_signal = __commonJS({
6728
6872
  if (signal.aborted) {
6729
6873
  onAbort();
6730
6874
  } else {
6731
- signal.addEventListener("abort", onAbort);
6732
- eos(stream, () => signal.removeEventListener("abort", onAbort));
6875
+ addAbortListener = addAbortListener || require_util().addAbortListener;
6876
+ const disposable = addAbortListener(signal, onAbort);
6877
+ eos(stream, disposable[SymbolDispose]);
6733
6878
  }
6734
6879
  return stream;
6735
6880
  };
@@ -6909,12 +7054,23 @@ var require_state2 = __commonJS({
6909
7054
  "node_modules/pino-abstract-transport/node_modules/readable-stream/lib/internal/streams/state.js"(exports2, module2) {
6910
7055
  "use strict";
6911
7056
  var { MathFloor, NumberIsInteger } = require_primordials();
7057
+ var { validateInteger } = require_validators();
6912
7058
  var { ERR_INVALID_ARG_VALUE } = require_errors().codes;
7059
+ var defaultHighWaterMarkBytes = 16 * 1024;
7060
+ var defaultHighWaterMarkObjectMode = 16;
6913
7061
  function highWaterMarkFrom(options, isDuplex, duplexKey) {
6914
7062
  return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
6915
7063
  }
6916
7064
  function getDefaultHighWaterMark(objectMode) {
6917
- return objectMode ? 16 : 16 * 1024;
7065
+ return objectMode ? defaultHighWaterMarkObjectMode : defaultHighWaterMarkBytes;
7066
+ }
7067
+ function setDefaultHighWaterMark(objectMode, value) {
7068
+ validateInteger(value, "value", 0);
7069
+ if (objectMode) {
7070
+ defaultHighWaterMarkObjectMode = value;
7071
+ } else {
7072
+ defaultHighWaterMarkBytes = value;
7073
+ }
6918
7074
  }
6919
7075
  function getHighWaterMark(state, options, duplexKey, isDuplex) {
6920
7076
  const hwm = highWaterMarkFrom(options, isDuplex, duplexKey);
@@ -6929,7 +7085,8 @@ var require_state2 = __commonJS({
6929
7085
  }
6930
7086
  module2.exports = {
6931
7087
  getHighWaterMark,
6932
- getDefaultHighWaterMark
7088
+ getDefaultHighWaterMark,
7089
+ setDefaultHighWaterMark
6933
7090
  };
6934
7091
  }
6935
7092
  });
@@ -6941,7 +7098,7 @@ var require_from = __commonJS({
6941
7098
  var process2 = require_process();
6942
7099
  var { PromisePrototypeThen, SymbolAsyncIterator, SymbolIterator } = require_primordials();
6943
7100
  var { Buffer: Buffer2 } = require("buffer");
6944
- var { ERR_INVALID_ARG_TYPE, ERR_STREAM_NULL_VALUES } = require_errors().codes;
7101
+ var { ERR_INVALID_ARG_TYPE: ERR_INVALID_ARG_TYPE2, ERR_STREAM_NULL_VALUES } = require_errors().codes;
6945
7102
  function from(Readable, iterable, opts) {
6946
7103
  let iterator;
6947
7104
  if (typeof iterable === "string" || iterable instanceof Buffer2) {
@@ -6962,7 +7119,7 @@ var require_from = __commonJS({
6962
7119
  isAsync = false;
6963
7120
  iterator = iterable[SymbolIterator]();
6964
7121
  } else {
6965
- throw new ERR_INVALID_ARG_TYPE("iterable", ["Iterable"], iterable);
7122
+ throw new ERR_INVALID_ARG_TYPE2("iterable", ["Iterable"], iterable);
6966
7123
  }
6967
7124
  const readable = new Readable({
6968
7125
  objectMode: true,
@@ -7043,6 +7200,7 @@ var require_readable = __commonJS({
7043
7200
  ObjectSetPrototypeOf,
7044
7201
  Promise: Promise2,
7045
7202
  SafeSet,
7203
+ SymbolAsyncDispose,
7046
7204
  SymbolAsyncIterator,
7047
7205
  Symbol: Symbol2
7048
7206
  } = require_primordials();
@@ -7062,12 +7220,13 @@ var require_readable = __commonJS({
7062
7220
  var {
7063
7221
  aggregateTwoErrors,
7064
7222
  codes: {
7065
- ERR_INVALID_ARG_TYPE,
7223
+ ERR_INVALID_ARG_TYPE: ERR_INVALID_ARG_TYPE2,
7066
7224
  ERR_METHOD_NOT_IMPLEMENTED,
7067
7225
  ERR_OUT_OF_RANGE,
7068
7226
  ERR_STREAM_PUSH_AFTER_EOF,
7069
7227
  ERR_STREAM_UNSHIFT_AFTER_END_EVENT
7070
- }
7228
+ },
7229
+ AbortError
7071
7230
  } = require_errors();
7072
7231
  var { validateObject } = require_validators();
7073
7232
  var kPaused = Symbol2("kPaused");
@@ -7078,39 +7237,97 @@ var require_readable = __commonJS({
7078
7237
  var nop = () => {
7079
7238
  };
7080
7239
  var { errorOrDestroy } = destroyImpl;
7240
+ var kObjectMode = 1 << 0;
7241
+ var kEnded = 1 << 1;
7242
+ var kEndEmitted = 1 << 2;
7243
+ var kReading = 1 << 3;
7244
+ var kConstructed = 1 << 4;
7245
+ var kSync = 1 << 5;
7246
+ var kNeedReadable = 1 << 6;
7247
+ var kEmittedReadable = 1 << 7;
7248
+ var kReadableListening = 1 << 8;
7249
+ var kResumeScheduled = 1 << 9;
7250
+ var kErrorEmitted = 1 << 10;
7251
+ var kEmitClose = 1 << 11;
7252
+ var kAutoDestroy = 1 << 12;
7253
+ var kDestroyed = 1 << 13;
7254
+ var kClosed = 1 << 14;
7255
+ var kCloseEmitted = 1 << 15;
7256
+ var kMultiAwaitDrain = 1 << 16;
7257
+ var kReadingMore = 1 << 17;
7258
+ var kDataEmitted = 1 << 18;
7259
+ function makeBitMapDescriptor(bit) {
7260
+ return {
7261
+ enumerable: false,
7262
+ get() {
7263
+ return (this.state & bit) !== 0;
7264
+ },
7265
+ set(value) {
7266
+ if (value)
7267
+ this.state |= bit;
7268
+ else
7269
+ this.state &= ~bit;
7270
+ }
7271
+ };
7272
+ }
7273
+ ObjectDefineProperties(ReadableState.prototype, {
7274
+ objectMode: makeBitMapDescriptor(kObjectMode),
7275
+ ended: makeBitMapDescriptor(kEnded),
7276
+ endEmitted: makeBitMapDescriptor(kEndEmitted),
7277
+ reading: makeBitMapDescriptor(kReading),
7278
+ // Stream is still being constructed and cannot be
7279
+ // destroyed until construction finished or failed.
7280
+ // Async construction is opt in, therefore we start as
7281
+ // constructed.
7282
+ constructed: makeBitMapDescriptor(kConstructed),
7283
+ // A flag to be able to tell if the event 'readable'/'data' is emitted
7284
+ // immediately, or on a later tick. We set this to true at first, because
7285
+ // any actions that shouldn't happen until "later" should generally also
7286
+ // not happen before the first read call.
7287
+ sync: makeBitMapDescriptor(kSync),
7288
+ // Whenever we return null, then we set a flag to say
7289
+ // that we're awaiting a 'readable' event emission.
7290
+ needReadable: makeBitMapDescriptor(kNeedReadable),
7291
+ emittedReadable: makeBitMapDescriptor(kEmittedReadable),
7292
+ readableListening: makeBitMapDescriptor(kReadableListening),
7293
+ resumeScheduled: makeBitMapDescriptor(kResumeScheduled),
7294
+ // True if the error was already emitted and should not be thrown again.
7295
+ errorEmitted: makeBitMapDescriptor(kErrorEmitted),
7296
+ emitClose: makeBitMapDescriptor(kEmitClose),
7297
+ autoDestroy: makeBitMapDescriptor(kAutoDestroy),
7298
+ // Has it been destroyed.
7299
+ destroyed: makeBitMapDescriptor(kDestroyed),
7300
+ // Indicates whether the stream has finished destroying.
7301
+ closed: makeBitMapDescriptor(kClosed),
7302
+ // True if close has been emitted or would have been emitted
7303
+ // depending on emitClose.
7304
+ closeEmitted: makeBitMapDescriptor(kCloseEmitted),
7305
+ multiAwaitDrain: makeBitMapDescriptor(kMultiAwaitDrain),
7306
+ // If true, a maybeReadMore has been scheduled.
7307
+ readingMore: makeBitMapDescriptor(kReadingMore),
7308
+ dataEmitted: makeBitMapDescriptor(kDataEmitted)
7309
+ });
7081
7310
  function ReadableState(options, stream, isDuplex) {
7082
7311
  if (typeof isDuplex !== "boolean")
7083
7312
  isDuplex = stream instanceof require_duplex();
7084
- this.objectMode = !!(options && options.objectMode);
7085
- if (isDuplex)
7086
- this.objectMode = this.objectMode || !!(options && options.readableObjectMode);
7313
+ this.state = kEmitClose | kAutoDestroy | kConstructed | kSync;
7314
+ if (options && options.objectMode)
7315
+ this.state |= kObjectMode;
7316
+ if (isDuplex && options && options.readableObjectMode)
7317
+ this.state |= kObjectMode;
7087
7318
  this.highWaterMark = options ? getHighWaterMark(this, options, "readableHighWaterMark", isDuplex) : getDefaultHighWaterMark(false);
7088
7319
  this.buffer = new BufferList();
7089
7320
  this.length = 0;
7090
7321
  this.pipes = [];
7091
7322
  this.flowing = null;
7092
- this.ended = false;
7093
- this.endEmitted = false;
7094
- this.reading = false;
7095
- this.constructed = true;
7096
- this.sync = true;
7097
- this.needReadable = false;
7098
- this.emittedReadable = false;
7099
- this.readableListening = false;
7100
- this.resumeScheduled = false;
7101
7323
  this[kPaused] = null;
7102
- this.errorEmitted = false;
7103
- this.emitClose = !options || options.emitClose !== false;
7104
- this.autoDestroy = !options || options.autoDestroy !== false;
7105
- this.destroyed = false;
7324
+ if (options && options.emitClose === false)
7325
+ this.state &= ~kEmitClose;
7326
+ if (options && options.autoDestroy === false)
7327
+ this.state &= ~kAutoDestroy;
7106
7328
  this.errored = null;
7107
- this.closed = false;
7108
- this.closeEmitted = false;
7109
7329
  this.defaultEncoding = options && options.defaultEncoding || "utf8";
7110
7330
  this.awaitDrainWriters = null;
7111
- this.multiAwaitDrain = false;
7112
- this.readingMore = false;
7113
- this.dataEmitted = false;
7114
7331
  this.decoder = null;
7115
7332
  this.encoding = null;
7116
7333
  if (options && options.encoding) {
@@ -7148,6 +7365,14 @@ var require_readable = __commonJS({
7148
7365
  Readable.prototype[EE.captureRejectionSymbol] = function(err) {
7149
7366
  this.destroy(err);
7150
7367
  };
7368
+ Readable.prototype[SymbolAsyncDispose] = function() {
7369
+ let error;
7370
+ if (!this.destroyed) {
7371
+ error = this.readableEnded ? null : new AbortError();
7372
+ this.destroy(error);
7373
+ }
7374
+ return new Promise2((resolve, reject) => eos(this, (err) => err && err !== error ? reject(err) : resolve(null)));
7375
+ };
7151
7376
  Readable.prototype.push = function(chunk, encoding) {
7152
7377
  return readableAddChunk(this, chunk, encoding, false);
7153
7378
  };
@@ -7158,7 +7383,7 @@ var require_readable = __commonJS({
7158
7383
  debug("readableAddChunk", chunk);
7159
7384
  const state = stream._readableState;
7160
7385
  let err;
7161
- if (!state.objectMode) {
7386
+ if ((state.state & kObjectMode) === 0) {
7162
7387
  if (typeof chunk === "string") {
7163
7388
  encoding = encoding || state.defaultEncoding;
7164
7389
  if (state.encoding !== encoding) {
@@ -7175,17 +7400,17 @@ var require_readable = __commonJS({
7175
7400
  chunk = Stream._uint8ArrayToBuffer(chunk);
7176
7401
  encoding = "";
7177
7402
  } else if (chunk != null) {
7178
- err = new ERR_INVALID_ARG_TYPE("chunk", ["string", "Buffer", "Uint8Array"], chunk);
7403
+ err = new ERR_INVALID_ARG_TYPE2("chunk", ["string", "Buffer", "Uint8Array"], chunk);
7179
7404
  }
7180
7405
  }
7181
7406
  if (err) {
7182
7407
  errorOrDestroy(stream, err);
7183
7408
  } else if (chunk === null) {
7184
- state.reading = false;
7409
+ state.state &= ~kReading;
7185
7410
  onEofChunk(stream, state);
7186
- } else if (state.objectMode || chunk && chunk.length > 0) {
7411
+ } else if ((state.state & kObjectMode) !== 0 || chunk && chunk.length > 0) {
7187
7412
  if (addToFront) {
7188
- if (state.endEmitted)
7413
+ if ((state.state & kEndEmitted) !== 0)
7189
7414
  errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());
7190
7415
  else if (state.destroyed || state.errored)
7191
7416
  return false;
@@ -7196,7 +7421,7 @@ var require_readable = __commonJS({
7196
7421
  } else if (state.destroyed || state.errored) {
7197
7422
  return false;
7198
7423
  } else {
7199
- state.reading = false;
7424
+ state.state &= ~kReading;
7200
7425
  if (state.decoder && !encoding) {
7201
7426
  chunk = state.decoder.write(chunk);
7202
7427
  if (state.objectMode || chunk.length !== 0)
@@ -7208,14 +7433,14 @@ var require_readable = __commonJS({
7208
7433
  }
7209
7434
  }
7210
7435
  } else if (!addToFront) {
7211
- state.reading = false;
7436
+ state.state &= ~kReading;
7212
7437
  maybeReadMore(stream, state);
7213
7438
  }
7214
7439
  return !state.ended && (state.length < state.highWaterMark || state.length === 0);
7215
7440
  }
7216
7441
  function addChunk(stream, state, chunk, addToFront) {
7217
7442
  if (state.flowing && state.length === 0 && !state.sync && stream.listenerCount("data") > 0) {
7218
- if (state.multiAwaitDrain) {
7443
+ if ((state.state & kMultiAwaitDrain) !== 0) {
7219
7444
  state.awaitDrainWriters.clear();
7220
7445
  } else {
7221
7446
  state.awaitDrainWriters = null;
@@ -7228,7 +7453,7 @@ var require_readable = __commonJS({
7228
7453
  state.buffer.unshift(chunk);
7229
7454
  else
7230
7455
  state.buffer.push(chunk);
7231
- if (state.needReadable)
7456
+ if ((state.state & kNeedReadable) !== 0)
7232
7457
  emitReadable(stream);
7233
7458
  }
7234
7459
  maybeReadMore(stream, state);
@@ -7270,7 +7495,7 @@ var require_readable = __commonJS({
7270
7495
  function howMuchToRead(n, state) {
7271
7496
  if (n <= 0 || state.length === 0 && state.ended)
7272
7497
  return 0;
7273
- if (state.objectMode)
7498
+ if ((state.state & kObjectMode) !== 0)
7274
7499
  return 1;
7275
7500
  if (NumberIsNaN(n)) {
7276
7501
  if (state.flowing && state.length)
@@ -7293,7 +7518,7 @@ var require_readable = __commonJS({
7293
7518
  if (n > state.highWaterMark)
7294
7519
  state.highWaterMark = computeNewHighWaterMark(n);
7295
7520
  if (n !== 0)
7296
- state.emittedReadable = false;
7521
+ state.state &= ~kEmittedReadable;
7297
7522
  if (n === 0 && state.needReadable && ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || state.ended)) {
7298
7523
  debug("read: emitReadable", state.length, state.ended);
7299
7524
  if (state.length === 0 && state.ended)
@@ -7308,7 +7533,7 @@ var require_readable = __commonJS({
7308
7533
  endReadable(this);
7309
7534
  return null;
7310
7535
  }
7311
- let doRead = state.needReadable;
7536
+ let doRead = (state.state & kNeedReadable) !== 0;
7312
7537
  debug("need readable", doRead);
7313
7538
  if (state.length === 0 || state.length - n < state.highWaterMark) {
7314
7539
  doRead = true;
@@ -7319,16 +7544,15 @@ var require_readable = __commonJS({
7319
7544
  debug("reading, ended or constructing", doRead);
7320
7545
  } else if (doRead) {
7321
7546
  debug("do read");
7322
- state.reading = true;
7323
- state.sync = true;
7547
+ state.state |= kReading | kSync;
7324
7548
  if (state.length === 0)
7325
- state.needReadable = true;
7549
+ state.state |= kNeedReadable;
7326
7550
  try {
7327
7551
  this._read(state.highWaterMark);
7328
7552
  } catch (err) {
7329
7553
  errorOrDestroy(this, err);
7330
7554
  }
7331
- state.sync = false;
7555
+ state.state &= ~kSync;
7332
7556
  if (!state.reading)
7333
7557
  n = howMuchToRead(nOrig, state);
7334
7558
  }
@@ -7525,9 +7749,7 @@ var require_readable = __commonJS({
7525
7749
  }
7526
7750
  dest.emit("pipe", src);
7527
7751
  if (dest.writableNeedDrain === true) {
7528
- if (state.flowing) {
7529
- pause();
7530
- }
7752
+ pause();
7531
7753
  } else if (!state.flowing) {
7532
7754
  debug("pipe resume");
7533
7755
  src.resume();
@@ -8005,7 +8227,7 @@ var require_writable = __commonJS({
8005
8227
  var { addAbortSignal } = require_add_abort_signal();
8006
8228
  var { getHighWaterMark, getDefaultHighWaterMark } = require_state2();
8007
8229
  var {
8008
- ERR_INVALID_ARG_TYPE,
8230
+ ERR_INVALID_ARG_TYPE: ERR_INVALID_ARG_TYPE2,
8009
8231
  ERR_METHOD_NOT_IMPLEMENTED,
8010
8232
  ERR_MULTIPLE_CALLBACK,
8011
8233
  ERR_STREAM_CANNOT_PIPE,
@@ -8141,7 +8363,7 @@ var require_writable = __commonJS({
8141
8363
  chunk = Stream._uint8ArrayToBuffer(chunk);
8142
8364
  encoding = "buffer";
8143
8365
  } else {
8144
- throw new ERR_INVALID_ARG_TYPE("chunk", ["string", "Buffer", "Uint8Array"], chunk);
8366
+ throw new ERR_INVALID_ARG_TYPE2("chunk", ["string", "Buffer", "Uint8Array"], chunk);
8145
8367
  }
8146
8368
  }
8147
8369
  let err;
@@ -8636,16 +8858,19 @@ var require_duplexify = __commonJS({
8636
8858
  isNodeStream,
8637
8859
  isReadableNodeStream,
8638
8860
  isWritableNodeStream,
8639
- isDuplexNodeStream
8861
+ isDuplexNodeStream,
8862
+ isReadableStream,
8863
+ isWritableStream
8640
8864
  } = require_utils();
8641
8865
  var eos = require_end_of_stream();
8642
8866
  var {
8643
8867
  AbortError,
8644
- codes: { ERR_INVALID_ARG_TYPE, ERR_INVALID_RETURN_VALUE }
8868
+ codes: { ERR_INVALID_ARG_TYPE: ERR_INVALID_ARG_TYPE2, ERR_INVALID_RETURN_VALUE }
8645
8869
  } = require_errors();
8646
8870
  var { destroyer } = require_destroy();
8647
8871
  var Duplex = require_duplex();
8648
8872
  var Readable = require_readable();
8873
+ var Writable = require_writable();
8649
8874
  var { createDeferredPromise } = require_util();
8650
8875
  var from = require_from();
8651
8876
  var Blob = globalThis.Blob || bufferModule.Blob;
@@ -8692,6 +8917,16 @@ var require_duplexify = __commonJS({
8692
8917
  readable: false
8693
8918
  });
8694
8919
  }
8920
+ if (isReadableStream(body)) {
8921
+ return _duplexify({
8922
+ readable: Readable.fromWeb(body)
8923
+ });
8924
+ }
8925
+ if (isWritableStream(body)) {
8926
+ return _duplexify({
8927
+ writable: Writable.fromWeb(body)
8928
+ });
8929
+ }
8695
8930
  if (typeof body === "function") {
8696
8931
  const { value, write, final, destroy } = fromAsyncGen(body);
8697
8932
  if (isIterable(value)) {
@@ -8748,6 +8983,9 @@ var require_duplexify = __commonJS({
8748
8983
  writable: false
8749
8984
  });
8750
8985
  }
8986
+ if (isReadableStream(body === null || body === void 0 ? void 0 : body.readable) && isWritableStream(body === null || body === void 0 ? void 0 : body.writable)) {
8987
+ return Duplexify.fromWeb(body);
8988
+ }
8751
8989
  if (typeof (body === null || body === void 0 ? void 0 : body.writable) === "object" || typeof (body === null || body === void 0 ? void 0 : body.readable) === "object") {
8752
8990
  const readable = body !== null && body !== void 0 && body.readable ? isReadableNodeStream(body === null || body === void 0 ? void 0 : body.readable) ? body === null || body === void 0 ? void 0 : body.readable : duplexify(body.readable) : void 0;
8753
8991
  const writable = body !== null && body !== void 0 && body.writable ? isWritableNodeStream(body === null || body === void 0 ? void 0 : body.writable) ? body === null || body === void 0 ? void 0 : body.writable : duplexify(body.writable) : void 0;
@@ -8779,7 +9017,7 @@ var require_duplexify = __commonJS({
8779
9017
  }
8780
9018
  });
8781
9019
  }
8782
- throw new ERR_INVALID_ARG_TYPE(
9020
+ throw new ERR_INVALID_ARG_TYPE2(
8783
9021
  name,
8784
9022
  [
8785
9023
  "Blob",
@@ -9205,7 +9443,7 @@ var require_passthrough = __commonJS({
9205
9443
  var require_pipeline = __commonJS({
9206
9444
  "node_modules/pino-abstract-transport/node_modules/readable-stream/lib/internal/streams/pipeline.js"(exports2, module2) {
9207
9445
  var process2 = require_process();
9208
- var { ArrayIsArray, Promise: Promise2, SymbolAsyncIterator } = require_primordials();
9446
+ var { ArrayIsArray, Promise: Promise2, SymbolAsyncIterator, SymbolDispose } = require_primordials();
9209
9447
  var eos = require_end_of_stream();
9210
9448
  var { once } = require_util();
9211
9449
  var destroyImpl = require_destroy();
@@ -9213,7 +9451,7 @@ var require_pipeline = __commonJS({
9213
9451
  var {
9214
9452
  aggregateTwoErrors,
9215
9453
  codes: {
9216
- ERR_INVALID_ARG_TYPE,
9454
+ ERR_INVALID_ARG_TYPE: ERR_INVALID_ARG_TYPE2,
9217
9455
  ERR_INVALID_RETURN_VALUE,
9218
9456
  ERR_MISSING_ARGS,
9219
9457
  ERR_STREAM_DESTROYED,
@@ -9230,11 +9468,12 @@ var require_pipeline = __commonJS({
9230
9468
  isTransformStream,
9231
9469
  isWebStream,
9232
9470
  isReadableStream,
9233
- isReadableEnded
9471
+ isReadableFinished
9234
9472
  } = require_utils();
9235
9473
  var AbortController = globalThis.AbortController || require_abort_controller().AbortController;
9236
9474
  var PassThrough;
9237
9475
  var Readable;
9476
+ var addAbortListener;
9238
9477
  function destroyer(stream, reading, writing) {
9239
9478
  let finished = false;
9240
9479
  stream.on("close", () => {
@@ -9270,7 +9509,7 @@ var require_pipeline = __commonJS({
9270
9509
  } else if (isReadableNodeStream(val)) {
9271
9510
  return fromReadable(val);
9272
9511
  }
9273
- throw new ERR_INVALID_ARG_TYPE("val", ["Readable", "Iterable", "AsyncIterable"], val);
9512
+ throw new ERR_INVALID_ARG_TYPE2("val", ["Readable", "Iterable", "AsyncIterable"], val);
9274
9513
  }
9275
9514
  async function* fromReadable(val) {
9276
9515
  if (!Readable) {
@@ -9323,8 +9562,8 @@ var require_pipeline = __commonJS({
9323
9562
  }
9324
9563
  if (end) {
9325
9564
  writable.end();
9565
+ await wait();
9326
9566
  }
9327
- await wait();
9328
9567
  finish();
9329
9568
  } catch (err) {
9330
9569
  finish(error !== err ? aggregateTwoErrors(error, err) : err);
@@ -9376,7 +9615,11 @@ var require_pipeline = __commonJS({
9376
9615
  function abort() {
9377
9616
  finishImpl(new AbortError());
9378
9617
  }
9379
- outerSignal === null || outerSignal === void 0 ? void 0 : outerSignal.addEventListener("abort", abort);
9618
+ addAbortListener = addAbortListener || require_util().addAbortListener;
9619
+ let disposable;
9620
+ if (outerSignal) {
9621
+ disposable = addAbortListener(outerSignal, abort);
9622
+ }
9380
9623
  let error;
9381
9624
  let value;
9382
9625
  const destroys = [];
@@ -9385,6 +9628,7 @@ var require_pipeline = __commonJS({
9385
9628
  finishImpl(err, --finishCount === 0);
9386
9629
  }
9387
9630
  function finishImpl(err, final) {
9631
+ var _disposable;
9388
9632
  if (err && (!error || error.code === "ERR_STREAM_PREMATURE_CLOSE")) {
9389
9633
  error = err;
9390
9634
  }
@@ -9394,7 +9638,8 @@ var require_pipeline = __commonJS({
9394
9638
  while (destroys.length) {
9395
9639
  destroys.shift()(error);
9396
9640
  }
9397
- outerSignal === null || outerSignal === void 0 ? void 0 : outerSignal.removeEventListener("abort", abort);
9641
+ ;
9642
+ (_disposable = disposable) === null || _disposable === void 0 ? void 0 : _disposable[SymbolDispose]();
9398
9643
  ac.abort();
9399
9644
  if (final) {
9400
9645
  if (!error) {
@@ -9528,7 +9773,7 @@ var require_pipeline = __commonJS({
9528
9773
  end
9529
9774
  });
9530
9775
  } else {
9531
- throw new ERR_INVALID_ARG_TYPE(
9776
+ throw new ERR_INVALID_ARG_TYPE2(
9532
9777
  "val",
9533
9778
  ["Readable", "Iterable", "AsyncIterable", "ReadableStream", "TransformStream"],
9534
9779
  ret
@@ -9552,7 +9797,7 @@ var require_pipeline = __commonJS({
9552
9797
  end
9553
9798
  });
9554
9799
  } else {
9555
- throw new ERR_INVALID_ARG_TYPE(
9800
+ throw new ERR_INVALID_ARG_TYPE2(
9556
9801
  "val",
9557
9802
  ["Readable", "Iterable", "AsyncIterable", "ReadableStream", "TransformStream"],
9558
9803
  ret
@@ -9584,7 +9829,7 @@ var require_pipeline = __commonJS({
9584
9829
  dst.end();
9585
9830
  };
9586
9831
  var endFn = endFn2;
9587
- if (isReadableEnded(src)) {
9832
+ if (isReadableFinished(src)) {
9588
9833
  process2.nextTick(endFn2);
9589
9834
  } else {
9590
9835
  src.once("end", endFn2);
@@ -9693,7 +9938,7 @@ var require_compose = __commonJS({
9693
9938
  d = new Duplex({
9694
9939
  // TODO (ronag): highWaterMark?
9695
9940
  writableObjectMode: !!(head !== null && head !== void 0 && head.writableObjectMode),
9696
- readableObjectMode: !!(tail !== null && tail !== void 0 && tail.writableObjectMode),
9941
+ readableObjectMode: !!(tail !== null && tail !== void 0 && tail.readableObjectMode),
9697
9942
  writable,
9698
9943
  readable
9699
9944
  });
@@ -9822,22 +10067,26 @@ var require_operators = __commonJS({
9822
10067
  "use strict";
9823
10068
  var AbortController = globalThis.AbortController || require_abort_controller().AbortController;
9824
10069
  var {
9825
- codes: { ERR_INVALID_ARG_VALUE, ERR_INVALID_ARG_TYPE, ERR_MISSING_ARGS, ERR_OUT_OF_RANGE },
10070
+ codes: { ERR_INVALID_ARG_VALUE, ERR_INVALID_ARG_TYPE: ERR_INVALID_ARG_TYPE2, ERR_MISSING_ARGS, ERR_OUT_OF_RANGE },
9826
10071
  AbortError
9827
10072
  } = require_errors();
9828
10073
  var { validateAbortSignal, validateInteger, validateObject } = require_validators();
9829
10074
  var kWeakHandler = require_primordials().Symbol("kWeak");
10075
+ var kResistStopPropagation = require_primordials().Symbol("kResistStopPropagation");
9830
10076
  var { finished } = require_end_of_stream();
9831
10077
  var staticCompose = require_compose();
9832
10078
  var { addAbortSignalNoValidate } = require_add_abort_signal();
9833
10079
  var { isWritable, isNodeStream } = require_utils();
10080
+ var { deprecate } = require_util();
9834
10081
  var {
9835
10082
  ArrayPrototypePush,
10083
+ Boolean: Boolean2,
9836
10084
  MathFloor,
9837
10085
  Number: Number2,
9838
10086
  NumberIsNaN,
9839
10087
  Promise: Promise2,
9840
10088
  PromiseReject,
10089
+ PromiseResolve,
9841
10090
  PromisePrototypeThen,
9842
10091
  Symbol: Symbol2
9843
10092
  } = require_primordials();
@@ -9861,7 +10110,7 @@ var require_operators = __commonJS({
9861
10110
  }
9862
10111
  function map(fn, options) {
9863
10112
  if (typeof fn !== "function") {
9864
- throw new ERR_INVALID_ARG_TYPE("fn", ["Function", "AsyncFunction"], fn);
10113
+ throw new ERR_INVALID_ARG_TYPE2("fn", ["Function", "AsyncFunction"], fn);
9865
10114
  }
9866
10115
  if (options != null) {
9867
10116
  validateObject(options, "options");
@@ -9873,31 +10122,43 @@ var require_operators = __commonJS({
9873
10122
  if ((options === null || options === void 0 ? void 0 : options.concurrency) != null) {
9874
10123
  concurrency = MathFloor(options.concurrency);
9875
10124
  }
9876
- validateInteger(concurrency, "concurrency", 1);
10125
+ let highWaterMark = concurrency - 1;
10126
+ if ((options === null || options === void 0 ? void 0 : options.highWaterMark) != null) {
10127
+ highWaterMark = MathFloor(options.highWaterMark);
10128
+ }
10129
+ validateInteger(concurrency, "options.concurrency", 1);
10130
+ validateInteger(highWaterMark, "options.highWaterMark", 0);
10131
+ highWaterMark += concurrency;
9877
10132
  return async function* map2() {
9878
- var _options$signal, _options$signal2;
9879
- const ac = new AbortController();
10133
+ const signal = require_util().AbortSignalAny(
10134
+ [options === null || options === void 0 ? void 0 : options.signal].filter(Boolean2)
10135
+ );
9880
10136
  const stream = this;
9881
10137
  const queue = [];
9882
- const signal = ac.signal;
9883
10138
  const signalOpt = {
9884
10139
  signal
9885
10140
  };
9886
- const abort = () => ac.abort();
9887
- if (options !== null && options !== void 0 && (_options$signal = options.signal) !== null && _options$signal !== void 0 && _options$signal.aborted) {
9888
- abort();
9889
- }
9890
- options === null || options === void 0 ? void 0 : (_options$signal2 = options.signal) === null || _options$signal2 === void 0 ? void 0 : _options$signal2.addEventListener("abort", abort);
9891
10141
  let next;
9892
10142
  let resume;
9893
10143
  let done = false;
9894
- function onDone() {
10144
+ let cnt = 0;
10145
+ function onCatch() {
9895
10146
  done = true;
10147
+ afterItemProcessed();
10148
+ }
10149
+ function afterItemProcessed() {
10150
+ cnt -= 1;
10151
+ maybeResume();
10152
+ }
10153
+ function maybeResume() {
10154
+ if (resume && !done && cnt < concurrency && queue.length < highWaterMark) {
10155
+ resume();
10156
+ resume = null;
10157
+ }
9896
10158
  }
9897
10159
  async function pump() {
9898
10160
  try {
9899
10161
  for await (let val of stream) {
9900
- var _val;
9901
10162
  if (done) {
9902
10163
  return;
9903
10164
  }
@@ -9906,21 +10167,21 @@ var require_operators = __commonJS({
9906
10167
  }
9907
10168
  try {
9908
10169
  val = fn(val, signalOpt);
10170
+ if (val === kEmpty) {
10171
+ continue;
10172
+ }
10173
+ val = PromiseResolve(val);
9909
10174
  } catch (err) {
9910
10175
  val = PromiseReject(err);
9911
10176
  }
9912
- if (val === kEmpty) {
9913
- continue;
9914
- }
9915
- if (typeof ((_val = val) === null || _val === void 0 ? void 0 : _val.catch) === "function") {
9916
- val.catch(onDone);
9917
- }
10177
+ cnt += 1;
10178
+ PromisePrototypeThen(val, afterItemProcessed, onCatch);
9918
10179
  queue.push(val);
9919
10180
  if (next) {
9920
10181
  next();
9921
10182
  next = null;
9922
10183
  }
9923
- if (!done && queue.length && queue.length >= concurrency) {
10184
+ if (!done && (queue.length >= highWaterMark || cnt >= concurrency)) {
9924
10185
  await new Promise2((resolve) => {
9925
10186
  resume = resolve;
9926
10187
  });
@@ -9929,16 +10190,14 @@ var require_operators = __commonJS({
9929
10190
  queue.push(kEof);
9930
10191
  } catch (err) {
9931
10192
  const val = PromiseReject(err);
9932
- PromisePrototypeThen(val, void 0, onDone);
10193
+ PromisePrototypeThen(val, afterItemProcessed, onCatch);
9933
10194
  queue.push(val);
9934
10195
  } finally {
9935
- var _options$signal3;
9936
10196
  done = true;
9937
10197
  if (next) {
9938
10198
  next();
9939
10199
  next = null;
9940
10200
  }
9941
- options === null || options === void 0 ? void 0 : (_options$signal3 = options.signal) === null || _options$signal3 === void 0 ? void 0 : _options$signal3.removeEventListener("abort", abort);
9942
10201
  }
9943
10202
  }
9944
10203
  pump();
@@ -9956,17 +10215,13 @@ var require_operators = __commonJS({
9956
10215
  yield val;
9957
10216
  }
9958
10217
  queue.shift();
9959
- if (resume) {
9960
- resume();
9961
- resume = null;
9962
- }
10218
+ maybeResume();
9963
10219
  }
9964
10220
  await new Promise2((resolve) => {
9965
10221
  next = resolve;
9966
10222
  });
9967
10223
  }
9968
10224
  } finally {
9969
- ac.abort();
9970
10225
  done = true;
9971
10226
  if (resume) {
9972
10227
  resume();
@@ -9985,8 +10240,8 @@ var require_operators = __commonJS({
9985
10240
  return async function* asIndexedPairs2() {
9986
10241
  let index = 0;
9987
10242
  for await (const val of this) {
9988
- var _options$signal4;
9989
- if (options !== null && options !== void 0 && (_options$signal4 = options.signal) !== null && _options$signal4 !== void 0 && _options$signal4.aborted) {
10243
+ var _options$signal;
10244
+ if (options !== null && options !== void 0 && (_options$signal = options.signal) !== null && _options$signal !== void 0 && _options$signal.aborted) {
9990
10245
  throw new AbortError({
9991
10246
  cause: options.signal.reason
9992
10247
  });
@@ -10003,7 +10258,7 @@ var require_operators = __commonJS({
10003
10258
  }
10004
10259
  async function every(fn, options = void 0) {
10005
10260
  if (typeof fn !== "function") {
10006
- throw new ERR_INVALID_ARG_TYPE("fn", ["Function", "AsyncFunction"], fn);
10261
+ throw new ERR_INVALID_ARG_TYPE2("fn", ["Function", "AsyncFunction"], fn);
10007
10262
  }
10008
10263
  return !await some.call(
10009
10264
  this,
@@ -10021,7 +10276,7 @@ var require_operators = __commonJS({
10021
10276
  }
10022
10277
  async function forEach(fn, options) {
10023
10278
  if (typeof fn !== "function") {
10024
- throw new ERR_INVALID_ARG_TYPE("fn", ["Function", "AsyncFunction"], fn);
10279
+ throw new ERR_INVALID_ARG_TYPE2("fn", ["Function", "AsyncFunction"], fn);
10025
10280
  }
10026
10281
  async function forEachFn(value, options2) {
10027
10282
  await fn(value, options2);
@@ -10032,7 +10287,7 @@ var require_operators = __commonJS({
10032
10287
  }
10033
10288
  function filter(fn, options) {
10034
10289
  if (typeof fn !== "function") {
10035
- throw new ERR_INVALID_ARG_TYPE("fn", ["Function", "AsyncFunction"], fn);
10290
+ throw new ERR_INVALID_ARG_TYPE2("fn", ["Function", "AsyncFunction"], fn);
10036
10291
  }
10037
10292
  async function filterFn(value, options2) {
10038
10293
  if (await fn(value, options2)) {
@@ -10049,9 +10304,9 @@ var require_operators = __commonJS({
10049
10304
  }
10050
10305
  };
10051
10306
  async function reduce(reducer, initialValue, options) {
10052
- var _options$signal5;
10307
+ var _options$signal2;
10053
10308
  if (typeof reducer !== "function") {
10054
- throw new ERR_INVALID_ARG_TYPE("reducer", ["Function", "AsyncFunction"], reducer);
10309
+ throw new ERR_INVALID_ARG_TYPE2("reducer", ["Function", "AsyncFunction"], reducer);
10055
10310
  }
10056
10311
  if (options != null) {
10057
10312
  validateObject(options, "options");
@@ -10060,7 +10315,7 @@ var require_operators = __commonJS({
10060
10315
  validateAbortSignal(options.signal, "options.signal");
10061
10316
  }
10062
10317
  let hasInitialValue = arguments.length > 1;
10063
- if (options !== null && options !== void 0 && (_options$signal5 = options.signal) !== null && _options$signal5 !== void 0 && _options$signal5.aborted) {
10318
+ if (options !== null && options !== void 0 && (_options$signal2 = options.signal) !== null && _options$signal2 !== void 0 && _options$signal2.aborted) {
10064
10319
  const err = new AbortError(void 0, {
10065
10320
  cause: options.signal.reason
10066
10321
  });
@@ -10074,16 +10329,17 @@ var require_operators = __commonJS({
10074
10329
  if (options !== null && options !== void 0 && options.signal) {
10075
10330
  const opts = {
10076
10331
  once: true,
10077
- [kWeakHandler]: this
10332
+ [kWeakHandler]: this,
10333
+ [kResistStopPropagation]: true
10078
10334
  };
10079
10335
  options.signal.addEventListener("abort", () => ac.abort(), opts);
10080
10336
  }
10081
10337
  let gotAnyItemFromStream = false;
10082
10338
  try {
10083
10339
  for await (const value of this) {
10084
- var _options$signal6;
10340
+ var _options$signal3;
10085
10341
  gotAnyItemFromStream = true;
10086
- if (options !== null && options !== void 0 && (_options$signal6 = options.signal) !== null && _options$signal6 !== void 0 && _options$signal6.aborted) {
10342
+ if (options !== null && options !== void 0 && (_options$signal3 = options.signal) !== null && _options$signal3 !== void 0 && _options$signal3.aborted) {
10087
10343
  throw new AbortError();
10088
10344
  }
10089
10345
  if (!hasInitialValue) {
@@ -10112,8 +10368,8 @@ var require_operators = __commonJS({
10112
10368
  }
10113
10369
  const result = [];
10114
10370
  for await (const val of this) {
10115
- var _options$signal7;
10116
- if (options !== null && options !== void 0 && (_options$signal7 = options.signal) !== null && _options$signal7 !== void 0 && _options$signal7.aborted) {
10371
+ var _options$signal4;
10372
+ if (options !== null && options !== void 0 && (_options$signal4 = options.signal) !== null && _options$signal4 !== void 0 && _options$signal4.aborted) {
10117
10373
  throw new AbortError(void 0, {
10118
10374
  cause: options.signal.reason
10119
10375
  });
@@ -10149,13 +10405,13 @@ var require_operators = __commonJS({
10149
10405
  }
10150
10406
  number = toIntegerOrInfinity(number);
10151
10407
  return async function* drop2() {
10152
- var _options$signal8;
10153
- if (options !== null && options !== void 0 && (_options$signal8 = options.signal) !== null && _options$signal8 !== void 0 && _options$signal8.aborted) {
10408
+ var _options$signal5;
10409
+ if (options !== null && options !== void 0 && (_options$signal5 = options.signal) !== null && _options$signal5 !== void 0 && _options$signal5.aborted) {
10154
10410
  throw new AbortError();
10155
10411
  }
10156
10412
  for await (const val of this) {
10157
- var _options$signal9;
10158
- if (options !== null && options !== void 0 && (_options$signal9 = options.signal) !== null && _options$signal9 !== void 0 && _options$signal9.aborted) {
10413
+ var _options$signal6;
10414
+ if (options !== null && options !== void 0 && (_options$signal6 = options.signal) !== null && _options$signal6 !== void 0 && _options$signal6.aborted) {
10159
10415
  throw new AbortError();
10160
10416
  }
10161
10417
  if (number-- <= 0) {
@@ -10173,25 +10429,26 @@ var require_operators = __commonJS({
10173
10429
  }
10174
10430
  number = toIntegerOrInfinity(number);
10175
10431
  return async function* take2() {
10176
- var _options$signal10;
10177
- if (options !== null && options !== void 0 && (_options$signal10 = options.signal) !== null && _options$signal10 !== void 0 && _options$signal10.aborted) {
10432
+ var _options$signal7;
10433
+ if (options !== null && options !== void 0 && (_options$signal7 = options.signal) !== null && _options$signal7 !== void 0 && _options$signal7.aborted) {
10178
10434
  throw new AbortError();
10179
10435
  }
10180
10436
  for await (const val of this) {
10181
- var _options$signal11;
10182
- if (options !== null && options !== void 0 && (_options$signal11 = options.signal) !== null && _options$signal11 !== void 0 && _options$signal11.aborted) {
10437
+ var _options$signal8;
10438
+ if (options !== null && options !== void 0 && (_options$signal8 = options.signal) !== null && _options$signal8 !== void 0 && _options$signal8.aborted) {
10183
10439
  throw new AbortError();
10184
10440
  }
10185
10441
  if (number-- > 0) {
10186
10442
  yield val;
10187
- } else {
10443
+ }
10444
+ if (number <= 0) {
10188
10445
  return;
10189
10446
  }
10190
10447
  }
10191
10448
  }.call(this);
10192
10449
  }
10193
10450
  module2.exports.streamReturningOperators = {
10194
- asIndexedPairs,
10451
+ asIndexedPairs: deprecate(asIndexedPairs, "readable.asIndexedPairs will be removed in a future version."),
10195
10452
  drop,
10196
10453
  filter,
10197
10454
  flatMap,
@@ -10218,7 +10475,7 @@ var require_promises = __commonJS({
10218
10475
  var { isIterable, isNodeStream, isWebStream } = require_utils();
10219
10476
  var { pipelineImpl: pl } = require_pipeline();
10220
10477
  var { finished } = require_end_of_stream();
10221
- require("stream");
10478
+ require_stream();
10222
10479
  function pipeline(...streams) {
10223
10480
  return new Promise2((resolve, reject) => {
10224
10481
  let signal;
@@ -10265,15 +10522,18 @@ var require_stream = __commonJS({
10265
10522
  codes: { ERR_ILLEGAL_CONSTRUCTOR }
10266
10523
  } = require_errors();
10267
10524
  var compose = require_compose();
10525
+ var { setDefaultHighWaterMark, getDefaultHighWaterMark } = require_state2();
10268
10526
  var { pipeline } = require_pipeline();
10269
10527
  var { destroyer } = require_destroy();
10270
10528
  var eos = require_end_of_stream();
10271
10529
  var promises = require_promises();
10272
10530
  var utils = require_utils();
10273
10531
  var Stream = module2.exports = require_legacy().Stream;
10532
+ Stream.isDestroyed = utils.isDestroyed;
10274
10533
  Stream.isDisturbed = utils.isDisturbed;
10275
10534
  Stream.isErrored = utils.isErrored;
10276
10535
  Stream.isReadable = utils.isReadable;
10536
+ Stream.isWritable = utils.isWritable;
10277
10537
  Stream.Readable = require_readable();
10278
10538
  for (const key of ObjectKeys(streamReturningOperators)) {
10279
10539
  let fn2 = function(...args) {
@@ -10337,6 +10597,8 @@ var require_stream = __commonJS({
10337
10597
  Stream.finished = eos;
10338
10598
  Stream.destroy = destroyer;
10339
10599
  Stream.compose = compose;
10600
+ Stream.setDefaultHighWaterMark = setDefaultHighWaterMark;
10601
+ Stream.getDefaultHighWaterMark = getDefaultHighWaterMark;
10340
10602
  ObjectDefineProperty(Stream, "promises", {
10341
10603
  __proto__: null,
10342
10604
  configurable: true,