ooxml-core 1.25.2 → 1.26.0
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.
- package/README.md +16 -0
- package/dist/{PptxHandler-AUK27AQD.mjs → PptxHandler-5QBRBXRX.mjs} +3 -3
- package/dist/{PptxHandler-QBGEZDCO.cjs → PptxHandler-CVYP5PAN.cjs} +3 -3
- package/dist/PptxHandler-TOAD6P7N.mjs +4 -0
- package/dist/{PresentationBuilder-RX7D75GZ.mjs → PresentationBuilder-EBVNYMLE.mjs} +2 -2
- package/dist/{PresentationBuilder-MEETJGEA.mjs → PresentationBuilder-M5UXW4AF.mjs} +3 -3
- package/dist/{PresentationBuilder-CI45KEHL.cjs → PresentationBuilder-RVQZCTIO.cjs} +5 -5
- package/dist/automation/index.cjs +273 -156
- package/dist/automation/index.mjs +273 -156
- package/dist/automation/xlsx-read.d.ts +2 -8
- package/dist/automation/xlsx-read.d.ts.map +1 -1
- package/dist/automation/xlsx.d.ts +2 -2
- package/dist/chart/index.cjs +89 -47
- package/dist/chart/index.mjs +89 -47
- package/dist/{chunk-6DHZZD5R.mjs → chunk-2XMK5SXU.mjs} +106 -48
- package/dist/{chunk-TX2QFS3J.mjs → chunk-4IIR2QEH.mjs} +608 -371
- package/dist/{chunk-635WPRNJ.mjs → chunk-DNYZX6YG.mjs} +19 -3
- package/dist/{chunk-VGDHSED6.mjs → chunk-EBJ724RB.mjs} +1 -1
- package/dist/{chunk-GMETZZ3V.cjs → chunk-EEHK52XB.cjs} +1677 -1440
- package/dist/{chunk-E2PYQQQV.mjs → chunk-JJ37PCNR.mjs} +89 -47
- package/dist/{chunk-5F7OB7PA.mjs → chunk-K6OFJ5GJ.mjs} +605 -368
- package/dist/{chunk-HVRFRYYS.mjs → chunk-KONCS53X.mjs} +5 -5
- package/dist/{chunk-S5TGOEQX.cjs → chunk-MU3XSASV.cjs} +106 -47
- package/dist/{chunk-E3PRAHL6.mjs → chunk-ZXPPM63Y.mjs} +1 -1
- package/dist/docx/embedded.cjs +89 -47
- package/dist/docx/embedded.mjs +89 -47
- package/dist/docx/index.cjs +89 -47
- package/dist/docx/index.mjs +89 -47
- package/dist/docx/load/index.cjs +89 -47
- package/dist/docx/load/index.mjs +89 -47
- package/dist/index.cjs +128 -53
- package/dist/index.mjs +128 -53
- package/dist/opc/index.cjs +90 -47
- package/dist/opc/index.mjs +90 -48
- package/dist/opc/zip-limits.d.ts +6 -0
- package/dist/opc/zip-limits.d.ts.map +1 -1
- package/dist/pptx/automation/index.cjs +766 -444
- package/dist/pptx/automation/index.d.ts +4 -4
- package/dist/pptx/automation/index.mjs +6 -6
- package/dist/pptx/chunks/{index-CgjEEpfK.d.ts → index-B94RKk84.d.ts} +276 -115
- package/dist/pptx/chunks/index-B94RKk84.d.ts.map +1 -0
- package/dist/pptx/chunks/{index-CX0RM1fF.d.ts → index-BOpULlxB.d.ts} +3 -3
- package/dist/pptx/chunks/{index-CX0RM1fF.d.ts.map → index-BOpULlxB.d.ts.map} +1 -1
- package/dist/pptx/chunks/{index-DCbp5fOs.d.ts → index-D3gKRIAi.d.ts} +12 -5
- package/dist/pptx/chunks/{index-DCbp5fOs.d.ts.map → index-D3gKRIAi.d.ts.map} +1 -1
- package/dist/pptx/chunks/{text-operations-CjalmJIi.d.ts → text-operations-CNfUj45U.d.ts} +16 -2
- package/dist/pptx/chunks/{text-operations-CjalmJIi.d.ts.map → text-operations-CNfUj45U.d.ts.map} +1 -1
- package/dist/pptx/cli/index.cjs +766 -444
- package/dist/pptx/cli/index.d.ts +1 -1
- package/dist/pptx/cli/index.mjs +5 -5
- package/dist/pptx/converter/index.d.ts +1 -1
- package/dist/pptx/converter/index.mjs +3 -3
- package/dist/pptx/editor/render/editor-history.cjs +21 -0
- package/dist/pptx/editor/render/editor-history.d.ts +9 -0
- package/dist/pptx/editor/render/editor-history.d.ts.map +1 -1
- package/dist/pptx/editor/render/editor-history.mjs +21 -0
- package/dist/pptx/editor/render/find-replace.cjs +14 -14
- package/dist/pptx/editor/render/find-replace.d.ts +2 -2
- package/dist/pptx/editor/render/find-replace.mjs +1 -1
- package/dist/pptx/editor/render/slide-operations.cjs +8 -8
- package/dist/pptx/editor/render/slide-operations.mjs +2 -2
- package/dist/pptx/index.cjs +765 -442
- package/dist/pptx/index.d.ts +5 -5
- package/dist/pptx/index.mjs +6 -6
- package/dist/pptx/node/index.d.ts +1 -1
- package/dist/pptx/signature-node/index.cjs +89 -47
- package/dist/pptx/signature-node/index.mjs +2 -2
- package/dist/visio/index.cjs +266 -150
- package/dist/visio/index.mjs +266 -150
- package/dist/visio/ui/index.cjs +266 -150
- package/dist/visio/ui/index.mjs +266 -150
- package/dist/xlsx/index.cjs +518 -153
- package/dist/xlsx/index.mjs +518 -154
- package/dist/xlsx/load/index.cjs +266 -150
- package/dist/xlsx/load/index.mjs +266 -150
- package/dist/xlsx/numfmt/view.d.ts +13 -0
- package/dist/xlsx/numfmt/view.d.ts.map +1 -0
- package/dist/xlsx/read/index.d.ts +1 -0
- package/dist/xlsx/read/index.d.ts.map +1 -1
- package/dist/xlsx/read/limits.d.ts +5 -0
- package/dist/xlsx/read/limits.d.ts.map +1 -1
- package/dist/xlsx/read/package.d.ts +6 -0
- package/dist/xlsx/read/package.d.ts.map +1 -1
- package/dist/xlsx/read/rows-stream.d.ts +12 -0
- package/dist/xlsx/read/rows-stream.d.ts.map +1 -0
- package/dist/xlsx/read/rows.d.ts +37 -0
- package/dist/xlsx/read/rows.d.ts.map +1 -0
- package/dist/xlsx/read/shared-strings.d.ts +6 -1
- package/dist/xlsx/read/shared-strings.d.ts.map +1 -1
- package/dist/xlsx/read/sheet-data-source.d.ts +30 -3
- package/dist/xlsx/read/sheet-data-source.d.ts.map +1 -1
- package/dist/xlsx/read/sheet-data.d.ts +13 -2
- package/dist/xlsx/read/sheet-data.d.ts.map +1 -1
- package/dist/xlsx/read/worksheet.d.ts.map +1 -1
- package/dist/xlsx/ui/index.cjs +266 -150
- package/dist/xlsx/ui/index.mjs +266 -150
- package/dist/xml/index.cjs +38 -6
- package/dist/xml/index.mjs +37 -7
- package/dist/xml/lite.d.ts +15 -0
- package/dist/xml/lite.d.ts.map +1 -1
- package/package.json +1 -1
- package/dist/PptxHandler-5UO5DD5K.mjs +0 -4
- package/dist/pptx/chunks/index-CgjEEpfK.d.ts.map +0 -1
package/dist/docx/index.mjs
CHANGED
|
@@ -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
|
-
|
|
2641
|
-
|
|
2642
|
-
|
|
2643
|
-
|
|
2644
|
-
|
|
2645
|
-
|
|
2646
|
-
|
|
2647
|
-
|
|
2648
|
-
|
|
2649
|
-
|
|
2650
|
-
|
|
2651
|
-
|
|
2652
|
-
|
|
2653
|
-
|
|
2654
|
-
|
|
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 = "";
|
package/dist/docx/load/index.cjs
CHANGED
|
@@ -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
|
-
|
|
3708
|
-
|
|
3709
|
-
|
|
3710
|
-
|
|
3711
|
-
|
|
3712
|
-
|
|
3713
|
-
|
|
3714
|
-
|
|
3715
|
-
|
|
3716
|
-
|
|
3717
|
-
|
|
3718
|
-
|
|
3719
|
-
|
|
3720
|
-
|
|
3721
|
-
|
|
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 = "";
|
package/dist/docx/load/index.mjs
CHANGED
|
@@ -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
|
-
|
|
3702
|
-
|
|
3703
|
-
|
|
3704
|
-
|
|
3705
|
-
|
|
3706
|
-
|
|
3707
|
-
|
|
3708
|
-
|
|
3709
|
-
|
|
3710
|
-
|
|
3711
|
-
|
|
3712
|
-
|
|
3713
|
-
|
|
3714
|
-
|
|
3715
|
-
|
|
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 =
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
-
|
|
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
|
-
|
|
12400
|
-
|
|
12401
|
-
|
|
12402
|
-
|
|
12403
|
-
|
|
12404
|
-
|
|
12405
|
-
|
|
12406
|
-
|
|
12407
|
-
|
|
12408
|
-
|
|
12409
|
-
|
|
12410
|
-
|
|
12411
|
-
|
|
12412
|
-
|
|
12413
|
-
|
|
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,
|