ooxml-core 1.25.1 → 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/layout/index.cjs +2 -2
- package/dist/docx/layout/index.mjs +2 -2
- package/dist/docx/layout/input.d.ts +6 -1
- package/dist/docx/layout/input.d.ts.map +1 -1
- package/dist/docx/layout/result.d.ts +1 -0
- package/dist/docx/layout/result.d.ts.map +1 -1
- 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/xlsx/index.cjs
CHANGED
|
@@ -1738,6 +1738,37 @@ function formatValue(value2, format, options2 = {}) {
|
|
|
1738
1738
|
function isDateFormat(format) {
|
|
1739
1739
|
return compileFormat(format).isDate;
|
|
1740
1740
|
}
|
|
1741
|
+
var DAY_PARTS = /* @__PURE__ */ new Set([
|
|
1742
|
+
"y",
|
|
1743
|
+
"yyyy",
|
|
1744
|
+
"e",
|
|
1745
|
+
"g",
|
|
1746
|
+
"b",
|
|
1747
|
+
"bbbb",
|
|
1748
|
+
"m",
|
|
1749
|
+
"mm",
|
|
1750
|
+
"mmm",
|
|
1751
|
+
"mmmm",
|
|
1752
|
+
"mmmmm",
|
|
1753
|
+
"d",
|
|
1754
|
+
"dd",
|
|
1755
|
+
"ddd",
|
|
1756
|
+
"dddd"
|
|
1757
|
+
]);
|
|
1758
|
+
function dateTimeParts(format, value2) {
|
|
1759
|
+
const section = chooseSection(compileFormat(format), value2)?.section;
|
|
1760
|
+
if (section?.kind !== "date") return void 0;
|
|
1761
|
+
let date = false;
|
|
1762
|
+
let time = false;
|
|
1763
|
+
for (const token of section.tokens) {
|
|
1764
|
+
if (token.t === "elapsed") return void 0;
|
|
1765
|
+
if (token.t === "date") {
|
|
1766
|
+
if (DAY_PARTS.has(token.part)) date = true;
|
|
1767
|
+
else time = true;
|
|
1768
|
+
} else if (token.t === "ampm" || token.t === "subsec") time = true;
|
|
1769
|
+
}
|
|
1770
|
+
return date || time ? { date, time } : void 0;
|
|
1771
|
+
}
|
|
1741
1772
|
|
|
1742
1773
|
// xlsx/numfmt/input-date.ts
|
|
1743
1774
|
var MONTH_NAMES = [
|
|
@@ -12055,40 +12086,61 @@ function decode(text3) {
|
|
|
12055
12086
|
}
|
|
12056
12087
|
var isSpace2 = (code) => code === 32 || code === 9 || code === 10 || code === 13;
|
|
12057
12088
|
var hasLineEnds = (xml) => xml.includes("\r") || xml.includes("\x85") || xml.includes("\u2028") || xml.includes("\u2029");
|
|
12058
|
-
|
|
12089
|
+
var LiteDeclinedError = class extends Error {
|
|
12090
|
+
constructor() {
|
|
12091
|
+
super("The XML fragment needs the full parser");
|
|
12092
|
+
this.name = "LiteDeclinedError";
|
|
12093
|
+
}
|
|
12094
|
+
};
|
|
12095
|
+
function* liteChildElements(xml, namespaces) {
|
|
12096
|
+
const nodes = topLevelNodes(xml, namespaces);
|
|
12097
|
+
for (let next = nodes.next(); ; next = nodes.next()) {
|
|
12098
|
+
if (next.done) {
|
|
12099
|
+
if (next.value) return;
|
|
12100
|
+
throw new LiteDeclinedError();
|
|
12101
|
+
}
|
|
12102
|
+
if (typeof next.value !== "string") yield next.value.asElement();
|
|
12103
|
+
}
|
|
12104
|
+
}
|
|
12105
|
+
function* topLevelNodes(xml, namespaces) {
|
|
12059
12106
|
const source2 = hasLineEnds(xml) ? xml.replace(/\r[\n\u0085]/g, "\n").replace(/[\r\u0085\u2028\u2029]/g, "\n") : xml;
|
|
12060
|
-
const root =
|
|
12107
|
+
const root = new LiteElement("", "", null);
|
|
12108
|
+
const level2 = root.childNodes;
|
|
12061
12109
|
const stack2 = [root];
|
|
12062
12110
|
let top = root;
|
|
12063
12111
|
const n2 = source2.length;
|
|
12064
12112
|
let pos = 0;
|
|
12065
12113
|
while (pos < n2) {
|
|
12114
|
+
if (level2.length && stack2.length === 1) {
|
|
12115
|
+
yield* level2;
|
|
12116
|
+
level2.length = 0;
|
|
12117
|
+
}
|
|
12066
12118
|
const lt = source2.indexOf("<", pos);
|
|
12067
12119
|
const end = lt < 0 ? n2 : lt;
|
|
12068
12120
|
if (end > pos) {
|
|
12069
12121
|
const text3 = decode(source2.slice(pos, end));
|
|
12070
|
-
if (text3 === void 0) return
|
|
12122
|
+
if (text3 === void 0) return false;
|
|
12071
12123
|
top.childNodes.push(text3);
|
|
12072
12124
|
}
|
|
12073
12125
|
if (lt < 0) break;
|
|
12074
12126
|
const next = source2.charCodeAt(lt + 1);
|
|
12075
12127
|
if (next === 33) {
|
|
12076
12128
|
const after = skipCommentOrCdata(source2, lt, top);
|
|
12077
|
-
if (after < 0) return
|
|
12129
|
+
if (after < 0) return false;
|
|
12078
12130
|
pos = after;
|
|
12079
12131
|
continue;
|
|
12080
12132
|
}
|
|
12081
12133
|
if (next === 47) {
|
|
12082
12134
|
const gt = source2.indexOf(">", lt);
|
|
12083
12135
|
if (gt < 0 || stack2.length < 2 || source2.slice(lt + 2, gt).trimEnd() !== top.tagName)
|
|
12084
|
-
return
|
|
12136
|
+
return false;
|
|
12085
12137
|
stack2.pop();
|
|
12086
12138
|
top = stack2[stack2.length - 1];
|
|
12087
12139
|
pos = gt + 1;
|
|
12088
12140
|
continue;
|
|
12089
12141
|
}
|
|
12090
12142
|
const parsed = startTag(source2, lt + 1, namespaces);
|
|
12091
|
-
if (!parsed) return
|
|
12143
|
+
if (!parsed) return false;
|
|
12092
12144
|
top.childNodes.push(parsed.element);
|
|
12093
12145
|
if (!parsed.selfClosing) {
|
|
12094
12146
|
stack2.push(parsed.element);
|
|
@@ -12096,7 +12148,9 @@ function parseLiteFragment(xml, container, namespaces) {
|
|
|
12096
12148
|
}
|
|
12097
12149
|
pos = parsed.end;
|
|
12098
12150
|
}
|
|
12099
|
-
|
|
12151
|
+
if (stack2.length !== 1) return false;
|
|
12152
|
+
yield* level2;
|
|
12153
|
+
return true;
|
|
12100
12154
|
}
|
|
12101
12155
|
var DECLARATIONS = /<!DOCTYPE|<!ENTITY/i;
|
|
12102
12156
|
function skipCommentOrCdata(source2, lt, parent) {
|
|
@@ -16873,57 +16927,99 @@ function resolveLimits(limits) {
|
|
|
16873
16927
|
fail: (message, limit2, kind) => create ? create(message, { limit: limit2, kind }) : new ZipLimitError(message, { limit: limit2, kind })
|
|
16874
16928
|
};
|
|
16875
16929
|
}
|
|
16876
|
-
function inflateEntryGuarded(entry3, alreadyRead, limits) {
|
|
16930
|
+
async function inflateEntryGuarded(entry3, alreadyRead, limits) {
|
|
16931
|
+
const chunks2 = [];
|
|
16932
|
+
let size = 0;
|
|
16933
|
+
for await (const chunk of streamEntryGuarded(entry3, alreadyRead, limits)) {
|
|
16934
|
+
chunks2.push(chunk);
|
|
16935
|
+
size += chunk.byteLength;
|
|
16936
|
+
}
|
|
16937
|
+
if (chunks2.length === 1 && chunks2[0]) return chunks2[0];
|
|
16938
|
+
const out = new Uint8Array(size);
|
|
16939
|
+
let offset2 = 0;
|
|
16940
|
+
for (const chunk of chunks2) {
|
|
16941
|
+
out.set(chunk, offset2);
|
|
16942
|
+
offset2 += chunk.byteLength;
|
|
16943
|
+
}
|
|
16944
|
+
return out;
|
|
16945
|
+
}
|
|
16946
|
+
var AHEAD = 8;
|
|
16947
|
+
async function* streamEntryGuarded(entry3, alreadyRead, limits) {
|
|
16877
16948
|
const r = resolveLimits(limits);
|
|
16878
16949
|
const declared = declaredEntrySize(entry3);
|
|
16879
|
-
|
|
16880
|
-
|
|
16881
|
-
|
|
16882
|
-
|
|
16883
|
-
|
|
16884
|
-
|
|
16885
|
-
|
|
16886
|
-
|
|
16887
|
-
|
|
16888
|
-
|
|
16889
|
-
|
|
16890
|
-
|
|
16891
|
-
|
|
16892
|
-
|
|
16893
|
-
|
|
16894
|
-
if (size > declared || size > r.maxEntryBytes)
|
|
16895
|
-
return abort(
|
|
16896
|
-
r.fail(
|
|
16897
|
-
`${r.label} part ${entry3.name} inflates past its declared size`,
|
|
16898
|
-
r.maxEntryBytes,
|
|
16899
|
-
size > declared ? "declaredSize" : "maxEntryBytes"
|
|
16900
|
-
)
|
|
16901
|
-
);
|
|
16902
|
-
if (alreadyRead + size > r.maxTotalBytes)
|
|
16903
|
-
return abort(
|
|
16904
|
-
r.fail(
|
|
16905
|
-
`${r.label} package exceeds the ${mib(r.maxTotalBytes)} MiB uncompressed content limit`,
|
|
16906
|
-
r.maxTotalBytes,
|
|
16907
|
-
"maxTotalBytes"
|
|
16908
|
-
)
|
|
16909
|
-
);
|
|
16910
|
-
chunks2.push(chunk);
|
|
16911
|
-
});
|
|
16912
|
-
stream.on("error", (error) => abort(error));
|
|
16913
|
-
stream.on("end", () => {
|
|
16914
|
-
if (done) return;
|
|
16915
|
-
done = true;
|
|
16916
|
-
if (chunks2.length === 1 && chunks2[0]) return resolvePromise(chunks2[0]);
|
|
16917
|
-
const out = new Uint8Array(size);
|
|
16918
|
-
let offset2 = 0;
|
|
16919
|
-
for (const chunk of chunks2) {
|
|
16920
|
-
out.set(chunk, offset2);
|
|
16921
|
-
offset2 += chunk.byteLength;
|
|
16922
|
-
}
|
|
16923
|
-
resolvePromise(out);
|
|
16924
|
-
});
|
|
16950
|
+
const stream = entry3.internalStream("uint8array");
|
|
16951
|
+
const queue = [];
|
|
16952
|
+
let size = 0;
|
|
16953
|
+
let ended = false;
|
|
16954
|
+
let stopped = false;
|
|
16955
|
+
let failure2;
|
|
16956
|
+
let paused = false;
|
|
16957
|
+
let wake;
|
|
16958
|
+
const pause = () => {
|
|
16959
|
+
paused = true;
|
|
16960
|
+
stream.pause();
|
|
16961
|
+
};
|
|
16962
|
+
const resume = () => {
|
|
16963
|
+
if (!paused || stopped) return;
|
|
16964
|
+
paused = false;
|
|
16925
16965
|
stream.resume();
|
|
16966
|
+
};
|
|
16967
|
+
const fail2 = (error) => {
|
|
16968
|
+
failure2 ??= error;
|
|
16969
|
+
stopped = true;
|
|
16970
|
+
queue.length = 0;
|
|
16971
|
+
pause();
|
|
16972
|
+
wake?.();
|
|
16973
|
+
};
|
|
16974
|
+
stream.on("data", (chunk) => {
|
|
16975
|
+
if (stopped) return pause();
|
|
16976
|
+
size += chunk.byteLength;
|
|
16977
|
+
if (size > declared || size > r.maxEntryBytes)
|
|
16978
|
+
return fail2(
|
|
16979
|
+
r.fail(
|
|
16980
|
+
`${r.label} part ${entry3.name} inflates past its declared size`,
|
|
16981
|
+
r.maxEntryBytes,
|
|
16982
|
+
size > declared ? "declaredSize" : "maxEntryBytes"
|
|
16983
|
+
)
|
|
16984
|
+
);
|
|
16985
|
+
if (alreadyRead + size > r.maxTotalBytes)
|
|
16986
|
+
return fail2(
|
|
16987
|
+
r.fail(
|
|
16988
|
+
`${r.label} package exceeds the ${mib(r.maxTotalBytes)} MiB uncompressed content limit`,
|
|
16989
|
+
r.maxTotalBytes,
|
|
16990
|
+
"maxTotalBytes"
|
|
16991
|
+
)
|
|
16992
|
+
);
|
|
16993
|
+
queue.push(chunk);
|
|
16994
|
+
if (queue.length >= AHEAD) pause();
|
|
16995
|
+
wake?.();
|
|
16926
16996
|
});
|
|
16997
|
+
stream.on("error", (error) => fail2(error));
|
|
16998
|
+
stream.on("end", () => {
|
|
16999
|
+
ended = true;
|
|
17000
|
+
wake?.();
|
|
17001
|
+
});
|
|
17002
|
+
stream.resume();
|
|
17003
|
+
try {
|
|
17004
|
+
for (; ; ) {
|
|
17005
|
+
if (failure2) throw failure2;
|
|
17006
|
+
const chunk = queue.shift();
|
|
17007
|
+
if (chunk) {
|
|
17008
|
+
if (queue.length < AHEAD / 2) resume();
|
|
17009
|
+
yield chunk;
|
|
17010
|
+
continue;
|
|
17011
|
+
}
|
|
17012
|
+
if (ended) return;
|
|
17013
|
+
await new Promise((resolve3) => {
|
|
17014
|
+
wake = resolve3;
|
|
17015
|
+
resume();
|
|
17016
|
+
});
|
|
17017
|
+
wake = void 0;
|
|
17018
|
+
}
|
|
17019
|
+
} finally {
|
|
17020
|
+
stopped = true;
|
|
17021
|
+
if (!ended) pause();
|
|
17022
|
+
}
|
|
16927
17023
|
}
|
|
16928
17024
|
function toBase64(bytes) {
|
|
16929
17025
|
let binary = "";
|
|
@@ -19067,15 +19163,21 @@ function zipLimitsFor(limits) {
|
|
|
19067
19163
|
}
|
|
19068
19164
|
};
|
|
19069
19165
|
}
|
|
19166
|
+
function workbookLimit(error) {
|
|
19167
|
+
return error instanceof XmlLimitError && error.limit === "maxNodes" ? new WorkbookTooLargeError(error.message, "maxXmlElements", error.maximum, { cause: error }) : error;
|
|
19168
|
+
}
|
|
19070
19169
|
function parseDataXml(xml, label2, maxXmlElements = DEFAULT_XLSX_LOAD_LIMITS.maxXmlElements) {
|
|
19071
19170
|
try {
|
|
19072
19171
|
return parseXml(xml, { label: label2, limits: { maxNodes: maxXmlElements } });
|
|
19073
19172
|
} catch (error) {
|
|
19074
|
-
|
|
19075
|
-
|
|
19076
|
-
|
|
19077
|
-
|
|
19078
|
-
|
|
19173
|
+
throw workbookLimit(error);
|
|
19174
|
+
}
|
|
19175
|
+
}
|
|
19176
|
+
function checkDataXml(xml, label2, maxXmlElements = DEFAULT_XLSX_LOAD_LIMITS.maxXmlElements) {
|
|
19177
|
+
try {
|
|
19178
|
+
checkXmlLimits(xml, label2, { maxNodes: maxXmlElements });
|
|
19179
|
+
} catch (error) {
|
|
19180
|
+
throw workbookLimit(error);
|
|
19079
19181
|
}
|
|
19080
19182
|
}
|
|
19081
19183
|
var CONTENT_TYPES = {
|
|
@@ -19166,9 +19268,8 @@ var SourceIndex = class {
|
|
|
19166
19268
|
}
|
|
19167
19269
|
};
|
|
19168
19270
|
var mib2 = (bytes) => Math.round(bytes / 1048576);
|
|
19169
|
-
async function
|
|
19170
|
-
const
|
|
19171
|
-
const maxInput = resolved.maxInputBytes;
|
|
19271
|
+
async function openPackage(input, limits) {
|
|
19272
|
+
const maxInput = limits.maxInputBytes;
|
|
19172
19273
|
const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
|
|
19173
19274
|
if (bytes.byteLength > maxInput)
|
|
19174
19275
|
throw new WorkbookTooLargeError(
|
|
@@ -19185,7 +19286,10 @@ async function readZipParts(input, limits = {}) {
|
|
|
19185
19286
|
{ cause: error }
|
|
19186
19287
|
);
|
|
19187
19288
|
}
|
|
19188
|
-
|
|
19289
|
+
return guardZip(loaded, zipLimitsFor(limits));
|
|
19290
|
+
}
|
|
19291
|
+
async function readZipParts(input, limits = {}) {
|
|
19292
|
+
const zip = await openPackage(input, resolveLoadLimits(limits));
|
|
19189
19293
|
const parts = /* @__PURE__ */ new Map();
|
|
19190
19294
|
for (const entry3 of Object.values(zip.files)) {
|
|
19191
19295
|
if (entry3.dir) continue;
|
|
@@ -19230,6 +19334,92 @@ function parseDynamicArrayMetadata(xml) {
|
|
|
19230
19334
|
return out;
|
|
19231
19335
|
}
|
|
19232
19336
|
|
|
19337
|
+
// xlsx/read/sheet-data-source.ts
|
|
19338
|
+
var ROOT = /^\uFEFF?(?:\s*<\?[^]*?\?>)?\s*<([A-Za-z_][\w.:-]*)((?:\s[^>]*)?)>/;
|
|
19339
|
+
var DECLARATION = /\sxmlns(?::([\w.-]+))?\s*=\s*(["'])(.*?)\2/g;
|
|
19340
|
+
var OPEN = /<((?:[A-Za-z_][\w.-]*:)?)sheetData(?=[\s/>])/;
|
|
19341
|
+
function rootNamespaces(xml) {
|
|
19342
|
+
const root = ROOT.exec(xml.slice(0, 8192));
|
|
19343
|
+
if (!root) return void 0;
|
|
19344
|
+
const out = {};
|
|
19345
|
+
for (const match2 of (root[2] ?? "").matchAll(DECLARATION)) out[match2[1] ?? ""] = match2[3] ?? "";
|
|
19346
|
+
return out;
|
|
19347
|
+
}
|
|
19348
|
+
var SPECIAL = /<[!?]/g;
|
|
19349
|
+
var SECTIONS = [
|
|
19350
|
+
["<!--", "-->"],
|
|
19351
|
+
["<![CDATA[", "]]>"],
|
|
19352
|
+
["<?", "?>"]
|
|
19353
|
+
];
|
|
19354
|
+
function blankComments(xml) {
|
|
19355
|
+
if (!xml.includes("<!--") && !xml.includes("<![CDATA[")) return xml;
|
|
19356
|
+
const pieces2 = [];
|
|
19357
|
+
let copied = 0;
|
|
19358
|
+
SPECIAL.lastIndex = 0;
|
|
19359
|
+
for (let match2 = SPECIAL.exec(xml); match2; match2 = SPECIAL.exec(xml)) {
|
|
19360
|
+
const at = match2.index;
|
|
19361
|
+
const section = SECTIONS.find(([open2]) => xml.startsWith(open2, at));
|
|
19362
|
+
if (!section) return void 0;
|
|
19363
|
+
const [open, close2] = section;
|
|
19364
|
+
const end = xml.indexOf(close2, at + open.length);
|
|
19365
|
+
if (end < 0) return void 0;
|
|
19366
|
+
const after = end + close2.length;
|
|
19367
|
+
if (open !== "<?") {
|
|
19368
|
+
pieces2.push(xml.slice(copied, at), " ".repeat(after - at));
|
|
19369
|
+
copied = after;
|
|
19370
|
+
}
|
|
19371
|
+
SPECIAL.lastIndex = after;
|
|
19372
|
+
}
|
|
19373
|
+
pieces2.push(xml.slice(copied));
|
|
19374
|
+
return pieces2.join("");
|
|
19375
|
+
}
|
|
19376
|
+
var DECLARATIONS2 = /<!DOCTYPE|<!ENTITY/i;
|
|
19377
|
+
function rootChildren(xml) {
|
|
19378
|
+
if (DECLARATIONS2.test(xml)) return void 0;
|
|
19379
|
+
const plain3 = blankComments(xml);
|
|
19380
|
+
if (plain3 === void 0) return void 0;
|
|
19381
|
+
const namespaces = rootNamespaces(plain3);
|
|
19382
|
+
const root = ROOT.exec(plain3.slice(0, 8192));
|
|
19383
|
+
if (!namespaces || !root || (root[2] ?? "").trimEnd().endsWith("/")) return void 0;
|
|
19384
|
+
const close2 = plain3.lastIndexOf(`</${root[1] ?? ""}`);
|
|
19385
|
+
if (close2 < root[0].length || !/^<\/[^\s>]+\s*>\s*$/.test(plain3.slice(close2))) return void 0;
|
|
19386
|
+
const content2 = xml.slice(root[0].length, close2);
|
|
19387
|
+
return { [Symbol.iterator]: () => liteChildElements(content2, namespaces) };
|
|
19388
|
+
}
|
|
19389
|
+
function findSheetData(plain3) {
|
|
19390
|
+
const namespaces = rootNamespaces(plain3);
|
|
19391
|
+
const open = OPEN.exec(plain3);
|
|
19392
|
+
if (!namespaces || !open) return void 0;
|
|
19393
|
+
const prefix = (open[1] ?? "").slice(0, -1);
|
|
19394
|
+
if (prefix && namespaces[prefix] === void 0) return void 0;
|
|
19395
|
+
const tagName = `${open[1] ?? ""}sheetData`;
|
|
19396
|
+
const openEnd = plain3.indexOf(">", open.index);
|
|
19397
|
+
if (openEnd < 0) return void 0;
|
|
19398
|
+
const attributes = plain3.slice(open.index + tagName.length + 1, openEnd);
|
|
19399
|
+
if (attributes.trimEnd().endsWith("/") || attributes.includes("xmlns")) return void 0;
|
|
19400
|
+
return { namespaces, tagName, contentStart: openEnd + 1 };
|
|
19401
|
+
}
|
|
19402
|
+
function sheetDataStart(head) {
|
|
19403
|
+
const plain3 = blankComments(head);
|
|
19404
|
+
if (plain3 === void 0) return void 0;
|
|
19405
|
+
const open = OPEN.exec(plain3);
|
|
19406
|
+
if (!open || plain3.indexOf(">", open.index) < 0) return void 0;
|
|
19407
|
+
return findSheetData(plain3) ?? false;
|
|
19408
|
+
}
|
|
19409
|
+
function splitSheetData(xml) {
|
|
19410
|
+
const plain3 = blankComments(xml);
|
|
19411
|
+
const start = plain3 === void 0 ? void 0 : findSheetData(plain3);
|
|
19412
|
+
if (plain3 === void 0 || !start) return void 0;
|
|
19413
|
+
const { namespaces, tagName, contentStart } = start;
|
|
19414
|
+
const close2 = plain3.indexOf(`</${tagName}`, contentStart);
|
|
19415
|
+
if (close2 < 0 || OPEN.test(plain3.slice(contentStart - 1))) return void 0;
|
|
19416
|
+
const data = xml.slice(contentStart, close2);
|
|
19417
|
+
return {
|
|
19418
|
+
xml: xml.slice(0, contentStart) + xml.slice(close2),
|
|
19419
|
+
rows: { [Symbol.iterator]: () => liteChildElements(data, namespaces) }
|
|
19420
|
+
};
|
|
19421
|
+
}
|
|
19422
|
+
|
|
19233
19423
|
// xlsx/read/style-parts.ts
|
|
19234
19424
|
function parseColor(element3, palette) {
|
|
19235
19425
|
if (!element3) return void 0;
|
|
@@ -19392,9 +19582,21 @@ function parseRichString(element3, palette) {
|
|
|
19392
19582
|
const text3 = parsed.map((run2) => run2.text).join("");
|
|
19393
19583
|
return { text: text3, runs: parsed };
|
|
19394
19584
|
}
|
|
19585
|
+
var LABEL = "XLSX shared strings";
|
|
19395
19586
|
function parseSharedStrings(xml, palette, maxXmlElements) {
|
|
19396
19587
|
if (!xml) return [];
|
|
19397
|
-
const
|
|
19588
|
+
const items = rootChildren(xml);
|
|
19589
|
+
if (items) {
|
|
19590
|
+
checkDataXml(xml, LABEL, maxXmlElements);
|
|
19591
|
+
try {
|
|
19592
|
+
const out = [];
|
|
19593
|
+
for (const si of items) if (named(si, "si", NS.x)) out.push(parseRichString(si, palette));
|
|
19594
|
+
return out;
|
|
19595
|
+
} catch (error) {
|
|
19596
|
+
if (!(error instanceof LiteDeclinedError)) throw error;
|
|
19597
|
+
}
|
|
19598
|
+
}
|
|
19599
|
+
const root = parseDataXml(xml, LABEL, maxXmlElements).documentElement;
|
|
19398
19600
|
return xChildren(root, "si").map((si) => parseRichString(si, palette));
|
|
19399
19601
|
}
|
|
19400
19602
|
|
|
@@ -23884,14 +24086,14 @@ var CHART_ROOT_BINDINGS = /* @__PURE__ */ new Map([
|
|
|
23884
24086
|
["a", NS.a],
|
|
23885
24087
|
["r", NS.r]
|
|
23886
24088
|
]);
|
|
23887
|
-
var
|
|
24089
|
+
var DECLARATION2 = / xmlns:([A-Za-z_][\w.-]*)="([^"]*)"/g;
|
|
23888
24090
|
function stripDeclarations(xml, bindings) {
|
|
23889
24091
|
const conflicting = /* @__PURE__ */ new Set();
|
|
23890
|
-
for (const [, prefix, uri] of xml.matchAll(
|
|
24092
|
+
for (const [, prefix, uri] of xml.matchAll(DECLARATION2))
|
|
23891
24093
|
if (prefix !== void 0 && bindings.has(prefix) && bindings.get(prefix) !== uri)
|
|
23892
24094
|
conflicting.add(prefix);
|
|
23893
24095
|
return xml.replace(
|
|
23894
|
-
|
|
24096
|
+
DECLARATION2,
|
|
23895
24097
|
(match2, prefix, uri) => bindings.get(prefix) === uri && !conflicting.has(prefix) ? "" : match2
|
|
23896
24098
|
);
|
|
23897
24099
|
}
|
|
@@ -24130,12 +24332,12 @@ function labelOptions(context, element3) {
|
|
|
24130
24332
|
}
|
|
24131
24333
|
);
|
|
24132
24334
|
}
|
|
24133
|
-
var
|
|
24335
|
+
var LABEL2 = /* @__PURE__ */ new Set([...LABEL_OPTIONS, "idx", "layout", "tx"]);
|
|
24134
24336
|
var LABELS = /* @__PURE__ */ new Set([...LABEL_OPTIONS, "dLbl", "showLeaderLines", "leaderLines"]);
|
|
24135
24337
|
function parseDataLabels(context, element3) {
|
|
24136
24338
|
if (!element3) return void 0;
|
|
24137
24339
|
const labels = children(element3, "dLbl", NS.c).map((node2) => {
|
|
24138
|
-
reportUnmodelled(context, node2,
|
|
24340
|
+
reportUnmodelled(context, node2, LABEL2);
|
|
24139
24341
|
return assignDefined(labelOptions(context, node2), {
|
|
24140
24342
|
index: cNumber(context, node2, "idx"),
|
|
24141
24343
|
tx: parseChartText(context, cChild(node2, "tx"), false),
|
|
@@ -24252,10 +24454,10 @@ var TRENDLINE_TYPES = [
|
|
|
24252
24454
|
"poly",
|
|
24253
24455
|
"power"
|
|
24254
24456
|
];
|
|
24255
|
-
var
|
|
24457
|
+
var LABEL3 = /* @__PURE__ */ new Set(["layout", "tx", "numFmt", "spPr", "txPr", "extLst"]);
|
|
24256
24458
|
function parseTrendlineLabel(context, element3) {
|
|
24257
24459
|
if (!element3) return void 0;
|
|
24258
|
-
reportUnmodelled(context, element3,
|
|
24460
|
+
reportUnmodelled(context, element3, LABEL3);
|
|
24259
24461
|
return assignDefined(
|
|
24260
24462
|
{},
|
|
24261
24463
|
{
|
|
@@ -25256,7 +25458,7 @@ function plotAreaXml(context, plotArea) {
|
|
|
25256
25458
|
}
|
|
25257
25459
|
|
|
25258
25460
|
// chart/write-space.ts
|
|
25259
|
-
var
|
|
25461
|
+
var DECLARATION3 = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
|
|
25260
25462
|
function view3DXml(view) {
|
|
25261
25463
|
if (!view) return "";
|
|
25262
25464
|
return elementXml(
|
|
@@ -25304,7 +25506,7 @@ function writeChartSpace(space, options2 = {}) {
|
|
|
25304
25506
|
valXml("autoUpdate", space.externalDataAutoUpdate)
|
|
25305
25507
|
) + raw(context, space.printSettings) + relationship("userShapes", space.userShapesRelId) + raw(context, space.extLst);
|
|
25306
25508
|
const breakAfter = options2.declarationBreak ?? "\r\n";
|
|
25307
|
-
return `${
|
|
25509
|
+
return `${DECLARATION3}${breakAfter}<c:chartSpace${declarations}>${body}</c:chartSpace>`;
|
|
25308
25510
|
}
|
|
25309
25511
|
|
|
25310
25512
|
// chart/keep-source.ts
|
|
@@ -26451,12 +26653,12 @@ function labelOptions2(context, element3) {
|
|
|
26451
26653
|
extLst: extensionList2(element3)
|
|
26452
26654
|
};
|
|
26453
26655
|
}
|
|
26454
|
-
var
|
|
26455
|
-
var LABELS2 = /* @__PURE__ */ new Set([...
|
|
26656
|
+
var LABEL4 = /* @__PURE__ */ new Set(["numFmt", "spPr", "txPr", "visibility", "separator", "extLst"]);
|
|
26657
|
+
var LABELS2 = /* @__PURE__ */ new Set([...LABEL4, "dataLabel", "dataLabelHidden"]);
|
|
26456
26658
|
function parseDataLabels2(context, element3) {
|
|
26457
26659
|
reportUnmodelled2(context, element3, LABELS2);
|
|
26458
26660
|
const labels = cxChildren(element3, "dataLabel").map((label2) => {
|
|
26459
|
-
reportUnmodelled2(context, label2,
|
|
26661
|
+
reportUnmodelled2(context, label2, LABEL4);
|
|
26460
26662
|
return assignDefined(
|
|
26461
26663
|
{},
|
|
26462
26664
|
{ index: indexAttribute(context, label2, "idx"), ...labelOptions2(context, label2) }
|
|
@@ -27271,12 +27473,17 @@ function readRowInfo(ctx, rowEl) {
|
|
|
27271
27473
|
if (boolAttr(rowEl, "collapsed")) info.collapsed = true;
|
|
27272
27474
|
return Object.keys(info).length ? info : void 0;
|
|
27273
27475
|
}
|
|
27274
|
-
function readSheetData(ctx,
|
|
27476
|
+
function readSheetData(ctx, rows, sheet) {
|
|
27477
|
+
const reader = sheetDataReader(ctx, sheet);
|
|
27478
|
+
for (const rowEl of rows) reader.read(rowEl);
|
|
27479
|
+
reader.done();
|
|
27480
|
+
}
|
|
27481
|
+
function sheetDataReader(ctx, sheet) {
|
|
27275
27482
|
const masters = /* @__PURE__ */ new Map();
|
|
27276
27483
|
const anchors = [];
|
|
27277
27484
|
let rowIndex = -1;
|
|
27278
|
-
|
|
27279
|
-
if (rowEl.localName !== "row")
|
|
27485
|
+
const read = (rowEl) => {
|
|
27486
|
+
if (rowEl.localName !== "row") return;
|
|
27280
27487
|
const r = numAttr(rowEl, "r");
|
|
27281
27488
|
rowIndex = r !== void 0 ? r - 1 : rowIndex + 1;
|
|
27282
27489
|
const info = readRowInfo(ctx, rowEl);
|
|
@@ -27317,8 +27524,8 @@ function readSheetData(ctx, sheetData, sheet) {
|
|
|
27317
27524
|
}
|
|
27318
27525
|
cells.set(colIndex, cell);
|
|
27319
27526
|
}
|
|
27320
|
-
}
|
|
27321
|
-
markSpills(sheet, anchors);
|
|
27527
|
+
};
|
|
27528
|
+
return { read, done: () => markSpills(sheet, anchors) };
|
|
27322
27529
|
}
|
|
27323
27530
|
function markSpills(sheet, anchors) {
|
|
27324
27531
|
for (const anchor of anchors) {
|
|
@@ -27344,67 +27551,6 @@ function markSpills(sheet, anchors) {
|
|
|
27344
27551
|
}
|
|
27345
27552
|
}
|
|
27346
27553
|
|
|
27347
|
-
// xlsx/read/sheet-data-source.ts
|
|
27348
|
-
var ROOT = /^\uFEFF?(?:\s*<\?[^]*?\?>)?\s*<([A-Za-z_][\w.:-]*)((?:\s[^>]*)?)>/;
|
|
27349
|
-
var DECLARATION3 = /\sxmlns(?::([\w.-]+))?\s*=\s*(["'])(.*?)\2/g;
|
|
27350
|
-
var OPEN = /<((?:[A-Za-z_][\w.-]*:)?)sheetData(?=[\s/>])/;
|
|
27351
|
-
function rootNamespaces(xml) {
|
|
27352
|
-
const root = ROOT.exec(xml.slice(0, 8192));
|
|
27353
|
-
if (!root) return void 0;
|
|
27354
|
-
const out = {};
|
|
27355
|
-
for (const match2 of (root[2] ?? "").matchAll(DECLARATION3)) out[match2[1] ?? ""] = match2[3] ?? "";
|
|
27356
|
-
return out;
|
|
27357
|
-
}
|
|
27358
|
-
var SPECIAL = /<[!?]/g;
|
|
27359
|
-
var SECTIONS = [
|
|
27360
|
-
["<!--", "-->"],
|
|
27361
|
-
["<![CDATA[", "]]>"],
|
|
27362
|
-
["<?", "?>"]
|
|
27363
|
-
];
|
|
27364
|
-
function blankComments(xml) {
|
|
27365
|
-
if (!xml.includes("<!--") && !xml.includes("<![CDATA[")) return xml;
|
|
27366
|
-
const pieces = [];
|
|
27367
|
-
let copied = 0;
|
|
27368
|
-
SPECIAL.lastIndex = 0;
|
|
27369
|
-
for (let match2 = SPECIAL.exec(xml); match2; match2 = SPECIAL.exec(xml)) {
|
|
27370
|
-
const at = match2.index;
|
|
27371
|
-
const section = SECTIONS.find(([open2]) => xml.startsWith(open2, at));
|
|
27372
|
-
if (!section) return void 0;
|
|
27373
|
-
const [open, close2] = section;
|
|
27374
|
-
const end = xml.indexOf(close2, at + open.length);
|
|
27375
|
-
if (end < 0) return void 0;
|
|
27376
|
-
const after = end + close2.length;
|
|
27377
|
-
if (open !== "<?") {
|
|
27378
|
-
pieces.push(xml.slice(copied, at), " ".repeat(after - at));
|
|
27379
|
-
copied = after;
|
|
27380
|
-
}
|
|
27381
|
-
SPECIAL.lastIndex = after;
|
|
27382
|
-
}
|
|
27383
|
-
pieces.push(xml.slice(copied));
|
|
27384
|
-
return pieces.join("");
|
|
27385
|
-
}
|
|
27386
|
-
function splitSheetData(xml) {
|
|
27387
|
-
const plain3 = blankComments(xml);
|
|
27388
|
-
if (plain3 === void 0) return void 0;
|
|
27389
|
-
const namespaces = rootNamespaces(plain3);
|
|
27390
|
-
const open = OPEN.exec(plain3);
|
|
27391
|
-
if (!namespaces || !open) return void 0;
|
|
27392
|
-
const prefix = (open[1] ?? "").slice(0, -1);
|
|
27393
|
-
const ns = namespaces[prefix];
|
|
27394
|
-
if (prefix && ns === void 0) return void 0;
|
|
27395
|
-
const tagName = `${open[1] ?? ""}sheetData`;
|
|
27396
|
-
const openEnd = plain3.indexOf(">", open.index);
|
|
27397
|
-
if (openEnd < 0) return void 0;
|
|
27398
|
-
const attributes = plain3.slice(open.index + tagName.length + 1, openEnd);
|
|
27399
|
-
if (attributes.trimEnd().endsWith("/") || attributes.includes("xmlns")) return void 0;
|
|
27400
|
-
const close2 = plain3.indexOf(`</${tagName}`, openEnd);
|
|
27401
|
-
if (close2 < 0 || OPEN.test(plain3.slice(openEnd))) return void 0;
|
|
27402
|
-
const container = new LiteElement(tagName, "sheetData", ns || null);
|
|
27403
|
-
const data = parseLiteFragment(xml.slice(openEnd + 1, close2), container, namespaces);
|
|
27404
|
-
if (!data) return void 0;
|
|
27405
|
-
return { xml: xml.slice(0, openEnd + 1) + xml.slice(close2), sheetData: data.asElement() };
|
|
27406
|
-
}
|
|
27407
|
-
|
|
27408
27554
|
// xlsx/read/scenarios.ts
|
|
27409
27555
|
function readScenarios(node2) {
|
|
27410
27556
|
if (!node2) return void 0;
|
|
@@ -27595,19 +27741,27 @@ function readComments(ctx, partName, sheet) {
|
|
|
27595
27741
|
sheet.comments = mergeComments(legacy, threaded);
|
|
27596
27742
|
}
|
|
27597
27743
|
function parseWorksheet(ctx, partName, name, sheetId) {
|
|
27598
|
-
const sheet = createWorksheet(name, sheetId);
|
|
27599
|
-
sheet.partName = partName;
|
|
27600
27744
|
const xml = ctx.source.text(partName);
|
|
27601
27745
|
if (!xml) {
|
|
27746
|
+
const sheet = createWorksheet(name, sheetId);
|
|
27747
|
+
sheet.partName = partName;
|
|
27602
27748
|
ctx.warn(`Sheet "${name}" has no part ${partName}; it was loaded empty.`);
|
|
27603
27749
|
return sheet;
|
|
27604
27750
|
}
|
|
27605
27751
|
const split = splitSheetData(xml);
|
|
27606
|
-
|
|
27607
|
-
|
|
27608
|
-
|
|
27609
|
-
|
|
27610
|
-
|
|
27752
|
+
if (split) {
|
|
27753
|
+
try {
|
|
27754
|
+
return readWorksheet(ctx, partName, name, sheetId, split.xml, split.rows);
|
|
27755
|
+
} catch (error) {
|
|
27756
|
+
if (!(error instanceof LiteDeclinedError)) throw error;
|
|
27757
|
+
}
|
|
27758
|
+
}
|
|
27759
|
+
return readWorksheet(ctx, partName, name, sheetId, xml);
|
|
27760
|
+
}
|
|
27761
|
+
function readWorksheet(ctx, partName, name, sheetId, xml, rows) {
|
|
27762
|
+
const sheet = createWorksheet(name, sheetId);
|
|
27763
|
+
sheet.partName = partName;
|
|
27764
|
+
const root = parseDataXml(xml, "XLSX worksheet", ctx.maxXmlElements).documentElement;
|
|
27611
27765
|
const byName = /* @__PURE__ */ new Map();
|
|
27612
27766
|
const cfBlocks = [];
|
|
27613
27767
|
for (const node2 of elements(root)) {
|
|
@@ -27630,7 +27784,7 @@ function parseWorksheet(ctx, partName, name, sheetId) {
|
|
|
27630
27784
|
if (format.format) sheet.format = format.format;
|
|
27631
27785
|
sheet.columns = readColumns(byName.get("cols"), ctx.xfMap);
|
|
27632
27786
|
const data = byName.get("sheetData");
|
|
27633
|
-
if (data) readSheetData(ctx,
|
|
27787
|
+
if (data) readSheetData(ctx, rows ?? elements(data), sheet);
|
|
27634
27788
|
const protection2 = readProtection(byName.get("sheetProtection"));
|
|
27635
27789
|
if (protection2) sheet.protection = protection2;
|
|
27636
27790
|
const autoFilter = readAutoFilter(byName.get("autoFilter"));
|
|
@@ -27798,6 +27952,216 @@ function readProperties(core, app, custom, warn) {
|
|
|
27798
27952
|
};
|
|
27799
27953
|
}
|
|
27800
27954
|
|
|
27955
|
+
// xlsx/numfmt/view.ts
|
|
27956
|
+
function isoOf(serial, date1904, shows2) {
|
|
27957
|
+
if (!(serial >= 0) || serial > MAX_DATE_SERIAL + 1) return void 0;
|
|
27958
|
+
if (!date1904 && serial >= 60 && serial < 61) return void 0;
|
|
27959
|
+
const date = serialToDate(serial, date1904);
|
|
27960
|
+
if (date.getUTCFullYear() > 9999) return void 0;
|
|
27961
|
+
const iso = date.toISOString();
|
|
27962
|
+
const time = iso.slice(11, iso.endsWith(".000Z") ? 19 : 23);
|
|
27963
|
+
if (serial < 1 && (!date1904 || !shows2.date)) return time;
|
|
27964
|
+
return Number.isInteger(serial) && !shows2.time ? iso.slice(0, 10) : `${iso.slice(0, 10)}T${time}`;
|
|
27965
|
+
}
|
|
27966
|
+
function numberFormatView(numFmt, value2, date1904) {
|
|
27967
|
+
if (numFmt === "General") return {};
|
|
27968
|
+
const parts = typeof value2 === "number" ? dateTimeParts(numFmt, value2) : void 0;
|
|
27969
|
+
const iso = parts && typeof value2 === "number" ? isoOf(value2, date1904, parts) : void 0;
|
|
27970
|
+
return iso ? { numberFormat: numFmt, iso } : { numberFormat: numFmt };
|
|
27971
|
+
}
|
|
27972
|
+
|
|
27973
|
+
// xlsx/read/rows-stream.ts
|
|
27974
|
+
var MAX_HEAD = 1 << 20;
|
|
27975
|
+
async function* sheetRows(ctx, entry3, alreadyRead, limits) {
|
|
27976
|
+
const sheet = createWorksheet("", 1);
|
|
27977
|
+
const reader = sheetDataReader(ctx, sheet);
|
|
27978
|
+
let consumed = 0;
|
|
27979
|
+
function* take2(items, skip) {
|
|
27980
|
+
let index3 = 0;
|
|
27981
|
+
for (const item2 of items) {
|
|
27982
|
+
if (index3++ < skip) continue;
|
|
27983
|
+
reader.read(item2);
|
|
27984
|
+
consumed++;
|
|
27985
|
+
sheet.rowInfo.clear();
|
|
27986
|
+
delete sheet.dataTables;
|
|
27987
|
+
if (!sheet.rows.size) continue;
|
|
27988
|
+
const rows = [...sheet.rows].sort((a2, b) => a2[0] - b[0]);
|
|
27989
|
+
sheet.rows.clear();
|
|
27990
|
+
yield* rows;
|
|
27991
|
+
}
|
|
27992
|
+
}
|
|
27993
|
+
try {
|
|
27994
|
+
for await (const piece of pieces(entry3, alreadyRead, limits))
|
|
27995
|
+
yield* take2(liteChildElements(piece.xml, piece.start.namespaces), 0);
|
|
27996
|
+
return;
|
|
27997
|
+
} catch (error) {
|
|
27998
|
+
if (!(error instanceof LiteDeclinedError)) throw error;
|
|
27999
|
+
}
|
|
28000
|
+
const xml = new TextDecoder("utf-8").decode(await entry3.async("uint8array"));
|
|
28001
|
+
const split = splitSheetData(xml);
|
|
28002
|
+
if (split)
|
|
28003
|
+
try {
|
|
28004
|
+
yield* take2(split.rows, consumed);
|
|
28005
|
+
return;
|
|
28006
|
+
} catch (error) {
|
|
28007
|
+
if (!(error instanceof LiteDeclinedError)) throw error;
|
|
28008
|
+
}
|
|
28009
|
+
const root = parseDataXml(xml, "XLSX worksheet", limits.maxXmlElements).documentElement;
|
|
28010
|
+
const data = elements(root).find((node2) => node2.localName === "sheetData");
|
|
28011
|
+
yield* take2(data ? elements(data) : [], consumed);
|
|
28012
|
+
}
|
|
28013
|
+
async function* pieces(entry3, alreadyRead, limits) {
|
|
28014
|
+
const decoder2 = new TextDecoder("utf-8");
|
|
28015
|
+
let start;
|
|
28016
|
+
let row2 = "";
|
|
28017
|
+
let buffer = "";
|
|
28018
|
+
const chunks2 = streamEntryGuarded(entry3, alreadyRead, zipLimitsFor(limits));
|
|
28019
|
+
try {
|
|
28020
|
+
for (let ended = false; !ended; ) {
|
|
28021
|
+
const next = await chunks2.next();
|
|
28022
|
+
ended = next.done === true;
|
|
28023
|
+
buffer += next.done ? decoder2.decode() : decoder2.decode(next.value, { stream: true });
|
|
28024
|
+
if (!start) {
|
|
28025
|
+
const found = sheetDataStart(buffer);
|
|
28026
|
+
if (found === false || !found && (ended || buffer.length > MAX_HEAD))
|
|
28027
|
+
throw new LiteDeclinedError();
|
|
28028
|
+
if (!found) continue;
|
|
28029
|
+
start = found;
|
|
28030
|
+
row2 = `<${found.tagName.slice(0, -"sheetData".length)}row`;
|
|
28031
|
+
buffer = buffer.slice(found.contentStart);
|
|
28032
|
+
}
|
|
28033
|
+
const close2 = buffer.indexOf(`</${start.tagName}`);
|
|
28034
|
+
if (close2 >= 0) {
|
|
28035
|
+
yield { xml: buffer.slice(0, close2), start };
|
|
28036
|
+
return;
|
|
28037
|
+
}
|
|
28038
|
+
const cut = lastRowStart(buffer, row2);
|
|
28039
|
+
if (cut > 0) {
|
|
28040
|
+
yield { xml: buffer.slice(0, cut), start };
|
|
28041
|
+
buffer = buffer.slice(cut);
|
|
28042
|
+
}
|
|
28043
|
+
}
|
|
28044
|
+
} finally {
|
|
28045
|
+
await chunks2.return();
|
|
28046
|
+
}
|
|
28047
|
+
throw new LiteDeclinedError();
|
|
28048
|
+
}
|
|
28049
|
+
function lastRowStart(xml, row2) {
|
|
28050
|
+
for (let at = xml.lastIndexOf(row2); at > 0; at = xml.lastIndexOf(row2, at - 1)) {
|
|
28051
|
+
const next = xml.charCodeAt(at + row2.length);
|
|
28052
|
+
if (next === 32 || next === 9 || next === 10 || next === 13 || next === 62 || next === 47)
|
|
28053
|
+
return at;
|
|
28054
|
+
}
|
|
28055
|
+
return -1;
|
|
28056
|
+
}
|
|
28057
|
+
|
|
28058
|
+
// xlsx/read/rows.ts
|
|
28059
|
+
async function* readXlsxRows(input, options2 = {}) {
|
|
28060
|
+
const limits = resolveLoadLimits(options2.limits);
|
|
28061
|
+
const zip = await openPackage(input, limits);
|
|
28062
|
+
const warned = /* @__PURE__ */ new Set();
|
|
28063
|
+
const warn = (message) => {
|
|
28064
|
+
if (warned.has(message)) return;
|
|
28065
|
+
warned.add(message);
|
|
28066
|
+
options2.onWarning?.(message);
|
|
28067
|
+
};
|
|
28068
|
+
const parts = new PartReader(zip);
|
|
28069
|
+
const rootRels = parseRelationships(await parts.text("_rels/.rels"));
|
|
28070
|
+
const fromRels = targetOfType("", rootRels, RELATIONSHIP_TYPES.officeDocument);
|
|
28071
|
+
const bookPart = fromRels && parts.has(fromRels) ? fromRels : "xl/workbook.xml";
|
|
28072
|
+
const bookXml = await parts.text(bookPart);
|
|
28073
|
+
if (bookXml === void 0) throw new Error("XLSX package has no workbook part (xl/workbook.xml)");
|
|
28074
|
+
const book = parseWorkbookPart(bookXml);
|
|
28075
|
+
const rels = parseRelationships(await parts.text(relationshipsPartFor(bookPart)));
|
|
28076
|
+
const entry3 = pickSheet(book.sheets, options2.sheet ?? 0);
|
|
28077
|
+
const rel = rels.get(entry3.relId);
|
|
28078
|
+
const target = rel && rel.mode !== "External" ? resolvePartPath(bookPart, rel.target) : void 0;
|
|
28079
|
+
if (rel?.type !== RELATIONSHIP_TYPES.worksheet || !target) {
|
|
28080
|
+
const kind = rel?.type.split("/").pop();
|
|
28081
|
+
throw new Error(
|
|
28082
|
+
`Sheet "${entry3.name}" ${kind ? `is a ${kind}` : "has no part"}; it has no rows to read.`
|
|
28083
|
+
);
|
|
28084
|
+
}
|
|
28085
|
+
const partOf = (type) => targetOfType(bookPart, rels, type);
|
|
28086
|
+
const warnings = [];
|
|
28087
|
+
const styles = parseStyles(await parts.text(partOf(RELATIONSHIP_TYPES.styles)), warnings);
|
|
28088
|
+
for (const message of warnings) warn(message);
|
|
28089
|
+
const ctx = {
|
|
28090
|
+
sharedStrings: parseSharedStrings(
|
|
28091
|
+
await parts.text(partOf(RELATIONSHIP_TYPES.sharedStrings)),
|
|
28092
|
+
styles.palette,
|
|
28093
|
+
limits.maxXmlElements
|
|
28094
|
+
),
|
|
28095
|
+
xfMap: styles.xfMap,
|
|
28096
|
+
date1904: book.date1904,
|
|
28097
|
+
palette: styles.palette,
|
|
28098
|
+
dynamicCells: parseDynamicArrayMetadata(
|
|
28099
|
+
await parts.text(partOf(RELATIONSHIP_TYPES.sheetMetadata))
|
|
28100
|
+
),
|
|
28101
|
+
warn
|
|
28102
|
+
};
|
|
28103
|
+
const sheet = parts.entry(target);
|
|
28104
|
+
if (!sheet) {
|
|
28105
|
+
warn(`Sheet "${entry3.name}" has no part ${target}; it was loaded empty.`);
|
|
28106
|
+
return;
|
|
28107
|
+
}
|
|
28108
|
+
const formats = styles.styles.map((style2) => style2.numFmt);
|
|
28109
|
+
const cellOf2 = (col, cell) => ({
|
|
28110
|
+
col,
|
|
28111
|
+
value: cell.value,
|
|
28112
|
+
...cell.formula ? { formula: cell.formula } : {},
|
|
28113
|
+
...numberFormatView(
|
|
28114
|
+
formats[cell.styleId ?? 0] ?? formats[0] ?? "General",
|
|
28115
|
+
cell.value,
|
|
28116
|
+
book.date1904
|
|
28117
|
+
)
|
|
28118
|
+
});
|
|
28119
|
+
for await (const [row2, cells] of sheetRows(ctx, sheet, parts.read, limits)) {
|
|
28120
|
+
const out = [];
|
|
28121
|
+
for (const [col, cell] of cells)
|
|
28122
|
+
if (cell.value !== null || cell.formula) out.push(cellOf2(col, cell));
|
|
28123
|
+
if (out.length) yield { row: row2, cells: out.sort((a2, b) => a2.col - b.col) };
|
|
28124
|
+
}
|
|
28125
|
+
}
|
|
28126
|
+
function pickSheet(sheets, wanted) {
|
|
28127
|
+
const found = typeof wanted === "number" ? Number.isSafeInteger(wanted) && wanted >= 0 ? sheets[wanted] : void 0 : sheets.find((sheet) => sheet.name.toLowerCase() === wanted.toLowerCase());
|
|
28128
|
+
if (!found)
|
|
28129
|
+
throw new RangeError(
|
|
28130
|
+
typeof wanted === "number" ? `The workbook has no sheet at position ${wanted}` : `The workbook has no sheet named "${wanted}"`
|
|
28131
|
+
);
|
|
28132
|
+
return found;
|
|
28133
|
+
}
|
|
28134
|
+
function targetOfType(partName, rels, type) {
|
|
28135
|
+
for (const rel of rels.values())
|
|
28136
|
+
if (rel.type === type)
|
|
28137
|
+
return rel.mode === "External" ? void 0 : resolvePartPath(partName === "" ? "/" : partName, rel.target);
|
|
28138
|
+
return void 0;
|
|
28139
|
+
}
|
|
28140
|
+
var PartReader = class {
|
|
28141
|
+
entries = /* @__PURE__ */ new Map();
|
|
28142
|
+
/** Bytes inflated so far, for the total limit of the part read in pieces. */
|
|
28143
|
+
read = 0;
|
|
28144
|
+
decoder = new TextDecoder("utf-8");
|
|
28145
|
+
constructor(zip) {
|
|
28146
|
+
for (const entry3 of Object.values(zip.files))
|
|
28147
|
+
if (!entry3.dir) this.entries.set(entry3.name.replace(/^\//, "").toLowerCase(), entry3);
|
|
28148
|
+
}
|
|
28149
|
+
entry(partName) {
|
|
28150
|
+
return this.entries.get(partName.toLowerCase());
|
|
28151
|
+
}
|
|
28152
|
+
has(partName) {
|
|
28153
|
+
return this.entries.has(partName.toLowerCase());
|
|
28154
|
+
}
|
|
28155
|
+
/** A part decoded as UTF-8 (BOM stripped), or undefined when absent. */
|
|
28156
|
+
async text(partName) {
|
|
28157
|
+
const entry3 = partName ? this.entry(partName) : void 0;
|
|
28158
|
+
if (!entry3) return void 0;
|
|
28159
|
+
const bytes = await entry3.async("uint8array");
|
|
28160
|
+
this.read += bytes.byteLength;
|
|
28161
|
+
return this.decoder.decode(bytes);
|
|
28162
|
+
}
|
|
28163
|
+
};
|
|
28164
|
+
|
|
27801
28165
|
// xlsx/read/sparklines.ts
|
|
27802
28166
|
var XM2 = "http://schemas.microsoft.com/office/excel/2006/main";
|
|
27803
28167
|
var TYPES = ["line", "column", "stacked"];
|
|
@@ -48107,7 +48471,7 @@ function wrapStyledRuns(runs, maxWidth, measure2, options2 = {}) {
|
|
|
48107
48471
|
}
|
|
48108
48472
|
return result3;
|
|
48109
48473
|
};
|
|
48110
|
-
const width = (
|
|
48474
|
+
const width = (pieces2) => pieces2.reduce((sum3, piece) => {
|
|
48111
48475
|
const advance = measure2(piece.text, piece.run);
|
|
48112
48476
|
return sum3 + (Number.isFinite(advance) && advance >= 0 ? advance : 0);
|
|
48113
48477
|
}, 0);
|
|
@@ -48170,8 +48534,8 @@ function chartRichTitleSvg(model, width, options2 = {}, frameHeight = 400) {
|
|
|
48170
48534
|
};
|
|
48171
48535
|
hardLines.push(line3);
|
|
48172
48536
|
for (const run2 of paragraph2.runs) {
|
|
48173
|
-
const
|
|
48174
|
-
for (const [index3, piece] of
|
|
48537
|
+
const pieces2 = run2.text.split("\n");
|
|
48538
|
+
for (const [index3, piece] of pieces2.entries()) {
|
|
48175
48539
|
if (index3) {
|
|
48176
48540
|
line3 = { ...paragraph2, runs: [] };
|
|
48177
48541
|
hardLines.push(line3);
|
|
@@ -50618,6 +50982,7 @@ exports.readEmbeddedChartSpace = readEmbeddedChartSpace;
|
|
|
50618
50982
|
exports.readSparklineGroup = readSparklineGroup;
|
|
50619
50983
|
exports.readSparklineGroups = readSparklineGroups;
|
|
50620
50984
|
exports.readSparklineValues = readSparklineValues;
|
|
50985
|
+
exports.readXlsxRows = readXlsxRows;
|
|
50621
50986
|
exports.referenceSpans = referenceSpans;
|
|
50622
50987
|
exports.referenceTarget = referenceTarget;
|
|
50623
50988
|
exports.referencedRanges = referencedRanges;
|