ooxml-core 1.25.2 → 1.26.1

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 (103) hide show
  1. package/README.md +16 -0
  2. package/dist/{PptxHandler-AUK27AQD.mjs → PptxHandler-64BZOBWX.mjs} +3 -3
  3. package/dist/{PptxHandler-QBGEZDCO.cjs → PptxHandler-AILFLRH7.cjs} +3 -3
  4. package/dist/PptxHandler-PMLQGMFQ.mjs +4 -0
  5. package/dist/{PresentationBuilder-RX7D75GZ.mjs → PresentationBuilder-EJY2TYWL.mjs} +2 -2
  6. package/dist/{PresentationBuilder-MEETJGEA.mjs → PresentationBuilder-HBCCO2CF.mjs} +3 -3
  7. package/dist/{PresentationBuilder-CI45KEHL.cjs → PresentationBuilder-RBQP6A37.cjs} +5 -5
  8. package/dist/automation/index.cjs +273 -156
  9. package/dist/automation/index.mjs +273 -156
  10. package/dist/automation/xlsx-read.d.ts +2 -8
  11. package/dist/automation/xlsx-read.d.ts.map +1 -1
  12. package/dist/automation/xlsx.d.ts +2 -2
  13. package/dist/chart/index.cjs +89 -47
  14. package/dist/chart/index.mjs +89 -47
  15. package/dist/{chunk-6DHZZD5R.mjs → chunk-2XMK5SXU.mjs} +106 -48
  16. package/dist/{chunk-VGDHSED6.mjs → chunk-DHAZSMC7.mjs} +1 -1
  17. package/dist/{chunk-TX2QFS3J.mjs → chunk-FZBAMWCJ.mjs} +788 -542
  18. package/dist/{chunk-E2PYQQQV.mjs → chunk-JJ37PCNR.mjs} +89 -47
  19. package/dist/{chunk-S5TGOEQX.cjs → chunk-MU3XSASV.cjs} +106 -47
  20. package/dist/{chunk-GMETZZ3V.cjs → chunk-NXTHB2M3.cjs} +1857 -1611
  21. package/dist/{chunk-HVRFRYYS.mjs → chunk-OQPT5IC3.mjs} +5 -5
  22. package/dist/{chunk-5F7OB7PA.mjs → chunk-OTXJVFMY.mjs} +785 -539
  23. package/dist/{chunk-635WPRNJ.mjs → chunk-R7RL7W43.mjs} +19 -3
  24. package/dist/{chunk-E3PRAHL6.mjs → chunk-WRFMS5CL.mjs} +1 -1
  25. package/dist/docx/embedded.cjs +89 -47
  26. package/dist/docx/embedded.mjs +89 -47
  27. package/dist/docx/index.cjs +89 -47
  28. package/dist/docx/index.mjs +89 -47
  29. package/dist/docx/load/index.cjs +89 -47
  30. package/dist/docx/load/index.mjs +89 -47
  31. package/dist/index.cjs +128 -53
  32. package/dist/index.mjs +128 -53
  33. package/dist/opc/index.cjs +90 -47
  34. package/dist/opc/index.mjs +90 -48
  35. package/dist/opc/zip-limits.d.ts +6 -0
  36. package/dist/opc/zip-limits.d.ts.map +1 -1
  37. package/dist/pptx/automation/index.cjs +954 -622
  38. package/dist/pptx/automation/index.d.ts +4 -4
  39. package/dist/pptx/automation/index.mjs +6 -6
  40. package/dist/pptx/chunks/{index-DCbp5fOs.d.ts → index-CbFowkp4.d.ts} +12 -5
  41. package/dist/pptx/chunks/{index-DCbp5fOs.d.ts.map → index-CbFowkp4.d.ts.map} +1 -1
  42. package/dist/pptx/chunks/{index-CX0RM1fF.d.ts → index-D4FnOx6x.d.ts} +3 -3
  43. package/dist/pptx/chunks/{index-CX0RM1fF.d.ts.map → index-D4FnOx6x.d.ts.map} +1 -1
  44. package/dist/pptx/chunks/{index-CgjEEpfK.d.ts → index-D8DNpc1X.d.ts} +289 -118
  45. package/dist/pptx/chunks/index-D8DNpc1X.d.ts.map +1 -0
  46. package/dist/pptx/chunks/{text-operations-CjalmJIi.d.ts → text-operations-CNfUj45U.d.ts} +16 -2
  47. package/dist/pptx/chunks/{text-operations-CjalmJIi.d.ts.map → text-operations-CNfUj45U.d.ts.map} +1 -1
  48. package/dist/pptx/cli/index.cjs +954 -622
  49. package/dist/pptx/cli/index.d.ts +1 -1
  50. package/dist/pptx/cli/index.mjs +5 -5
  51. package/dist/pptx/converter/index.d.ts +1 -1
  52. package/dist/pptx/converter/index.mjs +3 -3
  53. package/dist/pptx/editor/render/editor-history.cjs +21 -0
  54. package/dist/pptx/editor/render/editor-history.d.ts +9 -0
  55. package/dist/pptx/editor/render/editor-history.d.ts.map +1 -1
  56. package/dist/pptx/editor/render/editor-history.mjs +21 -0
  57. package/dist/pptx/editor/render/find-replace.cjs +14 -14
  58. package/dist/pptx/editor/render/find-replace.d.ts +2 -2
  59. package/dist/pptx/editor/render/find-replace.mjs +1 -1
  60. package/dist/pptx/editor/render/slide-operations.cjs +8 -8
  61. package/dist/pptx/editor/render/slide-operations.mjs +2 -2
  62. package/dist/pptx/index.cjs +953 -620
  63. package/dist/pptx/index.d.ts +5 -5
  64. package/dist/pptx/index.mjs +6 -6
  65. package/dist/pptx/node/index.d.ts +1 -1
  66. package/dist/pptx/signature-node/index.cjs +89 -47
  67. package/dist/pptx/signature-node/index.mjs +2 -2
  68. package/dist/visio/index.cjs +266 -150
  69. package/dist/visio/index.mjs +266 -150
  70. package/dist/visio/ui/index.cjs +266 -150
  71. package/dist/visio/ui/index.mjs +266 -150
  72. package/dist/xlsx/index.cjs +518 -153
  73. package/dist/xlsx/index.mjs +518 -154
  74. package/dist/xlsx/load/index.cjs +266 -150
  75. package/dist/xlsx/load/index.mjs +266 -150
  76. package/dist/xlsx/numfmt/view.d.ts +13 -0
  77. package/dist/xlsx/numfmt/view.d.ts.map +1 -0
  78. package/dist/xlsx/read/index.d.ts +1 -0
  79. package/dist/xlsx/read/index.d.ts.map +1 -1
  80. package/dist/xlsx/read/limits.d.ts +5 -0
  81. package/dist/xlsx/read/limits.d.ts.map +1 -1
  82. package/dist/xlsx/read/package.d.ts +6 -0
  83. package/dist/xlsx/read/package.d.ts.map +1 -1
  84. package/dist/xlsx/read/rows-stream.d.ts +12 -0
  85. package/dist/xlsx/read/rows-stream.d.ts.map +1 -0
  86. package/dist/xlsx/read/rows.d.ts +37 -0
  87. package/dist/xlsx/read/rows.d.ts.map +1 -0
  88. package/dist/xlsx/read/shared-strings.d.ts +6 -1
  89. package/dist/xlsx/read/shared-strings.d.ts.map +1 -1
  90. package/dist/xlsx/read/sheet-data-source.d.ts +30 -3
  91. package/dist/xlsx/read/sheet-data-source.d.ts.map +1 -1
  92. package/dist/xlsx/read/sheet-data.d.ts +13 -2
  93. package/dist/xlsx/read/sheet-data.d.ts.map +1 -1
  94. package/dist/xlsx/read/worksheet.d.ts.map +1 -1
  95. package/dist/xlsx/ui/index.cjs +266 -150
  96. package/dist/xlsx/ui/index.mjs +266 -150
  97. package/dist/xml/index.cjs +38 -6
  98. package/dist/xml/index.mjs +37 -7
  99. package/dist/xml/lite.d.ts +15 -0
  100. package/dist/xml/lite.d.ts.map +1 -1
  101. package/package.json +1 -1
  102. package/dist/PptxHandler-5UO5DD5K.mjs +0 -4
  103. package/dist/pptx/chunks/index-CgjEEpfK.d.ts.map +0 -1
@@ -2634,57 +2634,99 @@ function resolveLimits(limits) {
2634
2634
  fail: (message, limit, kind) => create2 ? create2(message, { limit, kind }) : new ZipLimitError(message, { limit, kind })
2635
2635
  };
2636
2636
  }
2637
- function inflateEntryGuarded(entry2, alreadyRead, limits) {
2637
+ async function inflateEntryGuarded(entry2, alreadyRead, limits) {
2638
+ const chunks = [];
2639
+ let size = 0;
2640
+ for await (const chunk of streamEntryGuarded(entry2, alreadyRead, limits)) {
2641
+ chunks.push(chunk);
2642
+ size += chunk.byteLength;
2643
+ }
2644
+ if (chunks.length === 1 && chunks[0]) return chunks[0];
2645
+ const out = new Uint8Array(size);
2646
+ let offset = 0;
2647
+ for (const chunk of chunks) {
2648
+ out.set(chunk, offset);
2649
+ offset += chunk.byteLength;
2650
+ }
2651
+ return out;
2652
+ }
2653
+ var AHEAD = 8;
2654
+ async function* streamEntryGuarded(entry2, alreadyRead, limits) {
2638
2655
  const r = resolveLimits(limits);
2639
2656
  const declared = declaredEntrySize(entry2);
2640
- return new Promise((resolvePromise, reject) => {
2641
- const chunks = [];
2642
- let size = 0;
2643
- let done = false;
2644
- const stream = entry2.internalStream("uint8array");
2645
- const abort = (error) => {
2646
- if (done) return;
2647
- done = true;
2648
- stream.pause();
2649
- chunks.length = 0;
2650
- reject(error);
2651
- };
2652
- stream.on("data", (chunk) => {
2653
- if (done) return;
2654
- size += chunk.byteLength;
2655
- if (size > declared || size > r.maxEntryBytes)
2656
- return abort(
2657
- r.fail(
2658
- `${r.label} part ${entry2.name} inflates past its declared size`,
2659
- r.maxEntryBytes,
2660
- size > declared ? "declaredSize" : "maxEntryBytes"
2661
- )
2662
- );
2663
- if (alreadyRead + size > r.maxTotalBytes)
2664
- return abort(
2665
- r.fail(
2666
- `${r.label} package exceeds the ${mib(r.maxTotalBytes)} MiB uncompressed content limit`,
2667
- r.maxTotalBytes,
2668
- "maxTotalBytes"
2669
- )
2670
- );
2671
- chunks.push(chunk);
2672
- });
2673
- stream.on("error", (error) => abort(error));
2674
- stream.on("end", () => {
2675
- if (done) return;
2676
- done = true;
2677
- if (chunks.length === 1 && chunks[0]) return resolvePromise(chunks[0]);
2678
- const out = new Uint8Array(size);
2679
- let offset = 0;
2680
- for (const chunk of chunks) {
2681
- out.set(chunk, offset);
2682
- offset += chunk.byteLength;
2683
- }
2684
- resolvePromise(out);
2685
- });
2657
+ const stream = entry2.internalStream("uint8array");
2658
+ const queue = [];
2659
+ let size = 0;
2660
+ let ended = false;
2661
+ let stopped = false;
2662
+ let failure;
2663
+ let paused = false;
2664
+ let wake;
2665
+ const pause = () => {
2666
+ paused = true;
2667
+ stream.pause();
2668
+ };
2669
+ const resume = () => {
2670
+ if (!paused || stopped) return;
2671
+ paused = false;
2686
2672
  stream.resume();
2673
+ };
2674
+ const fail = (error) => {
2675
+ failure ??= error;
2676
+ stopped = true;
2677
+ queue.length = 0;
2678
+ pause();
2679
+ wake?.();
2680
+ };
2681
+ stream.on("data", (chunk) => {
2682
+ if (stopped) return pause();
2683
+ size += chunk.byteLength;
2684
+ if (size > declared || size > r.maxEntryBytes)
2685
+ return fail(
2686
+ r.fail(
2687
+ `${r.label} part ${entry2.name} inflates past its declared size`,
2688
+ r.maxEntryBytes,
2689
+ size > declared ? "declaredSize" : "maxEntryBytes"
2690
+ )
2691
+ );
2692
+ if (alreadyRead + size > r.maxTotalBytes)
2693
+ return fail(
2694
+ r.fail(
2695
+ `${r.label} package exceeds the ${mib(r.maxTotalBytes)} MiB uncompressed content limit`,
2696
+ r.maxTotalBytes,
2697
+ "maxTotalBytes"
2698
+ )
2699
+ );
2700
+ queue.push(chunk);
2701
+ if (queue.length >= AHEAD) pause();
2702
+ wake?.();
2703
+ });
2704
+ stream.on("error", (error) => fail(error));
2705
+ stream.on("end", () => {
2706
+ ended = true;
2707
+ wake?.();
2687
2708
  });
2709
+ stream.resume();
2710
+ try {
2711
+ for (; ; ) {
2712
+ if (failure) throw failure;
2713
+ const chunk = queue.shift();
2714
+ if (chunk) {
2715
+ if (queue.length < AHEAD / 2) resume();
2716
+ yield chunk;
2717
+ continue;
2718
+ }
2719
+ if (ended) return;
2720
+ await new Promise((resolve) => {
2721
+ wake = resolve;
2722
+ resume();
2723
+ });
2724
+ wake = void 0;
2725
+ }
2726
+ } finally {
2727
+ stopped = true;
2728
+ if (!ended) pause();
2729
+ }
2688
2730
  }
2689
2731
  function toBase64(bytes) {
2690
2732
  let binary = "";
@@ -3701,57 +3701,99 @@ function resolveLimits(limits) {
3701
3701
  fail: (message, limit, kind) => create2 ? create2(message, { limit, kind }) : new ZipLimitError(message, { limit, kind })
3702
3702
  };
3703
3703
  }
3704
- function inflateEntryGuarded(entry2, alreadyRead, limits) {
3704
+ async function inflateEntryGuarded(entry2, alreadyRead, limits) {
3705
+ const chunks = [];
3706
+ let size = 0;
3707
+ for await (const chunk of streamEntryGuarded(entry2, alreadyRead, limits)) {
3708
+ chunks.push(chunk);
3709
+ size += chunk.byteLength;
3710
+ }
3711
+ if (chunks.length === 1 && chunks[0]) return chunks[0];
3712
+ const out = new Uint8Array(size);
3713
+ let offset = 0;
3714
+ for (const chunk of chunks) {
3715
+ out.set(chunk, offset);
3716
+ offset += chunk.byteLength;
3717
+ }
3718
+ return out;
3719
+ }
3720
+ var AHEAD = 8;
3721
+ async function* streamEntryGuarded(entry2, alreadyRead, limits) {
3705
3722
  const r = resolveLimits(limits);
3706
3723
  const declared = declaredEntrySize(entry2);
3707
- return new Promise((resolvePromise, reject) => {
3708
- const chunks = [];
3709
- let size = 0;
3710
- let done = false;
3711
- const stream = entry2.internalStream("uint8array");
3712
- const abort = (error) => {
3713
- if (done) return;
3714
- done = true;
3715
- stream.pause();
3716
- chunks.length = 0;
3717
- reject(error);
3718
- };
3719
- stream.on("data", (chunk) => {
3720
- if (done) return;
3721
- size += chunk.byteLength;
3722
- if (size > declared || size > r.maxEntryBytes)
3723
- return abort(
3724
- r.fail(
3725
- `${r.label} part ${entry2.name} inflates past its declared size`,
3726
- r.maxEntryBytes,
3727
- size > declared ? "declaredSize" : "maxEntryBytes"
3728
- )
3729
- );
3730
- if (alreadyRead + size > r.maxTotalBytes)
3731
- return abort(
3732
- r.fail(
3733
- `${r.label} package exceeds the ${mib(r.maxTotalBytes)} MiB uncompressed content limit`,
3734
- r.maxTotalBytes,
3735
- "maxTotalBytes"
3736
- )
3737
- );
3738
- chunks.push(chunk);
3739
- });
3740
- stream.on("error", (error) => abort(error));
3741
- stream.on("end", () => {
3742
- if (done) return;
3743
- done = true;
3744
- if (chunks.length === 1 && chunks[0]) return resolvePromise(chunks[0]);
3745
- const out = new Uint8Array(size);
3746
- let offset = 0;
3747
- for (const chunk of chunks) {
3748
- out.set(chunk, offset);
3749
- offset += chunk.byteLength;
3750
- }
3751
- resolvePromise(out);
3752
- });
3724
+ const stream = entry2.internalStream("uint8array");
3725
+ const queue = [];
3726
+ let size = 0;
3727
+ let ended = false;
3728
+ let stopped = false;
3729
+ let failure;
3730
+ let paused = false;
3731
+ let wake;
3732
+ const pause = () => {
3733
+ paused = true;
3734
+ stream.pause();
3735
+ };
3736
+ const resume = () => {
3737
+ if (!paused || stopped) return;
3738
+ paused = false;
3753
3739
  stream.resume();
3740
+ };
3741
+ const fail = (error) => {
3742
+ failure ??= error;
3743
+ stopped = true;
3744
+ queue.length = 0;
3745
+ pause();
3746
+ wake?.();
3747
+ };
3748
+ stream.on("data", (chunk) => {
3749
+ if (stopped) return pause();
3750
+ size += chunk.byteLength;
3751
+ if (size > declared || size > r.maxEntryBytes)
3752
+ return fail(
3753
+ r.fail(
3754
+ `${r.label} part ${entry2.name} inflates past its declared size`,
3755
+ r.maxEntryBytes,
3756
+ size > declared ? "declaredSize" : "maxEntryBytes"
3757
+ )
3758
+ );
3759
+ if (alreadyRead + size > r.maxTotalBytes)
3760
+ return fail(
3761
+ r.fail(
3762
+ `${r.label} package exceeds the ${mib(r.maxTotalBytes)} MiB uncompressed content limit`,
3763
+ r.maxTotalBytes,
3764
+ "maxTotalBytes"
3765
+ )
3766
+ );
3767
+ queue.push(chunk);
3768
+ if (queue.length >= AHEAD) pause();
3769
+ wake?.();
3770
+ });
3771
+ stream.on("error", (error) => fail(error));
3772
+ stream.on("end", () => {
3773
+ ended = true;
3774
+ wake?.();
3754
3775
  });
3776
+ stream.resume();
3777
+ try {
3778
+ for (; ; ) {
3779
+ if (failure) throw failure;
3780
+ const chunk = queue.shift();
3781
+ if (chunk) {
3782
+ if (queue.length < AHEAD / 2) resume();
3783
+ yield chunk;
3784
+ continue;
3785
+ }
3786
+ if (ended) return;
3787
+ await new Promise((resolve) => {
3788
+ wake = resolve;
3789
+ resume();
3790
+ });
3791
+ wake = void 0;
3792
+ }
3793
+ } finally {
3794
+ stopped = true;
3795
+ if (!ended) pause();
3796
+ }
3755
3797
  }
3756
3798
  function toBase64(bytes) {
3757
3799
  let binary = "";
@@ -3695,57 +3695,99 @@ function resolveLimits(limits) {
3695
3695
  fail: (message, limit, kind) => create2 ? create2(message, { limit, kind }) : new ZipLimitError(message, { limit, kind })
3696
3696
  };
3697
3697
  }
3698
- function inflateEntryGuarded(entry2, alreadyRead, limits) {
3698
+ async function inflateEntryGuarded(entry2, alreadyRead, limits) {
3699
+ const chunks = [];
3700
+ let size = 0;
3701
+ for await (const chunk of streamEntryGuarded(entry2, alreadyRead, limits)) {
3702
+ chunks.push(chunk);
3703
+ size += chunk.byteLength;
3704
+ }
3705
+ if (chunks.length === 1 && chunks[0]) return chunks[0];
3706
+ const out = new Uint8Array(size);
3707
+ let offset = 0;
3708
+ for (const chunk of chunks) {
3709
+ out.set(chunk, offset);
3710
+ offset += chunk.byteLength;
3711
+ }
3712
+ return out;
3713
+ }
3714
+ var AHEAD = 8;
3715
+ async function* streamEntryGuarded(entry2, alreadyRead, limits) {
3699
3716
  const r = resolveLimits(limits);
3700
3717
  const declared = declaredEntrySize(entry2);
3701
- return new Promise((resolvePromise, reject) => {
3702
- const chunks = [];
3703
- let size = 0;
3704
- let done = false;
3705
- const stream = entry2.internalStream("uint8array");
3706
- const abort = (error) => {
3707
- if (done) return;
3708
- done = true;
3709
- stream.pause();
3710
- chunks.length = 0;
3711
- reject(error);
3712
- };
3713
- stream.on("data", (chunk) => {
3714
- if (done) return;
3715
- size += chunk.byteLength;
3716
- if (size > declared || size > r.maxEntryBytes)
3717
- return abort(
3718
- r.fail(
3719
- `${r.label} part ${entry2.name} inflates past its declared size`,
3720
- r.maxEntryBytes,
3721
- size > declared ? "declaredSize" : "maxEntryBytes"
3722
- )
3723
- );
3724
- if (alreadyRead + size > r.maxTotalBytes)
3725
- return abort(
3726
- r.fail(
3727
- `${r.label} package exceeds the ${mib(r.maxTotalBytes)} MiB uncompressed content limit`,
3728
- r.maxTotalBytes,
3729
- "maxTotalBytes"
3730
- )
3731
- );
3732
- chunks.push(chunk);
3733
- });
3734
- stream.on("error", (error) => abort(error));
3735
- stream.on("end", () => {
3736
- if (done) return;
3737
- done = true;
3738
- if (chunks.length === 1 && chunks[0]) return resolvePromise(chunks[0]);
3739
- const out = new Uint8Array(size);
3740
- let offset = 0;
3741
- for (const chunk of chunks) {
3742
- out.set(chunk, offset);
3743
- offset += chunk.byteLength;
3744
- }
3745
- resolvePromise(out);
3746
- });
3718
+ const stream = entry2.internalStream("uint8array");
3719
+ const queue = [];
3720
+ let size = 0;
3721
+ let ended = false;
3722
+ let stopped = false;
3723
+ let failure;
3724
+ let paused = false;
3725
+ let wake;
3726
+ const pause = () => {
3727
+ paused = true;
3728
+ stream.pause();
3729
+ };
3730
+ const resume = () => {
3731
+ if (!paused || stopped) return;
3732
+ paused = false;
3747
3733
  stream.resume();
3734
+ };
3735
+ const fail = (error) => {
3736
+ failure ??= error;
3737
+ stopped = true;
3738
+ queue.length = 0;
3739
+ pause();
3740
+ wake?.();
3741
+ };
3742
+ stream.on("data", (chunk) => {
3743
+ if (stopped) return pause();
3744
+ size += chunk.byteLength;
3745
+ if (size > declared || size > r.maxEntryBytes)
3746
+ return fail(
3747
+ r.fail(
3748
+ `${r.label} part ${entry2.name} inflates past its declared size`,
3749
+ r.maxEntryBytes,
3750
+ size > declared ? "declaredSize" : "maxEntryBytes"
3751
+ )
3752
+ );
3753
+ if (alreadyRead + size > r.maxTotalBytes)
3754
+ return fail(
3755
+ r.fail(
3756
+ `${r.label} package exceeds the ${mib(r.maxTotalBytes)} MiB uncompressed content limit`,
3757
+ r.maxTotalBytes,
3758
+ "maxTotalBytes"
3759
+ )
3760
+ );
3761
+ queue.push(chunk);
3762
+ if (queue.length >= AHEAD) pause();
3763
+ wake?.();
3764
+ });
3765
+ stream.on("error", (error) => fail(error));
3766
+ stream.on("end", () => {
3767
+ ended = true;
3768
+ wake?.();
3748
3769
  });
3770
+ stream.resume();
3771
+ try {
3772
+ for (; ; ) {
3773
+ if (failure) throw failure;
3774
+ const chunk = queue.shift();
3775
+ if (chunk) {
3776
+ if (queue.length < AHEAD / 2) resume();
3777
+ yield chunk;
3778
+ continue;
3779
+ }
3780
+ if (ended) return;
3781
+ await new Promise((resolve) => {
3782
+ wake = resolve;
3783
+ resume();
3784
+ });
3785
+ wake = void 0;
3786
+ }
3787
+ } finally {
3788
+ stopped = true;
3789
+ if (!ended) pause();
3790
+ }
3749
3791
  }
3750
3792
  function toBase64(bytes) {
3751
3793
  let binary = "";
package/dist/index.cjs CHANGED
@@ -2452,6 +2452,7 @@ function nudgeOutsideLabels(boxes, disc, minY, maxY) {
2452
2452
  var xml_exports = {};
2453
2453
  __export(xml_exports, {
2454
2454
  DEFAULT_XML_LIMITS: () => DEFAULT_XML_LIMITS,
2455
+ LiteDeclinedError: () => LiteDeclinedError,
2455
2456
  LiteElement: () => LiteElement,
2456
2457
  NS: () => NS,
2457
2458
  XmlLimitError: () => XmlLimitError,
@@ -2462,6 +2463,7 @@ __export(xml_exports, {
2462
2463
  elements: () => elements,
2463
2464
  first: () => first,
2464
2465
  isElement: () => isElement,
2466
+ liteChildElements: () => liteChildElements,
2465
2467
  makeNS: () => makeNS,
2466
2468
  named: () => named,
2467
2469
  parseLiteFragment: () => parseLiteFragment,
@@ -2716,40 +2718,68 @@ function decode(text3) {
2716
2718
  }
2717
2719
  var isSpace = (code) => code === 32 || code === 9 || code === 10 || code === 13;
2718
2720
  var hasLineEnds = (xml) => xml.includes("\r") || xml.includes("\x85") || xml.includes("\u2028") || xml.includes("\u2029");
2721
+ var LiteDeclinedError = class extends Error {
2722
+ constructor() {
2723
+ super("The XML fragment needs the full parser");
2724
+ this.name = "LiteDeclinedError";
2725
+ }
2726
+ };
2719
2727
  function parseLiteFragment(xml, container, namespaces) {
2728
+ const nodes = topLevelNodes(xml, namespaces);
2729
+ for (let next = nodes.next(); ; next = nodes.next()) {
2730
+ if (next.done) return next.value ? container : void 0;
2731
+ container.childNodes.push(next.value);
2732
+ }
2733
+ }
2734
+ function* liteChildElements(xml, namespaces) {
2735
+ const nodes = topLevelNodes(xml, namespaces);
2736
+ for (let next = nodes.next(); ; next = nodes.next()) {
2737
+ if (next.done) {
2738
+ if (next.value) return;
2739
+ throw new LiteDeclinedError();
2740
+ }
2741
+ if (typeof next.value !== "string") yield next.value.asElement();
2742
+ }
2743
+ }
2744
+ function* topLevelNodes(xml, namespaces) {
2720
2745
  const source = hasLineEnds(xml) ? xml.replace(/\r[\n\u0085]/g, "\n").replace(/[\r\u0085\u2028\u2029]/g, "\n") : xml;
2721
- const root = container;
2746
+ const root = new LiteElement("", "", null);
2747
+ const level3 = root.childNodes;
2722
2748
  const stack = [root];
2723
2749
  let top = root;
2724
2750
  const n2 = source.length;
2725
2751
  let pos = 0;
2726
2752
  while (pos < n2) {
2753
+ if (level3.length && stack.length === 1) {
2754
+ yield* level3;
2755
+ level3.length = 0;
2756
+ }
2727
2757
  const lt = source.indexOf("<", pos);
2728
2758
  const end = lt < 0 ? n2 : lt;
2729
2759
  if (end > pos) {
2730
2760
  const text3 = decode(source.slice(pos, end));
2731
- if (text3 === void 0) return void 0;
2761
+ if (text3 === void 0) return false;
2732
2762
  top.childNodes.push(text3);
2733
2763
  }
2734
2764
  if (lt < 0) break;
2735
2765
  const next = source.charCodeAt(lt + 1);
2736
2766
  if (next === 33) {
2737
2767
  const after = skipCommentOrCdata(source, lt, top);
2738
- if (after < 0) return void 0;
2768
+ if (after < 0) return false;
2739
2769
  pos = after;
2740
2770
  continue;
2741
2771
  }
2742
2772
  if (next === 47) {
2743
2773
  const gt = source.indexOf(">", lt);
2744
2774
  if (gt < 0 || stack.length < 2 || source.slice(lt + 2, gt).trimEnd() !== top.tagName)
2745
- return void 0;
2775
+ return false;
2746
2776
  stack.pop();
2747
2777
  top = stack[stack.length - 1];
2748
2778
  pos = gt + 1;
2749
2779
  continue;
2750
2780
  }
2751
2781
  const parsed = startTag(source, lt + 1, namespaces);
2752
- if (!parsed) return void 0;
2782
+ if (!parsed) return false;
2753
2783
  top.childNodes.push(parsed.element);
2754
2784
  if (!parsed.selfClosing) {
2755
2785
  stack.push(parsed.element);
@@ -2757,7 +2787,9 @@ function parseLiteFragment(xml, container, namespaces) {
2757
2787
  }
2758
2788
  pos = parsed.end;
2759
2789
  }
2760
- return stack.length === 1 ? root : void 0;
2790
+ if (stack.length !== 1) return false;
2791
+ yield* level3;
2792
+ return true;
2761
2793
  }
2762
2794
  var DECLARATIONS = /<!DOCTYPE|<!ENTITY/i;
2763
2795
  function skipCommentOrCdata(source, lt, parent) {
@@ -12393,57 +12425,99 @@ function resolveLimits(limits) {
12393
12425
  fail: (message, limit, kind) => create2 ? create2(message, { limit, kind }) : new ZipLimitError(message, { limit, kind })
12394
12426
  };
12395
12427
  }
12396
- function inflateEntryGuarded(entry3, alreadyRead, limits) {
12428
+ async function inflateEntryGuarded(entry3, alreadyRead, limits) {
12429
+ const chunks = [];
12430
+ let size = 0;
12431
+ for await (const chunk of streamEntryGuarded(entry3, alreadyRead, limits)) {
12432
+ chunks.push(chunk);
12433
+ size += chunk.byteLength;
12434
+ }
12435
+ if (chunks.length === 1 && chunks[0]) return chunks[0];
12436
+ const out = new Uint8Array(size);
12437
+ let offset = 0;
12438
+ for (const chunk of chunks) {
12439
+ out.set(chunk, offset);
12440
+ offset += chunk.byteLength;
12441
+ }
12442
+ return out;
12443
+ }
12444
+ var AHEAD = 8;
12445
+ async function* streamEntryGuarded(entry3, alreadyRead, limits) {
12397
12446
  const r = resolveLimits(limits);
12398
12447
  const declared = declaredEntrySize(entry3);
12399
- return new Promise((resolvePromise, reject2) => {
12400
- const chunks = [];
12401
- let size = 0;
12402
- let done = false;
12403
- const stream = entry3.internalStream("uint8array");
12404
- const abort = (error) => {
12405
- if (done) return;
12406
- done = true;
12407
- stream.pause();
12408
- chunks.length = 0;
12409
- reject2(error);
12410
- };
12411
- stream.on("data", (chunk) => {
12412
- if (done) return;
12413
- size += chunk.byteLength;
12414
- if (size > declared || size > r.maxEntryBytes)
12415
- return abort(
12416
- r.fail(
12417
- `${r.label} part ${entry3.name} inflates past its declared size`,
12418
- r.maxEntryBytes,
12419
- size > declared ? "declaredSize" : "maxEntryBytes"
12420
- )
12421
- );
12422
- if (alreadyRead + size > r.maxTotalBytes)
12423
- return abort(
12424
- r.fail(
12425
- `${r.label} package exceeds the ${mib(r.maxTotalBytes)} MiB uncompressed content limit`,
12426
- r.maxTotalBytes,
12427
- "maxTotalBytes"
12428
- )
12429
- );
12430
- chunks.push(chunk);
12431
- });
12432
- stream.on("error", (error) => abort(error));
12433
- stream.on("end", () => {
12434
- if (done) return;
12435
- done = true;
12436
- if (chunks.length === 1 && chunks[0]) return resolvePromise(chunks[0]);
12437
- const out = new Uint8Array(size);
12438
- let offset = 0;
12439
- for (const chunk of chunks) {
12440
- out.set(chunk, offset);
12441
- offset += chunk.byteLength;
12442
- }
12443
- resolvePromise(out);
12444
- });
12448
+ const stream = entry3.internalStream("uint8array");
12449
+ const queue = [];
12450
+ let size = 0;
12451
+ let ended = false;
12452
+ let stopped = false;
12453
+ let failure;
12454
+ let paused = false;
12455
+ let wake;
12456
+ const pause = () => {
12457
+ paused = true;
12458
+ stream.pause();
12459
+ };
12460
+ const resume = () => {
12461
+ if (!paused || stopped) return;
12462
+ paused = false;
12445
12463
  stream.resume();
12464
+ };
12465
+ const fail = (error) => {
12466
+ failure ??= error;
12467
+ stopped = true;
12468
+ queue.length = 0;
12469
+ pause();
12470
+ wake?.();
12471
+ };
12472
+ stream.on("data", (chunk) => {
12473
+ if (stopped) return pause();
12474
+ size += chunk.byteLength;
12475
+ if (size > declared || size > r.maxEntryBytes)
12476
+ return fail(
12477
+ r.fail(
12478
+ `${r.label} part ${entry3.name} inflates past its declared size`,
12479
+ r.maxEntryBytes,
12480
+ size > declared ? "declaredSize" : "maxEntryBytes"
12481
+ )
12482
+ );
12483
+ if (alreadyRead + size > r.maxTotalBytes)
12484
+ return fail(
12485
+ r.fail(
12486
+ `${r.label} package exceeds the ${mib(r.maxTotalBytes)} MiB uncompressed content limit`,
12487
+ r.maxTotalBytes,
12488
+ "maxTotalBytes"
12489
+ )
12490
+ );
12491
+ queue.push(chunk);
12492
+ if (queue.length >= AHEAD) pause();
12493
+ wake?.();
12494
+ });
12495
+ stream.on("error", (error) => fail(error));
12496
+ stream.on("end", () => {
12497
+ ended = true;
12498
+ wake?.();
12446
12499
  });
12500
+ stream.resume();
12501
+ try {
12502
+ for (; ; ) {
12503
+ if (failure) throw failure;
12504
+ const chunk = queue.shift();
12505
+ if (chunk) {
12506
+ if (queue.length < AHEAD / 2) resume();
12507
+ yield chunk;
12508
+ continue;
12509
+ }
12510
+ if (ended) return;
12511
+ await new Promise((resolve) => {
12512
+ wake = resolve;
12513
+ resume();
12514
+ });
12515
+ wake = void 0;
12516
+ }
12517
+ } finally {
12518
+ stopped = true;
12519
+ if (!ended) pause();
12520
+ }
12447
12521
  }
12448
12522
  function toBase64(bytes) {
12449
12523
  let binary = "";
@@ -40323,6 +40397,7 @@ __export(opc_exports, {
40323
40397
  replaceTitleGroup: () => replaceTitleGroup,
40324
40398
  resolvePartPath: () => resolvePartPath,
40325
40399
  signature: () => signature_exports,
40400
+ streamEntryGuarded: () => streamEntryGuarded,
40326
40401
  titleGroups: () => titleGroups,
40327
40402
  writeAppProperties: () => writeAppProperties,
40328
40403
  writeCoreProperties: () => writeCoreProperties,