@sheetxl/io-xlsx 0.7.28-beta.3 → 0.8.0-beta.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.
- package/browser/cjs/BAtEL-5TLyoaPFDP.cjs +2 -0
- package/browser/cjs/Bg0e53JZa8vhmm5a.cjs +1 -0
- package/browser/cjs/CK5FFUvet6FnIYO_.cjs +5 -0
- package/browser/cjs/{BZsKjlEe8ttWIao7.cjs → DV6LeTEiiFUrZoxj.cjs} +1 -1
- package/browser/cjs/Db8YjGM6TG34c8aT.cjs +1 -0
- package/browser/cjs/index.cjs +1 -1
- package/browser/esm/{Da4uZFnis4q5dMxA.mjs → 4BWLu134ABlCQEtM.mjs} +928 -890
- package/browser/esm/{uIgz_sO2ZTlIJryO.mjs → BkNXyG6NC-w5Xo92.mjs} +2 -2
- package/browser/esm/{9k07cBjQx8ZMNU1r.mjs → BzQ_lPzc8C4OTIGZ.mjs} +2 -2
- package/browser/esm/{BwSyMclyk-t3Qsxs.mjs → CJknI8BYGSZr-4zS.mjs} +5 -5
- package/browser/esm/{DmzsYgxDBYYWxQWu.mjs → CLWzJJyoSrykkVLX.mjs} +2 -2
- package/browser/esm/{BjKFtNZckTyELfHX.mjs → Cok_fBIUCHDSrKw0.mjs} +260 -242
- package/browser/esm/{C0ftqc3PDJkuDjFG.mjs → Ctqql4O-3xj2K8vv.mjs} +2 -2
- package/browser/esm/{DofvhgOWFHBSl9vH.mjs → D-m_kQLaewdwuXaF.mjs} +743 -681
- package/browser/esm/{Wg4pN30I3RZmpjIf.mjs → Dj7D2nVdAZ3TiUks.mjs} +1460 -1392
- package/browser/esm/{DatxS1drpnPiN0bA.mjs → Dz1Dp8DDJvhd09RR.mjs} +1 -1
- package/browser/esm/{B1HdC5n0VHTzJXno.mjs → ijQzHH-bvDfUHIi1.mjs} +1 -1
- package/browser/esm/index.mjs +2 -2
- package/node/esm/{C9wIBQW-fwqlpFJm.mjs → CEAmv36xpTNgFwl_.mjs} +2 -2
- package/node/esm/{CUQy4BVE8DwTALUu.mjs → CEV7nKotMpeRRnQC.mjs} +1 -1
- package/node/esm/{BTiGUmPt1-zNmYTg.mjs → CF1R5ovFsRNu--Rw.mjs} +994 -950
- package/node/esm/{DWNfn3shRCVhbEOV.mjs → Ctcl4jN52INWpKWC.mjs} +197 -179
- package/node/esm/{BOF2zpi3fMaBFMe7.mjs → CvnRSooxEQdlJgMn.mjs} +741 -677
- package/node/esm/{zldOc2ba5Vlg1s2E.mjs → DQd0vxzTaPt2qSL-.mjs} +1 -1
- package/node/esm/{DYH_lfcyj9wTL8Er.mjs → fOnuUjpPCAzmuIXN.mjs} +2 -2
- package/node/esm/index.mjs +5 -5
- package/node/esm/{f9-SN-lQDdZGt0vO.mjs → ssSlRCbCqxvZ9IX8.mjs} +613 -545
- package/package.json +3 -3
- package/types/src/AutoFilterRules.d.ts +62 -0
- package/types/src/reader/dom/DOMTransformer.d.ts +10 -0
- package/types/src/reader/domVisitors/AutoFilterVisitor.d.ts +1 -1
- package/types/src/reader/sax/SaxVisitor.d.ts +14 -0
- package/types/src/writer/builder/EmitterRegistry.d.ts +7 -0
- package/types/src/writer/emitters/StylesEmitter.d.ts +13 -2
- package/types/src/writer/utils/AutoFilter.d.ts +3 -2
- package/browser/cjs/5QaWZ2tRVhz1rf3W.cjs +0 -1
- package/browser/cjs/Bi-WvoygX7yZzlxU.cjs +0 -5
- package/browser/cjs/D-8WoJkvdPf-79sB.cjs +0 -2
- package/browser/cjs/sEmMmxaNBSY_o-Zb.cjs +0 -1
|
@@ -1,61 +1,73 @@
|
|
|
1
1
|
/**
|
|
2
|
-
* @license @sheetxl/io-xlsx - SheetXL - Import/Export from/to Excel - v0.
|
|
2
|
+
* @license @sheetxl/io-xlsx - SheetXL - Import/Export from/to Excel - v0.8.0-beta.1
|
|
3
3
|
*
|
|
4
4
|
* (C) 2026-present SheetXL Inc. & Michael T. Ford
|
|
5
5
|
* License: The license can be found at https://www.sheetxl.com/license.
|
|
6
6
|
*/
|
|
7
7
|
import { FormulaError as e, ICondition as r, parseFormulaLiteral as t } from "@sheetxl/sdk";
|
|
8
|
-
var n = "
|
|
8
|
+
var n = "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main", E = "http://schemas.microsoft.com/office/excel/2006/main", a = "{CCE6A557-97BC-4b89-ADB6-D9C93CAAB3DF}", o = "{78C0D931-6437-407d-A8EE-F0AAD7539E65}", T = "{78C0D931-6839-4c89-B8D6-976A2CC4E5B4}", s = "{B025F937-C7B1-47D3-B67F-A62EFF666E3E}", i = "{A8765BA9-456A-4dab-B4F3-ACF838C121DE}", p = "{3A4CF648-6AED-40f4-86FF-DC5316D8AED3}", A = {
|
|
9
|
+
"{05C60535-1F16-4FD2-B633-F4F36F0B64E0}": "sparklines",
|
|
10
|
+
"{7E03D99C-DC04-49D9-9315-930204A7B6E9}": "timelines",
|
|
11
|
+
"{01252117-D84E-4E92-8308-4BE1C098FCBB}": "ignoredErrors",
|
|
12
|
+
"{F7C9EE02-42E1-4005-9D12-6889AFFD525C}": "workbook protection extensions"
|
|
13
|
+
}, c = /* @__PURE__ */ new Set(["{77BFE23E-C014-4D31-8A63-9C772DBF06B6}"]);
|
|
14
|
+
function S(e) {
|
|
15
|
+
return (e ?? "").toUpperCase();
|
|
16
|
+
}
|
|
17
|
+
function O(e) {
|
|
18
|
+
return `{${e().toUpperCase()}}`;
|
|
19
|
+
}
|
|
20
|
+
var R = "_xlfn.", u = "_xlfn._xlws.", I = /* @__PURE__ */ new Map([
|
|
9
21
|
["ANCHORARRAY", {
|
|
10
|
-
prefix:
|
|
22
|
+
prefix: R,
|
|
11
23
|
unimplemented: !0
|
|
12
24
|
}],
|
|
13
25
|
["SINGLE", {
|
|
14
|
-
prefix:
|
|
26
|
+
prefix: R,
|
|
15
27
|
unimplemented: !0
|
|
16
28
|
}],
|
|
17
29
|
["_TRO_ALL", {
|
|
18
|
-
prefix:
|
|
30
|
+
prefix: R,
|
|
19
31
|
unimplemented: !0
|
|
20
32
|
}],
|
|
21
33
|
["_TRO_LEADING", {
|
|
22
|
-
prefix:
|
|
34
|
+
prefix: R,
|
|
23
35
|
unimplemented: !0
|
|
24
36
|
}],
|
|
25
37
|
["_TRO_TRAILING", {
|
|
26
|
-
prefix:
|
|
38
|
+
prefix: R,
|
|
27
39
|
unimplemented: !0
|
|
28
40
|
}],
|
|
29
41
|
["COPILOT", {
|
|
30
|
-
prefix:
|
|
42
|
+
prefix: R,
|
|
31
43
|
unimplemented: !0
|
|
32
44
|
}],
|
|
33
45
|
["LONGTEXT", {
|
|
34
|
-
prefix:
|
|
46
|
+
prefix: R,
|
|
35
47
|
unimplemented: !0
|
|
36
48
|
}],
|
|
37
49
|
["PQSOURCE", {
|
|
38
|
-
prefix:
|
|
50
|
+
prefix: R,
|
|
39
51
|
unimplemented: !0
|
|
40
52
|
}],
|
|
41
53
|
["PY", {
|
|
42
|
-
prefix:
|
|
54
|
+
prefix: u,
|
|
43
55
|
unimplemented: !0
|
|
44
56
|
}],
|
|
45
57
|
["PYTHON_STR", {
|
|
46
|
-
prefix:
|
|
58
|
+
prefix: R,
|
|
47
59
|
unimplemented: !0
|
|
48
60
|
}],
|
|
49
61
|
["PYTHON_TYPE", {
|
|
50
|
-
prefix:
|
|
62
|
+
prefix: R,
|
|
51
63
|
unimplemented: !0
|
|
52
64
|
}],
|
|
53
65
|
["PYTHON_TYPENAME", {
|
|
54
|
-
prefix:
|
|
66
|
+
prefix: R,
|
|
55
67
|
unimplemented: !0
|
|
56
68
|
}],
|
|
57
69
|
["QUERYSTRING", {
|
|
58
|
-
prefix:
|
|
70
|
+
prefix: R,
|
|
59
71
|
unimplemented: !0
|
|
60
72
|
}],
|
|
61
73
|
["ACCRINT", { intersect: "never" }],
|
|
@@ -104,12 +116,12 @@ var n = "_xlfn.", E = "_xlfn._xlws.", o = /* @__PURE__ */ new Map([
|
|
|
104
116
|
["EOMONTH", { intersect: "never" }],
|
|
105
117
|
["ERF", { intersect: "never" }],
|
|
106
118
|
["ERF.PRECISE", {
|
|
107
|
-
prefix:
|
|
119
|
+
prefix: R,
|
|
108
120
|
intersect: "never"
|
|
109
121
|
}],
|
|
110
122
|
["ERFC", { intersect: "never" }],
|
|
111
123
|
["ERFC.PRECISE", {
|
|
112
|
-
prefix:
|
|
124
|
+
prefix: R,
|
|
113
125
|
intersect: "never"
|
|
114
126
|
}],
|
|
115
127
|
["FACTDOUBLE", { intersect: "never" }],
|
|
@@ -127,19 +139,19 @@ var n = "_xlfn.", E = "_xlfn._xlws.", o = /* @__PURE__ */ new Map([
|
|
|
127
139
|
["IMCONJUGATE", { intersect: "never" }],
|
|
128
140
|
["IMCOS", { intersect: "never" }],
|
|
129
141
|
["IMCOSH", {
|
|
130
|
-
prefix:
|
|
142
|
+
prefix: R,
|
|
131
143
|
intersect: "never"
|
|
132
144
|
}],
|
|
133
145
|
["IMCOT", {
|
|
134
|
-
prefix:
|
|
146
|
+
prefix: R,
|
|
135
147
|
intersect: "never"
|
|
136
148
|
}],
|
|
137
149
|
["IMCSC", {
|
|
138
|
-
prefix:
|
|
150
|
+
prefix: R,
|
|
139
151
|
intersect: "never"
|
|
140
152
|
}],
|
|
141
153
|
["IMCSCH", {
|
|
142
|
-
prefix:
|
|
154
|
+
prefix: R,
|
|
143
155
|
intersect: "never"
|
|
144
156
|
}],
|
|
145
157
|
["IMDIV", { intersect: "never" }],
|
|
@@ -154,16 +166,16 @@ var n = "_xlfn.", E = "_xlfn._xlws.", o = /* @__PURE__ */ new Map([
|
|
|
154
166
|
}],
|
|
155
167
|
["IMREAL", { intersect: "never" }],
|
|
156
168
|
["IMSEC", {
|
|
157
|
-
prefix:
|
|
169
|
+
prefix: R,
|
|
158
170
|
intersect: "never"
|
|
159
171
|
}],
|
|
160
172
|
["IMSECH", {
|
|
161
|
-
prefix:
|
|
173
|
+
prefix: R,
|
|
162
174
|
intersect: "never"
|
|
163
175
|
}],
|
|
164
176
|
["IMSIN", { intersect: "never" }],
|
|
165
177
|
["IMSINH", {
|
|
166
|
-
prefix:
|
|
178
|
+
prefix: R,
|
|
167
179
|
intersect: "never"
|
|
168
180
|
}],
|
|
169
181
|
["IMSQRT", { intersect: "never" }],
|
|
@@ -173,12 +185,12 @@ var n = "_xlfn.", E = "_xlfn._xlws.", o = /* @__PURE__ */ new Map([
|
|
|
173
185
|
arrayScope: "consumer"
|
|
174
186
|
}],
|
|
175
187
|
["IMTAN", {
|
|
176
|
-
prefix:
|
|
188
|
+
prefix: R,
|
|
177
189
|
intersect: "never"
|
|
178
190
|
}],
|
|
179
191
|
["INTRATE", { intersect: "never" }],
|
|
180
192
|
["ISOMITTED", {
|
|
181
|
-
prefix:
|
|
193
|
+
prefix: R,
|
|
182
194
|
intersect: "never",
|
|
183
195
|
arrayScope: "consumer"
|
|
184
196
|
}],
|
|
@@ -246,13 +258,12 @@ var n = "_xlfn.", E = "_xlfn._xlws.", o = /* @__PURE__ */ new Map([
|
|
|
246
258
|
slotAlways: [3]
|
|
247
259
|
}],
|
|
248
260
|
["MAKEARRAY", {
|
|
249
|
-
prefix:
|
|
261
|
+
prefix: R,
|
|
250
262
|
slotNever: [2],
|
|
251
263
|
arrayScope: "consumer"
|
|
252
264
|
}],
|
|
253
265
|
["MATCH", {
|
|
254
266
|
slotNever: [2],
|
|
255
|
-
slotAlways: [0],
|
|
256
267
|
scopeClears: [1]
|
|
257
268
|
}],
|
|
258
269
|
["NETWORKDAYS.INTL", {
|
|
@@ -261,17 +272,17 @@ var n = "_xlfn.", E = "_xlfn._xlws.", o = /* @__PURE__ */ new Map([
|
|
|
261
272
|
}],
|
|
262
273
|
["NPV", { slotNever: [1] }],
|
|
263
274
|
["SCAN", {
|
|
264
|
-
prefix:
|
|
275
|
+
prefix: R,
|
|
265
276
|
slotNever: [0],
|
|
266
277
|
arrayScope: "opens"
|
|
267
278
|
}],
|
|
268
279
|
["TEXTJOIN", {
|
|
269
|
-
prefix:
|
|
280
|
+
prefix: R,
|
|
270
281
|
slotNever: [0],
|
|
271
282
|
arrayScope: "consumer"
|
|
272
283
|
}],
|
|
273
284
|
["TEXTSPLIT", {
|
|
274
|
-
prefix:
|
|
285
|
+
prefix: R,
|
|
275
286
|
slotAlways: [1, 2],
|
|
276
287
|
arrayScope: "consumer"
|
|
277
288
|
}],
|
|
@@ -287,10 +298,7 @@ var n = "_xlfn.", E = "_xlfn._xlws.", o = /* @__PURE__ */ new Map([
|
|
|
287
298
|
slotNever: [0, 1],
|
|
288
299
|
arrayScope: "consumer"
|
|
289
300
|
}],
|
|
290
|
-
["XMATCH", {
|
|
291
|
-
prefix: n,
|
|
292
|
-
slotAlways: [0]
|
|
293
|
-
}],
|
|
301
|
+
["XMATCH", { prefix: R }],
|
|
294
302
|
["CELL", {
|
|
295
303
|
arrayReturn: !0,
|
|
296
304
|
arrayScope: "consumer",
|
|
@@ -298,26 +306,26 @@ var n = "_xlfn.", E = "_xlfn._xlws.", o = /* @__PURE__ */ new Map([
|
|
|
298
306
|
}],
|
|
299
307
|
["COLUMN", { readsPerCell: 0 }],
|
|
300
308
|
["FORMULATEXT", {
|
|
301
|
-
prefix:
|
|
309
|
+
prefix: R,
|
|
302
310
|
readsPerCell: 0
|
|
303
311
|
}],
|
|
304
312
|
["ISFORMULA", {
|
|
305
|
-
prefix:
|
|
313
|
+
prefix: R,
|
|
306
314
|
readsPerCell: 0
|
|
307
315
|
}],
|
|
308
316
|
["REDUCE", {
|
|
309
|
-
prefix:
|
|
317
|
+
prefix: R,
|
|
310
318
|
arrayReturn: !0,
|
|
311
319
|
arrayScope: "opens",
|
|
312
320
|
scopeClears: [0]
|
|
313
321
|
}],
|
|
314
322
|
["ROW", { readsPerCell: 0 }],
|
|
315
323
|
["AGGREGATE", {
|
|
316
|
-
prefix:
|
|
324
|
+
prefix: R,
|
|
317
325
|
arrayScope: "opens"
|
|
318
326
|
}],
|
|
319
327
|
["FILTER", {
|
|
320
|
-
prefix:
|
|
328
|
+
prefix: u,
|
|
321
329
|
slotAlways: [2],
|
|
322
330
|
arrayScope: "opens"
|
|
323
331
|
}],
|
|
@@ -325,120 +333,119 @@ var n = "_xlfn.", E = "_xlfn._xlws.", o = /* @__PURE__ */ new Map([
|
|
|
325
333
|
["LOOKUP", { arrayScope: "opens" }],
|
|
326
334
|
["MMULT", { arrayScope: "opens" }],
|
|
327
335
|
["SORT", {
|
|
328
|
-
prefix:
|
|
336
|
+
prefix: u,
|
|
329
337
|
arrayScope: "opens"
|
|
330
338
|
}],
|
|
331
339
|
["SUMPRODUCT", { arrayScope: "opens" }],
|
|
332
340
|
["XLOOKUP", {
|
|
333
|
-
prefix:
|
|
341
|
+
prefix: R,
|
|
334
342
|
slotNever: [3],
|
|
335
|
-
slotAlways: [0],
|
|
336
343
|
arrayScope: "opens",
|
|
337
344
|
scopeClears: [0]
|
|
338
345
|
}],
|
|
339
346
|
["ARRAYTOTEXT", {
|
|
340
|
-
prefix:
|
|
347
|
+
prefix: R,
|
|
341
348
|
arrayScope: "opens"
|
|
342
349
|
}],
|
|
343
350
|
["BYCOL", {
|
|
344
|
-
prefix:
|
|
351
|
+
prefix: R,
|
|
345
352
|
arrayScope: "opens"
|
|
346
353
|
}],
|
|
347
354
|
["BYROW", {
|
|
348
|
-
prefix:
|
|
355
|
+
prefix: R,
|
|
349
356
|
arrayScope: "opens"
|
|
350
357
|
}],
|
|
351
358
|
["CHOOSECOLS", {
|
|
352
|
-
prefix:
|
|
359
|
+
prefix: R,
|
|
353
360
|
arrayScope: "opens"
|
|
354
361
|
}],
|
|
355
362
|
["CHOOSEROWS", {
|
|
356
|
-
prefix:
|
|
363
|
+
prefix: R,
|
|
357
364
|
arrayScope: "opens"
|
|
358
365
|
}],
|
|
359
366
|
["COLUMNS", { arrayScope: "opens" }],
|
|
360
367
|
["EXPAND", {
|
|
361
|
-
prefix:
|
|
368
|
+
prefix: R,
|
|
362
369
|
arrayScope: "opens"
|
|
363
370
|
}],
|
|
364
371
|
["GROUPBY", {
|
|
365
|
-
prefix:
|
|
372
|
+
prefix: R,
|
|
366
373
|
arrayScope: "opens"
|
|
367
374
|
}],
|
|
368
375
|
["HSTACK", {
|
|
369
|
-
prefix:
|
|
376
|
+
prefix: R,
|
|
370
377
|
arrayScope: "opens"
|
|
371
378
|
}],
|
|
372
379
|
["IRR", { arrayScope: "opens" }],
|
|
373
380
|
["MAP", {
|
|
374
|
-
prefix:
|
|
381
|
+
prefix: R,
|
|
375
382
|
arrayScope: "opens"
|
|
376
383
|
}],
|
|
377
384
|
["MDETERM", { arrayScope: "opens" }],
|
|
378
385
|
["MINVERSE", { arrayScope: "opens" }],
|
|
379
386
|
["MIRR", { arrayScope: "opens" }],
|
|
380
387
|
["PIVOTBY", {
|
|
381
|
-
prefix:
|
|
388
|
+
prefix: R,
|
|
382
389
|
arrayScope: "opens"
|
|
383
390
|
}],
|
|
384
391
|
["ROWS", { arrayScope: "opens" }],
|
|
385
392
|
["SHEETS", {
|
|
386
|
-
prefix:
|
|
393
|
+
prefix: R,
|
|
387
394
|
arrayScope: "opens"
|
|
388
395
|
}],
|
|
389
396
|
["SORTBY", {
|
|
390
|
-
prefix:
|
|
397
|
+
prefix: R,
|
|
391
398
|
arrayScope: "opens"
|
|
392
399
|
}],
|
|
393
400
|
["TAKE", {
|
|
394
|
-
prefix:
|
|
401
|
+
prefix: R,
|
|
395
402
|
arrayScope: "opens"
|
|
396
403
|
}],
|
|
397
404
|
["TOCOL", {
|
|
398
|
-
prefix:
|
|
405
|
+
prefix: R,
|
|
399
406
|
arrayScope: "opens"
|
|
400
407
|
}],
|
|
401
408
|
["TOROW", {
|
|
402
|
-
prefix:
|
|
409
|
+
prefix: R,
|
|
403
410
|
arrayScope: "opens"
|
|
404
411
|
}],
|
|
405
412
|
["UNIQUE", {
|
|
406
|
-
prefix:
|
|
413
|
+
prefix: R,
|
|
407
414
|
arrayScope: "opens"
|
|
408
415
|
}],
|
|
409
416
|
["VSTACK", {
|
|
410
|
-
prefix:
|
|
417
|
+
prefix: R,
|
|
411
418
|
arrayScope: "opens"
|
|
412
419
|
}],
|
|
413
420
|
["WRAPCOLS", {
|
|
414
|
-
prefix:
|
|
421
|
+
prefix: R,
|
|
415
422
|
arrayScope: "opens"
|
|
416
423
|
}],
|
|
417
424
|
["WRAPROWS", {
|
|
418
|
-
prefix:
|
|
425
|
+
prefix: R,
|
|
419
426
|
arrayScope: "opens"
|
|
420
427
|
}],
|
|
421
428
|
["CHISQ.TEST", {
|
|
422
|
-
prefix:
|
|
429
|
+
prefix: R,
|
|
423
430
|
arrayScope: "opens"
|
|
424
431
|
}],
|
|
425
432
|
["CORREL", { arrayScope: "opens" }],
|
|
426
433
|
["COVAR", { arrayScope: "opens" }],
|
|
427
434
|
["COVARIANCE.P", {
|
|
428
|
-
prefix:
|
|
435
|
+
prefix: R,
|
|
429
436
|
arrayScope: "opens"
|
|
430
437
|
}],
|
|
431
438
|
["COVARIANCE.S", {
|
|
432
|
-
prefix:
|
|
439
|
+
prefix: R,
|
|
433
440
|
arrayScope: "opens"
|
|
434
441
|
}],
|
|
435
442
|
["F.TEST", {
|
|
436
|
-
prefix:
|
|
443
|
+
prefix: R,
|
|
437
444
|
arrayScope: "opens"
|
|
438
445
|
}],
|
|
439
446
|
["FORECAST", { arrayScope: "opens" }],
|
|
440
447
|
["FORECAST.LINEAR", {
|
|
441
|
-
prefix:
|
|
448
|
+
prefix: R,
|
|
442
449
|
arrayScope: "opens"
|
|
443
450
|
}],
|
|
444
451
|
["GROWTH", {
|
|
@@ -463,7 +470,7 @@ var n = "_xlfn.", E = "_xlfn._xlws.", o = /* @__PURE__ */ new Map([
|
|
|
463
470
|
["SUMX2PY2", { arrayScope: "opens" }],
|
|
464
471
|
["SUMXMY2", { arrayScope: "opens" }],
|
|
465
472
|
["T.TEST", {
|
|
466
|
-
prefix:
|
|
473
|
+
prefix: R,
|
|
467
474
|
arrayScope: "opens"
|
|
468
475
|
}],
|
|
469
476
|
["TREND", {
|
|
@@ -472,19 +479,19 @@ var n = "_xlfn.", E = "_xlfn._xlws.", o = /* @__PURE__ */ new Map([
|
|
|
472
479
|
}],
|
|
473
480
|
["CHITEST", { arrayScope: "opens" }],
|
|
474
481
|
["FORECAST.ETS", {
|
|
475
|
-
prefix:
|
|
482
|
+
prefix: R,
|
|
476
483
|
arrayScope: "opens"
|
|
477
484
|
}],
|
|
478
485
|
["FORECAST.ETS.CONFINT", {
|
|
479
|
-
prefix:
|
|
486
|
+
prefix: R,
|
|
480
487
|
arrayScope: "opens"
|
|
481
488
|
}],
|
|
482
489
|
["FORECAST.ETS.SEASONALITY", {
|
|
483
|
-
prefix:
|
|
490
|
+
prefix: R,
|
|
484
491
|
arrayScope: "opens"
|
|
485
492
|
}],
|
|
486
493
|
["FORECAST.ETS.STAT", {
|
|
487
|
-
prefix:
|
|
494
|
+
prefix: R,
|
|
488
495
|
arrayScope: "opens"
|
|
489
496
|
}],
|
|
490
497
|
["FTEST", { arrayScope: "opens" }],
|
|
@@ -492,18 +499,18 @@ var n = "_xlfn.", E = "_xlfn._xlws.", o = /* @__PURE__ */ new Map([
|
|
|
492
499
|
["FREQUENCY", { arrayScope: "opens" }],
|
|
493
500
|
["MODE", { arrayScope: "opens" }],
|
|
494
501
|
["MODE.MULT", {
|
|
495
|
-
prefix:
|
|
502
|
+
prefix: R,
|
|
496
503
|
arrayScope: "opens"
|
|
497
504
|
}],
|
|
498
505
|
["MODE.SNGL", {
|
|
499
|
-
prefix:
|
|
506
|
+
prefix: R,
|
|
500
507
|
arrayScope: "opens"
|
|
501
508
|
}],
|
|
502
509
|
["AVEDEV", { arrayScope: "consumer" }],
|
|
503
510
|
["AVERAGE", { arrayScope: "consumer" }],
|
|
504
511
|
["AVERAGEA", { arrayScope: "consumer" }],
|
|
505
512
|
["CONCAT", {
|
|
506
|
-
prefix:
|
|
513
|
+
prefix: R,
|
|
507
514
|
arrayScope: "consumer"
|
|
508
515
|
}],
|
|
509
516
|
["COUNT", { arrayScope: "consumer" }],
|
|
@@ -515,7 +522,7 @@ var n = "_xlfn.", E = "_xlfn._xlws.", o = /* @__PURE__ */ new Map([
|
|
|
515
522
|
["KURT", { arrayScope: "consumer" }],
|
|
516
523
|
["LARGE", { arrayScope: "consumer" }],
|
|
517
524
|
["LET", {
|
|
518
|
-
prefix:
|
|
525
|
+
prefix: R,
|
|
519
526
|
arrayScope: "consumer"
|
|
520
527
|
}],
|
|
521
528
|
["MAX", { arrayScope: "consumer" }],
|
|
@@ -525,36 +532,36 @@ var n = "_xlfn.", E = "_xlfn._xlws.", o = /* @__PURE__ */ new Map([
|
|
|
525
532
|
["MINA", { arrayScope: "consumer" }],
|
|
526
533
|
["PERCENTILE", { arrayScope: "consumer" }],
|
|
527
534
|
["PERCENTILE.EXC", {
|
|
528
|
-
prefix:
|
|
535
|
+
prefix: R,
|
|
529
536
|
arrayScope: "consumer"
|
|
530
537
|
}],
|
|
531
538
|
["PERCENTILE.INC", {
|
|
532
|
-
prefix:
|
|
539
|
+
prefix: R,
|
|
533
540
|
arrayScope: "consumer"
|
|
534
541
|
}],
|
|
535
542
|
["PRODUCT", { arrayScope: "consumer" }],
|
|
536
543
|
["QUARTILE", { arrayScope: "consumer" }],
|
|
537
544
|
["QUARTILE.EXC", {
|
|
538
|
-
prefix:
|
|
545
|
+
prefix: R,
|
|
539
546
|
arrayScope: "consumer"
|
|
540
547
|
}],
|
|
541
548
|
["QUARTILE.INC", {
|
|
542
|
-
prefix:
|
|
549
|
+
prefix: R,
|
|
543
550
|
arrayScope: "consumer"
|
|
544
551
|
}],
|
|
545
552
|
["SKEW", { arrayScope: "consumer" }],
|
|
546
553
|
["SKEW.P", {
|
|
547
|
-
prefix:
|
|
554
|
+
prefix: R,
|
|
548
555
|
arrayScope: "consumer"
|
|
549
556
|
}],
|
|
550
557
|
["SMALL", { arrayScope: "consumer" }],
|
|
551
558
|
["STDEV", { arrayScope: "consumer" }],
|
|
552
559
|
["STDEV.P", {
|
|
553
|
-
prefix:
|
|
560
|
+
prefix: R,
|
|
554
561
|
arrayScope: "consumer"
|
|
555
562
|
}],
|
|
556
563
|
["STDEV.S", {
|
|
557
|
-
prefix:
|
|
564
|
+
prefix: R,
|
|
558
565
|
arrayScope: "consumer"
|
|
559
566
|
}],
|
|
560
567
|
["STDEVA", { arrayScope: "consumer" }],
|
|
@@ -564,11 +571,11 @@ var n = "_xlfn.", E = "_xlfn._xlws.", o = /* @__PURE__ */ new Map([
|
|
|
564
571
|
["TRIMMEAN", { arrayScope: "consumer" }],
|
|
565
572
|
["VAR", { arrayScope: "consumer" }],
|
|
566
573
|
["VAR.P", {
|
|
567
|
-
prefix:
|
|
574
|
+
prefix: R,
|
|
568
575
|
arrayScope: "consumer"
|
|
569
576
|
}],
|
|
570
577
|
["VAR.S", {
|
|
571
|
-
prefix:
|
|
578
|
+
prefix: R,
|
|
572
579
|
arrayScope: "consumer"
|
|
573
580
|
}],
|
|
574
581
|
["VARA", { arrayScope: "consumer" }],
|
|
@@ -578,11 +585,11 @@ var n = "_xlfn.", E = "_xlfn._xlws.", o = /* @__PURE__ */ new Map([
|
|
|
578
585
|
["AND", { arrayScope: "consumer" }],
|
|
579
586
|
["CUBEVALUE", { arrayScope: "consumer" }],
|
|
580
587
|
["FIELDVALUE", {
|
|
581
|
-
prefix:
|
|
588
|
+
prefix: R,
|
|
582
589
|
arrayScope: "consumer"
|
|
583
590
|
}],
|
|
584
591
|
["FILTERXML", {
|
|
585
|
-
prefix:
|
|
592
|
+
prefix: R,
|
|
586
593
|
arrayScope: "consumer"
|
|
587
594
|
}],
|
|
588
595
|
["FVSCHEDULE", {
|
|
@@ -592,46 +599,46 @@ var n = "_xlfn.", E = "_xlfn._xlws.", o = /* @__PURE__ */ new Map([
|
|
|
592
599
|
["HYPERLINK", { arrayScope: "consumer" }],
|
|
593
600
|
["ISREF", { arrayScope: "consumer" }],
|
|
594
601
|
["MUNIT", {
|
|
595
|
-
prefix:
|
|
602
|
+
prefix: R,
|
|
596
603
|
arrayScope: "consumer"
|
|
597
604
|
}],
|
|
598
605
|
["OR", { arrayScope: "consumer" }],
|
|
599
606
|
["PERCENTOF", {
|
|
600
|
-
prefix:
|
|
607
|
+
prefix: R,
|
|
601
608
|
arrayScope: "consumer"
|
|
602
609
|
}],
|
|
603
610
|
["PERCENTRANK", { arrayScope: "consumer" }],
|
|
604
611
|
["PERCENTRANK.EXC", {
|
|
605
|
-
prefix:
|
|
612
|
+
prefix: R,
|
|
606
613
|
arrayScope: "consumer"
|
|
607
614
|
}],
|
|
608
615
|
["PERCENTRANK.INC", {
|
|
609
|
-
prefix:
|
|
616
|
+
prefix: R,
|
|
610
617
|
arrayScope: "consumer"
|
|
611
618
|
}],
|
|
612
619
|
["REGEXEXTRACT", {
|
|
613
|
-
prefix:
|
|
620
|
+
prefix: R,
|
|
614
621
|
arrayScope: "consumer"
|
|
615
622
|
}],
|
|
616
623
|
["SEQUENCE", {
|
|
617
|
-
prefix:
|
|
624
|
+
prefix: R,
|
|
618
625
|
arrayScope: "consumer"
|
|
619
626
|
}],
|
|
620
627
|
["SHEET", {
|
|
621
|
-
prefix:
|
|
628
|
+
prefix: R,
|
|
622
629
|
arrayScope: "consumer"
|
|
623
630
|
}],
|
|
624
631
|
["STDEVPA", { arrayScope: "consumer" }],
|
|
625
632
|
["STOCKHISTORY", {
|
|
626
|
-
prefix:
|
|
633
|
+
prefix: R,
|
|
627
634
|
arrayScope: "consumer"
|
|
628
635
|
}],
|
|
629
636
|
["XOR", {
|
|
630
|
-
prefix:
|
|
637
|
+
prefix: R,
|
|
631
638
|
arrayScope: "consumer"
|
|
632
639
|
}],
|
|
633
640
|
["Z.TEST", {
|
|
634
|
-
prefix:
|
|
641
|
+
prefix: R,
|
|
635
642
|
arrayScope: "consumer"
|
|
636
643
|
}],
|
|
637
644
|
["ZTEST", { arrayScope: "consumer" }],
|
|
@@ -641,23 +648,23 @@ var n = "_xlfn.", E = "_xlfn._xlws.", o = /* @__PURE__ */ new Map([
|
|
|
641
648
|
arrayScope: "lazy"
|
|
642
649
|
}],
|
|
643
650
|
["IFNA", {
|
|
644
|
-
prefix:
|
|
651
|
+
prefix: R,
|
|
645
652
|
valueReturn: !0,
|
|
646
653
|
arrayScope: "lazy"
|
|
647
654
|
}],
|
|
648
655
|
["IFS", {
|
|
649
|
-
prefix:
|
|
656
|
+
prefix: R,
|
|
650
657
|
arrayReturn: !0,
|
|
651
658
|
arrayScope: "lazy"
|
|
652
659
|
}],
|
|
653
660
|
["SWITCH", {
|
|
654
|
-
prefix:
|
|
661
|
+
prefix: R,
|
|
655
662
|
arrayReturn: !0,
|
|
656
663
|
arrayScope: "lazy"
|
|
657
664
|
}],
|
|
658
665
|
["CHOOSE", { scopeClears: [0, 1] }],
|
|
659
666
|
["DROP", {
|
|
660
|
-
prefix:
|
|
667
|
+
prefix: R,
|
|
661
668
|
scopeClears: [1, 2]
|
|
662
669
|
}],
|
|
663
670
|
["INDIRECT", { volatile: !0 }],
|
|
@@ -666,23 +673,23 @@ var n = "_xlfn.", E = "_xlfn._xlws.", o = /* @__PURE__ */ new Map([
|
|
|
666
673
|
["OFFSET", { volatile: !0 }],
|
|
667
674
|
["RAND", { volatile: !0 }],
|
|
668
675
|
["RANDARRAY", {
|
|
669
|
-
prefix:
|
|
676
|
+
prefix: R,
|
|
670
677
|
arrayScope: "consumer",
|
|
671
678
|
volatile: !0
|
|
672
679
|
}],
|
|
673
680
|
["TODAY", { volatile: !0 }],
|
|
674
681
|
["TRIMRANGE", {
|
|
675
|
-
prefix:
|
|
682
|
+
prefix: R,
|
|
676
683
|
arrayScope: "opens",
|
|
677
684
|
volatile: !0
|
|
678
685
|
}],
|
|
679
686
|
["ABS", {}],
|
|
680
687
|
["ACOS", {}],
|
|
681
688
|
["ACOSH", {}],
|
|
682
|
-
["ACOT", { prefix:
|
|
683
|
-
["ACOTH", { prefix:
|
|
689
|
+
["ACOT", { prefix: R }],
|
|
690
|
+
["ACOTH", { prefix: R }],
|
|
684
691
|
["ADDRESS", {}],
|
|
685
|
-
["ARABIC", { prefix:
|
|
692
|
+
["ARABIC", { prefix: R }],
|
|
686
693
|
["AREAS", {}],
|
|
687
694
|
["ASC", {}],
|
|
688
695
|
["ASIN", {}],
|
|
@@ -693,47 +700,47 @@ var n = "_xlfn.", E = "_xlfn._xlws.", o = /* @__PURE__ */ new Map([
|
|
|
693
700
|
["AVERAGEIF", {}],
|
|
694
701
|
["AVERAGEIFS", {}],
|
|
695
702
|
["BAHTTEXT", {}],
|
|
696
|
-
["BASE", { prefix:
|
|
697
|
-
["BETA.DIST", { prefix:
|
|
698
|
-
["BETA.INV", { prefix:
|
|
703
|
+
["BASE", { prefix: R }],
|
|
704
|
+
["BETA.DIST", { prefix: R }],
|
|
705
|
+
["BETA.INV", { prefix: R }],
|
|
699
706
|
["BETADIST", {}],
|
|
700
707
|
["BETAINV", {}],
|
|
701
|
-
["BINOM.DIST", { prefix:
|
|
702
|
-
["BINOM.DIST.RANGE", { prefix:
|
|
703
|
-
["BINOM.INV", { prefix:
|
|
708
|
+
["BINOM.DIST", { prefix: R }],
|
|
709
|
+
["BINOM.DIST.RANGE", { prefix: R }],
|
|
710
|
+
["BINOM.INV", { prefix: R }],
|
|
704
711
|
["BINOMDIST", {}],
|
|
705
|
-
["BITAND", { prefix:
|
|
706
|
-
["BITLSHIFT", { prefix:
|
|
707
|
-
["BITOR", { prefix:
|
|
708
|
-
["BITRSHIFT", { prefix:
|
|
709
|
-
["BITXOR", { prefix:
|
|
712
|
+
["BITAND", { prefix: R }],
|
|
713
|
+
["BITLSHIFT", { prefix: R }],
|
|
714
|
+
["BITOR", { prefix: R }],
|
|
715
|
+
["BITRSHIFT", { prefix: R }],
|
|
716
|
+
["BITXOR", { prefix: R }],
|
|
710
717
|
["CEILING", {}],
|
|
711
|
-
["CEILING.MATH", { prefix:
|
|
712
|
-
["CEILING.PRECISE", { prefix:
|
|
718
|
+
["CEILING.MATH", { prefix: R }],
|
|
719
|
+
["CEILING.PRECISE", { prefix: R }],
|
|
713
720
|
["CHAR", {}],
|
|
714
721
|
["CHIDIST", {}],
|
|
715
722
|
["CHIINV", {}],
|
|
716
|
-
["CHISQ.DIST", { prefix:
|
|
717
|
-
["CHISQ.DIST.RT", { prefix:
|
|
718
|
-
["CHISQ.INV", { prefix:
|
|
719
|
-
["CHISQ.INV.RT", { prefix:
|
|
723
|
+
["CHISQ.DIST", { prefix: R }],
|
|
724
|
+
["CHISQ.DIST.RT", { prefix: R }],
|
|
725
|
+
["CHISQ.INV", { prefix: R }],
|
|
726
|
+
["CHISQ.INV.RT", { prefix: R }],
|
|
720
727
|
["CLEAN", {}],
|
|
721
728
|
["CODE", {}],
|
|
722
729
|
["COMBIN", {}],
|
|
723
|
-
["COMBINA", { prefix:
|
|
730
|
+
["COMBINA", { prefix: R }],
|
|
724
731
|
["CONFIDENCE", {}],
|
|
725
|
-
["CONFIDENCE.NORM", { prefix:
|
|
726
|
-
["CONFIDENCE.T", { prefix:
|
|
732
|
+
["CONFIDENCE.NORM", { prefix: R }],
|
|
733
|
+
["CONFIDENCE.T", { prefix: R }],
|
|
727
734
|
["COS", {}],
|
|
728
735
|
["COSH", {}],
|
|
729
|
-
["COT", { prefix:
|
|
730
|
-
["COTH", { prefix:
|
|
736
|
+
["COT", { prefix: R }],
|
|
737
|
+
["COTH", { prefix: R }],
|
|
731
738
|
["COUNTBLANK", {}],
|
|
732
739
|
["COUNTIF", {}],
|
|
733
740
|
["COUNTIFS", {}],
|
|
734
741
|
["CRITBINOM", {}],
|
|
735
|
-
["CSC", { prefix:
|
|
736
|
-
["CSCH", { prefix:
|
|
742
|
+
["CSC", { prefix: R }],
|
|
743
|
+
["CSCH", { prefix: R }],
|
|
737
744
|
["CUBEKPIMEMBER", {}],
|
|
738
745
|
["CUBEMEMBER", {}],
|
|
739
746
|
["CUBEMEMBERPROPERTY", {}],
|
|
@@ -745,27 +752,27 @@ var n = "_xlfn.", E = "_xlfn._xlws.", o = /* @__PURE__ */ new Map([
|
|
|
745
752
|
["DATESTRING", {}],
|
|
746
753
|
["DATEVALUE", {}],
|
|
747
754
|
["DAY", {}],
|
|
748
|
-
["DAYS", { prefix:
|
|
755
|
+
["DAYS", { prefix: R }],
|
|
749
756
|
["DAYS360", {}],
|
|
750
757
|
["DB", {}],
|
|
751
758
|
["DBCS", {}],
|
|
752
759
|
["DDB", {}],
|
|
753
|
-
["DECIMAL", { prefix:
|
|
760
|
+
["DECIMAL", { prefix: R }],
|
|
754
761
|
["DEGREES", {}],
|
|
755
|
-
["DETECTLANGUAGE", { prefix:
|
|
762
|
+
["DETECTLANGUAGE", { prefix: R }],
|
|
756
763
|
["DOLLAR", {}],
|
|
757
764
|
["ECMA.CEILING", {}],
|
|
758
|
-
["ENCODEURL", { prefix:
|
|
765
|
+
["ENCODEURL", { prefix: R }],
|
|
759
766
|
["ERROR.TYPE", {}],
|
|
760
767
|
["EVEN", {}],
|
|
761
768
|
["EXACT", {}],
|
|
762
769
|
["EXP", {}],
|
|
763
|
-
["EXPON.DIST", { prefix:
|
|
770
|
+
["EXPON.DIST", { prefix: R }],
|
|
764
771
|
["EXPONDIST", {}],
|
|
765
|
-
["F.DIST", { prefix:
|
|
766
|
-
["F.DIST.RT", { prefix:
|
|
767
|
-
["F.INV", { prefix:
|
|
768
|
-
["F.INV.RT", { prefix:
|
|
772
|
+
["F.DIST", { prefix: R }],
|
|
773
|
+
["F.DIST.RT", { prefix: R }],
|
|
774
|
+
["F.INV", { prefix: R }],
|
|
775
|
+
["F.INV.RT", { prefix: R }],
|
|
769
776
|
["FACT", {}],
|
|
770
777
|
["FALSE", {}],
|
|
771
778
|
["FDIST", {}],
|
|
@@ -776,21 +783,21 @@ var n = "_xlfn.", E = "_xlfn._xlws.", o = /* @__PURE__ */ new Map([
|
|
|
776
783
|
["FISHERINV", {}],
|
|
777
784
|
["FIXED", {}],
|
|
778
785
|
["FLOOR", {}],
|
|
779
|
-
["FLOOR.MATH", { prefix:
|
|
780
|
-
["FLOOR.PRECISE", { prefix:
|
|
786
|
+
["FLOOR.MATH", { prefix: R }],
|
|
787
|
+
["FLOOR.PRECISE", { prefix: R }],
|
|
781
788
|
["FV", {}],
|
|
782
|
-
["GAMMA", { prefix:
|
|
783
|
-
["GAMMA.DIST", { prefix:
|
|
784
|
-
["GAMMA.INV", { prefix:
|
|
789
|
+
["GAMMA", { prefix: R }],
|
|
790
|
+
["GAMMA.DIST", { prefix: R }],
|
|
791
|
+
["GAMMA.INV", { prefix: R }],
|
|
785
792
|
["GAMMADIST", {}],
|
|
786
793
|
["GAMMAINV", {}],
|
|
787
794
|
["GAMMALN", {}],
|
|
788
|
-
["GAMMALN.PRECISE", { prefix:
|
|
789
|
-
["GAUSS", { prefix:
|
|
795
|
+
["GAMMALN.PRECISE", { prefix: R }],
|
|
796
|
+
["GAUSS", { prefix: R }],
|
|
790
797
|
["HOUR", {}],
|
|
791
|
-
["HYPGEOM.DIST", { prefix:
|
|
798
|
+
["HYPGEOM.DIST", { prefix: R }],
|
|
792
799
|
["HYPGEOMDIST", {}],
|
|
793
|
-
["IMAGE", { prefix:
|
|
800
|
+
["IMAGE", { prefix: R }],
|
|
794
801
|
["INT", {}],
|
|
795
802
|
["IPMT", {}],
|
|
796
803
|
["ISBLANK", {}],
|
|
@@ -803,10 +810,10 @@ var n = "_xlfn.", E = "_xlfn._xlws.", o = /* @__PURE__ */ new Map([
|
|
|
803
810
|
["ISNUMBER", {}],
|
|
804
811
|
["ISO.CEILING", {}],
|
|
805
812
|
["ISODD", {}],
|
|
806
|
-
["ISOWEEKNUM", { prefix:
|
|
813
|
+
["ISOWEEKNUM", { prefix: R }],
|
|
807
814
|
["ISPMT", {}],
|
|
808
815
|
["ISTEXT", {}],
|
|
809
|
-
["LAMBDA", { prefix:
|
|
816
|
+
["LAMBDA", { prefix: R }],
|
|
810
817
|
["LEFT", {}],
|
|
811
818
|
["LEFTB", {}],
|
|
812
819
|
["LEN", {}],
|
|
@@ -815,24 +822,24 @@ var n = "_xlfn.", E = "_xlfn._xlws.", o = /* @__PURE__ */ new Map([
|
|
|
815
822
|
["LOG", {}],
|
|
816
823
|
["LOG10", {}],
|
|
817
824
|
["LOGINV", {}],
|
|
818
|
-
["LOGNORM.DIST", { prefix:
|
|
819
|
-
["LOGNORM.INV", { prefix:
|
|
825
|
+
["LOGNORM.DIST", { prefix: R }],
|
|
826
|
+
["LOGNORM.INV", { prefix: R }],
|
|
820
827
|
["LOGNORMDIST", {}],
|
|
821
828
|
["LOWER", {}],
|
|
822
|
-
["MAXIFS", { prefix:
|
|
829
|
+
["MAXIFS", { prefix: R }],
|
|
823
830
|
["MID", {}],
|
|
824
831
|
["MIDB", {}],
|
|
825
|
-
["MINIFS", { prefix:
|
|
832
|
+
["MINIFS", { prefix: R }],
|
|
826
833
|
["MINUTE", {}],
|
|
827
834
|
["MOD", {}],
|
|
828
835
|
["MONTH", {}],
|
|
829
836
|
["NA", {}],
|
|
830
|
-
["NEGBINOM.DIST", { prefix:
|
|
837
|
+
["NEGBINOM.DIST", { prefix: R }],
|
|
831
838
|
["NEGBINOMDIST", {}],
|
|
832
|
-
["NORM.DIST", { prefix:
|
|
833
|
-
["NORM.INV", { prefix:
|
|
834
|
-
["NORM.S.DIST", { prefix:
|
|
835
|
-
["NORM.S.INV", { prefix:
|
|
839
|
+
["NORM.DIST", { prefix: R }],
|
|
840
|
+
["NORM.INV", { prefix: R }],
|
|
841
|
+
["NORM.S.DIST", { prefix: R }],
|
|
842
|
+
["NORM.S.INV", { prefix: R }],
|
|
836
843
|
["NORMDIST", {}],
|
|
837
844
|
["NORMINV", {}],
|
|
838
845
|
["NORMSDIST", {}],
|
|
@@ -840,28 +847,28 @@ var n = "_xlfn.", E = "_xlfn._xlws.", o = /* @__PURE__ */ new Map([
|
|
|
840
847
|
["NOT", {}],
|
|
841
848
|
["NPER", {}],
|
|
842
849
|
["NUMBERSTRING", {}],
|
|
843
|
-
["NUMBERVALUE", { prefix:
|
|
850
|
+
["NUMBERVALUE", { prefix: R }],
|
|
844
851
|
["ODD", {}],
|
|
845
|
-
["PDURATION", { prefix:
|
|
852
|
+
["PDURATION", { prefix: R }],
|
|
846
853
|
["PERMUT", {}],
|
|
847
|
-
["PERMUTATIONA", { prefix:
|
|
848
|
-
["PHI", { prefix:
|
|
854
|
+
["PERMUTATIONA", { prefix: R }],
|
|
855
|
+
["PHI", { prefix: R }],
|
|
849
856
|
["PHONETIC", {}],
|
|
850
857
|
["PI", {}],
|
|
851
858
|
["PMT", {}],
|
|
852
859
|
["POISSON", {}],
|
|
853
|
-
["POISSON.DIST", { prefix:
|
|
860
|
+
["POISSON.DIST", { prefix: R }],
|
|
854
861
|
["POWER", {}],
|
|
855
862
|
["PPMT", {}],
|
|
856
863
|
["PROPER", {}],
|
|
857
864
|
["PV", {}],
|
|
858
865
|
["RADIANS", {}],
|
|
859
866
|
["RANK", {}],
|
|
860
|
-
["RANK.AVG", { prefix:
|
|
861
|
-
["RANK.EQ", { prefix:
|
|
867
|
+
["RANK.AVG", { prefix: R }],
|
|
868
|
+
["RANK.EQ", { prefix: R }],
|
|
862
869
|
["RATE", {}],
|
|
863
|
-
["REGEXREPLACE", { prefix:
|
|
864
|
-
["REGEXTEST", { prefix:
|
|
870
|
+
["REGEXREPLACE", { prefix: R }],
|
|
871
|
+
["REGEXTEST", { prefix: R }],
|
|
865
872
|
["REPLACE", {}],
|
|
866
873
|
["REPLACEB", {}],
|
|
867
874
|
["REPT", {}],
|
|
@@ -871,12 +878,12 @@ var n = "_xlfn.", E = "_xlfn._xlws.", o = /* @__PURE__ */ new Map([
|
|
|
871
878
|
["ROUND", {}],
|
|
872
879
|
["ROUNDDOWN", {}],
|
|
873
880
|
["ROUNDUP", {}],
|
|
874
|
-
["RRI", { prefix:
|
|
881
|
+
["RRI", { prefix: R }],
|
|
875
882
|
["RTD", {}],
|
|
876
883
|
["SEARCH", {}],
|
|
877
884
|
["SEARCHB", {}],
|
|
878
|
-
["SEC", { prefix:
|
|
879
|
-
["SECH", { prefix:
|
|
885
|
+
["SEC", { prefix: R }],
|
|
886
|
+
["SECH", { prefix: R }],
|
|
880
887
|
["SECOND", {}],
|
|
881
888
|
["SIGN", {}],
|
|
882
889
|
["SIN", {}],
|
|
@@ -890,72 +897,72 @@ var n = "_xlfn.", E = "_xlfn._xlws.", o = /* @__PURE__ */ new Map([
|
|
|
890
897
|
["SUMIF", {}],
|
|
891
898
|
["SUMIFS", {}],
|
|
892
899
|
["SYD", {}],
|
|
893
|
-
["T.DIST", { prefix:
|
|
894
|
-
["T.DIST.2T", { prefix:
|
|
895
|
-
["T.DIST.RT", { prefix:
|
|
896
|
-
["T.INV", { prefix:
|
|
897
|
-
["T.INV.2T", { prefix:
|
|
900
|
+
["T.DIST", { prefix: R }],
|
|
901
|
+
["T.DIST.2T", { prefix: R }],
|
|
902
|
+
["T.DIST.RT", { prefix: R }],
|
|
903
|
+
["T.INV", { prefix: R }],
|
|
904
|
+
["T.INV.2T", { prefix: R }],
|
|
898
905
|
["TAN", {}],
|
|
899
906
|
["TANH", {}],
|
|
900
907
|
["TDIST", {}],
|
|
901
908
|
["TEXT", {}],
|
|
902
|
-
["TEXTAFTER", { prefix:
|
|
903
|
-
["TEXTBEFORE", { prefix:
|
|
909
|
+
["TEXTAFTER", { prefix: R }],
|
|
910
|
+
["TEXTBEFORE", { prefix: R }],
|
|
904
911
|
["TIME", {}],
|
|
905
912
|
["TIMEVALUE", {}],
|
|
906
913
|
["TINV", {}],
|
|
907
|
-
["TRANSLATE", { prefix:
|
|
914
|
+
["TRANSLATE", { prefix: R }],
|
|
908
915
|
["TRIM", {}],
|
|
909
916
|
["TRUE", {}],
|
|
910
917
|
["TRUNC", {}],
|
|
911
|
-
["UNICHAR", { prefix:
|
|
912
|
-
["UNICODE", { prefix:
|
|
918
|
+
["UNICHAR", { prefix: R }],
|
|
919
|
+
["UNICODE", { prefix: R }],
|
|
913
920
|
["UPPER", {}],
|
|
914
921
|
["VALUE", {}],
|
|
915
|
-
["VALUETOTEXT", { prefix:
|
|
922
|
+
["VALUETOTEXT", { prefix: R }],
|
|
916
923
|
["VDB", {}],
|
|
917
924
|
["WAIT", {}],
|
|
918
|
-
["WEBSERVICE", { prefix:
|
|
925
|
+
["WEBSERVICE", { prefix: R }],
|
|
919
926
|
["WEEKDAY", {}],
|
|
920
927
|
["WEIBULL", {}],
|
|
921
|
-
["WEIBULL.DIST", { prefix:
|
|
928
|
+
["WEIBULL.DIST", { prefix: R }],
|
|
922
929
|
["YEAR", {}]
|
|
923
|
-
]),
|
|
930
|
+
]), l = (e) => "never" === I.get(e)?.intersect, N = (e, r) => !0 === I.get(e)?.slotNever?.includes(r), L = (e, r) => !0 === I.get(e)?.slotAlways?.includes(r), f = (e) => !0 === I.get(e)?.valueReturn, C = (e) => I.get(e)?.readsPerCell, D = (e) => "opens" === I.get(e)?.arrayScope, M = (e, r) => ({
|
|
924
931
|
type: "function",
|
|
925
932
|
value: e,
|
|
926
933
|
inputs: r ?? null
|
|
927
934
|
});
|
|
928
|
-
function
|
|
935
|
+
function P(e) {
|
|
929
936
|
return (r, t) => {
|
|
930
|
-
const
|
|
931
|
-
if ("function" ===
|
|
932
|
-
const e = String(
|
|
937
|
+
const n = r.type, E = r.value;
|
|
938
|
+
if ("function" === n) {
|
|
939
|
+
const e = String(E).toUpperCase(), t = (a = e, I.get(a)?.prefix), n = "LET" === e || "LAMBDA" === e ? U(r, e) : void 0;
|
|
933
940
|
if (t || n) return {
|
|
934
941
|
...r,
|
|
935
|
-
value: t ? t +
|
|
942
|
+
value: t ? t + E : E,
|
|
936
943
|
inputs: n ?? r.inputs
|
|
937
944
|
};
|
|
938
|
-
} else if ("infix" ===
|
|
945
|
+
} else if ("infix" === n) {
|
|
939
946
|
let e;
|
|
940
|
-
if (".:." ===
|
|
947
|
+
if (".:." === E ? e = "_TRO_ALL" : ".:" === E ? e = "_TRO_LEADING" : ":." === E && (e = "_TRO_TRAILING"), e) {
|
|
941
948
|
const t = {
|
|
942
949
|
type: "infix",
|
|
943
950
|
value: ":",
|
|
944
951
|
inputs: r.inputs,
|
|
945
952
|
isReference: !0
|
|
946
953
|
};
|
|
947
|
-
return
|
|
954
|
+
return M(R + e, [t]);
|
|
948
955
|
}
|
|
949
|
-
} else if ("postfix" ===
|
|
950
|
-
if ("#" ===
|
|
951
|
-
} else if ("prefix" ===
|
|
952
|
-
if ("@" ===
|
|
953
|
-
} else if ("named" ===
|
|
954
|
-
const t =
|
|
956
|
+
} else if ("postfix" === n) {
|
|
957
|
+
if ("#" === E) return M(R + "ANCHORARRAY", [r.inputs[0]]);
|
|
958
|
+
} else if ("prefix" === n) {
|
|
959
|
+
if ("@" === E && "tableReference" !== t?.type) return M(R + "SINGLE", [r.inputs[0]]);
|
|
960
|
+
} else if ("named" === n) {
|
|
961
|
+
const t = E, n = t?.name;
|
|
955
962
|
if (n && !t.scope) {
|
|
956
963
|
const t = n.toUpperCase();
|
|
957
964
|
if (((e) => {
|
|
958
|
-
const r =
|
|
965
|
+
const r = I.get(e);
|
|
959
966
|
return void 0 !== r && !0 !== r.unimplemented;
|
|
960
967
|
})(t) && !e?.has(t)) return {
|
|
961
968
|
...r,
|
|
@@ -965,85 +972,85 @@ function O(e) {
|
|
|
965
972
|
}
|
|
966
973
|
};
|
|
967
974
|
}
|
|
968
|
-
} else if ("tableReference" ===
|
|
969
|
-
var
|
|
975
|
+
} else if ("tableReference" === n) return g(r);
|
|
976
|
+
var a;
|
|
970
977
|
};
|
|
971
978
|
}
|
|
972
|
-
var
|
|
979
|
+
var y = (e, r) => e.length > r.length && e.substring(0, r.length).toLowerCase() === r, m = (e) => {
|
|
973
980
|
if ("named" !== e?.type) return;
|
|
974
981
|
const r = e.value, t = r?.name;
|
|
975
|
-
return !t || r.scope ||
|
|
976
|
-
},
|
|
982
|
+
return !t || r.scope || y(t, "_xlpm.") ? void 0 : y(t, "_xleta.") ? t.substring(7) : t;
|
|
983
|
+
}, v = (e, r) => ({
|
|
977
984
|
...e,
|
|
978
985
|
value: {
|
|
979
986
|
name: "_xlpm." + r,
|
|
980
987
|
scope: null
|
|
981
988
|
}
|
|
982
|
-
}),
|
|
983
|
-
const t =
|
|
984
|
-
if (void 0 !== t) return t.toUpperCase() === r ?
|
|
989
|
+
}), x = (e, r) => {
|
|
990
|
+
const t = m(e);
|
|
991
|
+
if (void 0 !== t) return t.toUpperCase() === r ? v(e, t) : e;
|
|
985
992
|
const n = e.inputs;
|
|
986
993
|
if (!n) return e;
|
|
987
994
|
let E;
|
|
988
995
|
for (let e = 0; e < n.length; e++) {
|
|
989
996
|
const t = n[e];
|
|
990
997
|
if (!t) continue;
|
|
991
|
-
const
|
|
992
|
-
|
|
998
|
+
const a = x(t, r);
|
|
999
|
+
a !== t && (E || (E = [...n]), E[e] = a);
|
|
993
1000
|
}
|
|
994
1001
|
return E ? {
|
|
995
1002
|
...e,
|
|
996
1003
|
inputs: E
|
|
997
1004
|
} : e;
|
|
998
|
-
},
|
|
1005
|
+
}, U = (e, r) => {
|
|
999
1006
|
const t = e.inputs, n = t?.length ?? 0;
|
|
1000
1007
|
if (!t || n < 2) return;
|
|
1001
1008
|
let E;
|
|
1002
|
-
const
|
|
1003
|
-
r !==
|
|
1009
|
+
const a = (e) => (E ?? t)[e], o = (e, r) => {
|
|
1010
|
+
r !== a(e) && (E || (E = [...t]), E[e] = r);
|
|
1004
1011
|
}, T = [];
|
|
1005
1012
|
if ("LAMBDA" === r) for (let e = 0; e < n - 1; e++) T.push([e, n - 1]);
|
|
1006
1013
|
else for (let e = 0; e + 1 < n; e += 2) T.push([e, e + 2]);
|
|
1007
1014
|
for (const [e, r] of T) {
|
|
1008
|
-
const t =
|
|
1015
|
+
const t = a(e), E = m(t);
|
|
1009
1016
|
if (void 0 === E) continue;
|
|
1010
|
-
|
|
1017
|
+
o(e, !0 === t.value?.optional ? {
|
|
1011
1018
|
...t,
|
|
1012
1019
|
value: {
|
|
1013
1020
|
name: "_xlop." + E,
|
|
1014
1021
|
scope: null
|
|
1015
1022
|
}
|
|
1016
|
-
} :
|
|
1023
|
+
} : v(t, E));
|
|
1017
1024
|
const T = E.toUpperCase();
|
|
1018
1025
|
for (let e = r; e < n; e++) {
|
|
1019
|
-
const r =
|
|
1020
|
-
r &&
|
|
1026
|
+
const r = a(e);
|
|
1027
|
+
r && o(e, x(r, T));
|
|
1021
1028
|
}
|
|
1022
1029
|
}
|
|
1023
1030
|
return E;
|
|
1024
|
-
},
|
|
1031
|
+
}, B = [
|
|
1025
1032
|
"_XLFN._XLWS.",
|
|
1026
1033
|
"_XLFN.",
|
|
1027
1034
|
"_XLWS.",
|
|
1028
1035
|
"_XLETA.",
|
|
1029
1036
|
"_XLPM."
|
|
1030
|
-
],
|
|
1037
|
+
], F = (e) => {
|
|
1031
1038
|
const r = e.toUpperCase();
|
|
1032
1039
|
let t = 0, n = !0;
|
|
1033
1040
|
for (; n;) {
|
|
1034
1041
|
n = !1;
|
|
1035
|
-
for (const e of
|
|
1042
|
+
for (const e of B) if (r.startsWith(e, t)) {
|
|
1036
1043
|
t += e.length, n = !0;
|
|
1037
1044
|
break;
|
|
1038
1045
|
}
|
|
1039
1046
|
}
|
|
1040
1047
|
return 0 === t ? e : e.substring(t);
|
|
1041
|
-
},
|
|
1048
|
+
}, G = /* @__PURE__ */ new Map([
|
|
1042
1049
|
["_TRO_ALL", ".:."],
|
|
1043
1050
|
["_TRO_LEADING", ".:"],
|
|
1044
1051
|
["_TRO_TRAILING", ":."]
|
|
1045
1052
|
]);
|
|
1046
|
-
var
|
|
1053
|
+
var g = (e) => {
|
|
1047
1054
|
const r = e.inputs;
|
|
1048
1055
|
if (!r) return;
|
|
1049
1056
|
let t = !1;
|
|
@@ -1067,23 +1074,23 @@ var f = (e) => {
|
|
|
1067
1074
|
...e,
|
|
1068
1075
|
inputs: n
|
|
1069
1076
|
} : void 0;
|
|
1070
|
-
},
|
|
1077
|
+
}, d = "__sxl.INTERSECT", V = (e) => {
|
|
1071
1078
|
if (!e) return !1;
|
|
1072
|
-
if ("function" === e.type && (r =
|
|
1079
|
+
if ("function" === e.type && (r = _(e), !0 === I.get(r)?.volatile)) return !0;
|
|
1073
1080
|
var r;
|
|
1074
1081
|
const t = e.inputs;
|
|
1075
1082
|
if (!t) return !1;
|
|
1076
|
-
for (let e = 0; e < t.length; e++) if (
|
|
1083
|
+
for (let e = 0; e < t.length; e++) if (V(t[e])) return !0;
|
|
1077
1084
|
return !1;
|
|
1078
1085
|
};
|
|
1079
|
-
function
|
|
1086
|
+
function h(e) {
|
|
1080
1087
|
const r = /* @__PURE__ */ new Map();
|
|
1081
1088
|
return {
|
|
1082
1089
|
getFunction: (r) => e()?.getFunctions().getByName(r) ?? null,
|
|
1083
1090
|
getNamedRoot: (t, n) => {
|
|
1084
|
-
const E = `${n ?? ""}!${t.toUpperCase()}`,
|
|
1085
|
-
if (void 0 !==
|
|
1086
|
-
let
|
|
1091
|
+
const E = `${n ?? ""}!${t.toUpperCase()}`, a = r.get(E);
|
|
1092
|
+
if (void 0 !== a) return a;
|
|
1093
|
+
let o = null;
|
|
1087
1094
|
const T = e()?.getNamedFormulas();
|
|
1088
1095
|
if (T) {
|
|
1089
1096
|
const e = T.getItems(n ? {
|
|
@@ -1091,14 +1098,14 @@ function P(e) {
|
|
|
1091
1098
|
scope: n
|
|
1092
1099
|
} : { name: t }), r = n ? e[0] : e.find((e) => !e.getScope()) ?? e[0];
|
|
1093
1100
|
r && r.getExpression({ formulaTransform: (e, r) => {
|
|
1094
|
-
void 0 === r && (
|
|
1101
|
+
void 0 === r && (o = e);
|
|
1095
1102
|
} });
|
|
1096
1103
|
}
|
|
1097
|
-
return r.set(E,
|
|
1104
|
+
return r.set(E, o), o;
|
|
1098
1105
|
}
|
|
1099
1106
|
};
|
|
1100
1107
|
}
|
|
1101
|
-
var
|
|
1108
|
+
var H = /* @__PURE__ */ new Set([
|
|
1102
1109
|
"+",
|
|
1103
1110
|
"-",
|
|
1104
1111
|
"*",
|
|
@@ -1111,13 +1118,13 @@ var y = /* @__PURE__ */ new Set([
|
|
|
1111
1118
|
"<",
|
|
1112
1119
|
">=",
|
|
1113
1120
|
"<="
|
|
1114
|
-
]),
|
|
1121
|
+
]), W = /* @__PURE__ */ new Set(["-", "+"]), Y = /* @__PURE__ */ new Set([
|
|
1115
1122
|
":",
|
|
1116
1123
|
" ",
|
|
1117
1124
|
".:.",
|
|
1118
1125
|
".:",
|
|
1119
1126
|
":."
|
|
1120
|
-
]),
|
|
1127
|
+
]), K = (e) => {
|
|
1121
1128
|
if (!e) return null;
|
|
1122
1129
|
if ("cell" === e.type) {
|
|
1123
1130
|
const r = e.value;
|
|
@@ -1136,12 +1143,12 @@ var y = /* @__PURE__ */ new Set([
|
|
|
1136
1143
|
} : null;
|
|
1137
1144
|
}
|
|
1138
1145
|
return null;
|
|
1139
|
-
},
|
|
1146
|
+
}, X = (e) => {
|
|
1140
1147
|
if (!e || "number" !== e.type) return null;
|
|
1141
1148
|
const r = "number" == typeof e.value ? e.value : Number(e.value);
|
|
1142
1149
|
return Number.isFinite(r) ? r : null;
|
|
1143
|
-
},
|
|
1144
|
-
let r =
|
|
1150
|
+
}, _ = (e) => String(e.value ?? "").toUpperCase(), b = /* @__PURE__ */ new WeakMap(), w = (e) => {
|
|
1151
|
+
let r = b.get(e);
|
|
1145
1152
|
return r || (r = ((e) => {
|
|
1146
1153
|
const r = [], t = [], n = (e) => {
|
|
1147
1154
|
r.push(null !== e.getRangeType() || e.getArrayDepth() > 0), t.push(null !== e.getScalarType());
|
|
@@ -1165,8 +1172,8 @@ var y = /* @__PURE__ */ new Set([
|
|
|
1165
1172
|
valueTyped: t,
|
|
1166
1173
|
period: E
|
|
1167
1174
|
};
|
|
1168
|
-
})(e),
|
|
1169
|
-
},
|
|
1175
|
+
})(e), b.set(e, r)), r;
|
|
1176
|
+
}, q = (e, r) => {
|
|
1170
1177
|
const t = e.accepts.length;
|
|
1171
1178
|
if (r < t) return r;
|
|
1172
1179
|
if (e.period > 0) {
|
|
@@ -1174,180 +1181,180 @@ var y = /* @__PURE__ */ new Set([
|
|
|
1174
1181
|
return n + (r - n) % e.period;
|
|
1175
1182
|
}
|
|
1176
1183
|
return -1;
|
|
1177
|
-
},
|
|
1178
|
-
const n =
|
|
1179
|
-
return E < 0 ? null : !!
|
|
1180
|
-
},
|
|
1181
|
-
const r =
|
|
1184
|
+
}, $ = (e, r, t) => {
|
|
1185
|
+
const n = w(r), E = q(n, t);
|
|
1186
|
+
return E < 0 ? null : !!L(e, E) || !l(e) && !N(e, E) && !n.accepts[E];
|
|
1187
|
+
}, k = (e, r) => r && "function" === e.type ? !((e) => {
|
|
1188
|
+
const r = I.get(e)?.arrayScope;
|
|
1182
1189
|
return "consumer" === r || "lazy" === r;
|
|
1183
|
-
})(
|
|
1184
|
-
const n =
|
|
1190
|
+
})(_(e)) : r, Q = (e, r, t) => {
|
|
1191
|
+
const n = k(e, t);
|
|
1185
1192
|
if ("function" !== e.type) return () => n;
|
|
1186
|
-
const E =
|
|
1187
|
-
if (!a && !
|
|
1188
|
-
const
|
|
1189
|
-
if (!
|
|
1190
|
-
const
|
|
1193
|
+
const E = _(e), a = D(E), o = n && void 0 !== ((e) => I.get(e))(E)?.scopeClears;
|
|
1194
|
+
if (!a && !o) return () => n;
|
|
1195
|
+
const T = r.getFunction(E);
|
|
1196
|
+
if (!T) return () => n;
|
|
1197
|
+
const s = w(T);
|
|
1191
1198
|
return (e) => {
|
|
1192
|
-
const r =
|
|
1193
|
-
return !(r >= 0 && ((e, r) => !0 ===
|
|
1194
|
-
if (!
|
|
1195
|
-
const n =
|
|
1196
|
-
return !(E < 0) && !
|
|
1197
|
-
})(E,
|
|
1199
|
+
const r = q(s, e);
|
|
1200
|
+
return !(r >= 0 && ((e, r) => !0 === I.get(e)?.scopeClears?.includes(r))(E, r)) && (n || ((e, r, t) => {
|
|
1201
|
+
if (!D(e) || !r.isBuiltIn()) return !1;
|
|
1202
|
+
const n = w(r), E = q(n, t);
|
|
1203
|
+
return !(E < 0) && !L(e, E) && n.accepts[E];
|
|
1204
|
+
})(E, T, e));
|
|
1198
1205
|
};
|
|
1199
|
-
},
|
|
1206
|
+
}, Z = (e, r, t) => {
|
|
1200
1207
|
if (!t) return () => !1;
|
|
1201
1208
|
const n = e.type;
|
|
1202
1209
|
if ("paren" === n) return () => !0;
|
|
1203
|
-
if ("prefix" === n) return () =>
|
|
1204
|
-
if ("infix" === n) return () =>
|
|
1210
|
+
if ("prefix" === n) return () => W.has(e.value);
|
|
1211
|
+
if ("infix" === n) return () => H.has(e.value);
|
|
1205
1212
|
if ("function" !== n) return () => !1;
|
|
1206
|
-
const E = r.getFunction(
|
|
1213
|
+
const E = r.getFunction(_(e));
|
|
1207
1214
|
if (!E) return () => !1;
|
|
1208
|
-
const
|
|
1215
|
+
const a = w(E);
|
|
1209
1216
|
return (e) => {
|
|
1210
|
-
const r =
|
|
1211
|
-
return r >= 0 && !
|
|
1217
|
+
const r = q(a, e);
|
|
1218
|
+
return r >= 0 && !a.accepts[r];
|
|
1212
1219
|
};
|
|
1213
|
-
},
|
|
1220
|
+
}, J = (e, r, t, n) => {
|
|
1214
1221
|
if (!e) return !1;
|
|
1215
1222
|
const E = e.type;
|
|
1216
1223
|
if ("prefix" === E) {
|
|
1217
1224
|
const E = e.value;
|
|
1218
|
-
return "@" !== E && !!
|
|
1225
|
+
return "@" !== E && !!W.has(E) && J(e.inputs?.[0], r, t, n);
|
|
1219
1226
|
}
|
|
1220
|
-
if ("infix" === E &&
|
|
1227
|
+
if ("infix" === E && Y.has(e.value)) return !0;
|
|
1221
1228
|
if ("postfix" === E && "#" === e.value) return !0;
|
|
1222
1229
|
if ("tableReference" === E) return !0;
|
|
1223
1230
|
if ("array" === E) return n;
|
|
1224
|
-
if ("paren" === E) return
|
|
1231
|
+
if ("paren" === E) return J(e.inputs?.[0], r, t, n);
|
|
1225
1232
|
if ("cell" === E) {
|
|
1226
|
-
const r =
|
|
1233
|
+
const r = K(e);
|
|
1227
1234
|
return null !== r && !(1 === r.rows && 1 === r.cols);
|
|
1228
1235
|
}
|
|
1229
1236
|
if ("named" === E) {
|
|
1230
1237
|
const n = e.value, E = n?.name;
|
|
1231
1238
|
if (!E) return !1;
|
|
1232
|
-
const
|
|
1233
|
-
if (t.has(
|
|
1234
|
-
t.add(
|
|
1239
|
+
const a = `${n.scope ?? ""}!${E.toUpperCase()}`;
|
|
1240
|
+
if (t.has(a)) return !1;
|
|
1241
|
+
t.add(a);
|
|
1235
1242
|
try {
|
|
1236
1243
|
const e = r.getNamedRoot(E, n.scope);
|
|
1237
|
-
return !!e &&
|
|
1244
|
+
return !!e && J(e, r, t, !0);
|
|
1238
1245
|
} finally {
|
|
1239
|
-
t.delete(
|
|
1246
|
+
t.delete(a);
|
|
1240
1247
|
}
|
|
1241
1248
|
}
|
|
1242
|
-
if ("infix" === E &&
|
|
1249
|
+
if ("infix" === E && H.has(e.value)) return J(e.inputs?.[0], r, t, n) || J(e.inputs?.[1], r, t, n);
|
|
1243
1250
|
if ("function" === E) {
|
|
1244
|
-
const E =
|
|
1251
|
+
const E = _(e), a = r.getFunction(E);
|
|
1245
1252
|
if (!a) return !1;
|
|
1246
|
-
const
|
|
1253
|
+
const o = ((e, r, t, n, E) => {
|
|
1247
1254
|
if (!t.isBuiltIn()) return null;
|
|
1248
|
-
const
|
|
1249
|
-
if (!
|
|
1250
|
-
const
|
|
1255
|
+
const a = e.inputs;
|
|
1256
|
+
if (!a) return null;
|
|
1257
|
+
const o = a[0];
|
|
1251
1258
|
switch (r) {
|
|
1252
1259
|
case "OFFSET": {
|
|
1253
|
-
const e =
|
|
1254
|
-
if (void 0 === e && void 0 === r) return
|
|
1255
|
-
const t =
|
|
1260
|
+
const e = a[3], r = a[4];
|
|
1261
|
+
if (void 0 === e && void 0 === r) return J(o, n, E, !0);
|
|
1262
|
+
const t = o ? K(o) : null, T = void 0 === e ? 1 === t?.rows : 1 === X(e), s = void 0 === r ? 1 === t?.cols : 1 === X(r);
|
|
1256
1263
|
return !(T && s);
|
|
1257
1264
|
}
|
|
1258
1265
|
case "INDEX": {
|
|
1259
|
-
const e =
|
|
1266
|
+
const e = a[1], r = a[2], t = o ? K(o) : null;
|
|
1260
1267
|
if (1 === t?.rows && 1 === t?.cols) return !1;
|
|
1261
1268
|
const n = (e, r) => {
|
|
1262
1269
|
if (void 0 === e) return 1 === r;
|
|
1263
|
-
const t =
|
|
1270
|
+
const t = X(e);
|
|
1264
1271
|
return null !== t && 0 !== t;
|
|
1265
1272
|
};
|
|
1266
1273
|
return !(n(e, t?.rows) && n(r, t?.cols));
|
|
1267
1274
|
}
|
|
1268
1275
|
case "XLOOKUP": {
|
|
1269
|
-
if (
|
|
1270
|
-
const e =
|
|
1276
|
+
if (a[3] && J(a[3], n, E, !0)) return !0;
|
|
1277
|
+
const e = a[1] ? K(a[1]) : null, r = a[2] ? K(a[2]) : null;
|
|
1271
1278
|
return !(e && r && (1 === e.rows && 1 === e.cols ? 1 === r.rows && 1 === r.cols : 1 === e.cols ? 1 === r.cols : 1 === e.rows && 1 === r.rows));
|
|
1272
1279
|
}
|
|
1273
1280
|
default: return null;
|
|
1274
1281
|
}
|
|
1275
1282
|
})(e, E, a, r, t);
|
|
1276
|
-
if (null !==
|
|
1277
|
-
const
|
|
1278
|
-
if (void 0 !==
|
|
1279
|
-
if (a.isBuiltIn() && ((e) => !0 ===
|
|
1280
|
-
const
|
|
1281
|
-
if (null !==
|
|
1282
|
-
const
|
|
1283
|
-
if (null !==
|
|
1284
|
-
const
|
|
1285
|
-
if (!
|
|
1286
|
-
const
|
|
1287
|
-
for (let e = 0; e <
|
|
1283
|
+
if (null !== o) return o;
|
|
1284
|
+
const T = C(E);
|
|
1285
|
+
if (void 0 !== T && a.isBuiltIn()) return J(e.inputs?.[T], r, t, !0);
|
|
1286
|
+
if (a.isBuiltIn() && ((e) => !0 === I.get(e)?.arrayReturn)(E)) return !0;
|
|
1287
|
+
const s = a.getDeclaration().getReturnType();
|
|
1288
|
+
if (null !== s.getRangeType()) return !0;
|
|
1289
|
+
const i = a.isBuiltIn() && f(E);
|
|
1290
|
+
if (null !== s.getScalarType() && !i) return !1;
|
|
1291
|
+
const p = e.inputs;
|
|
1292
|
+
if (!p) return !1;
|
|
1293
|
+
const A = i || n;
|
|
1294
|
+
for (let e = 0; e < p.length; e++) if (J(p[e], r, t, A)) return !0;
|
|
1288
1295
|
return !1;
|
|
1289
1296
|
}
|
|
1290
1297
|
return !1;
|
|
1291
|
-
},
|
|
1298
|
+
}, z = (e, r, t) => {
|
|
1292
1299
|
if (!e || "function" !== e.type) return !1;
|
|
1293
|
-
const n =
|
|
1294
|
-
return !(!
|
|
1295
|
-
},
|
|
1296
|
-
const
|
|
1297
|
-
if (!
|
|
1298
|
-
if (
|
|
1299
|
-
const
|
|
1300
|
-
let
|
|
1301
|
-
if ("infix" ===
|
|
1302
|
-
for (let e = 0; e < 2; e++)
|
|
1303
|
-
return
|
|
1300
|
+
const n = _(e);
|
|
1301
|
+
return !(!f(n) && void 0 === C(n)) && !!r.getFunction(n)?.isBuiltIn() && J(e, r, t, !0);
|
|
1302
|
+
}, j = (e, r, t, n = !1, E = !1) => {
|
|
1303
|
+
const a = e.inputs;
|
|
1304
|
+
if (!a) return null;
|
|
1305
|
+
if (k(e, n)) return null;
|
|
1306
|
+
const o = e.type, T = Z(e, r, E);
|
|
1307
|
+
let s = null;
|
|
1308
|
+
if ("infix" === o && H.has(e.value)) {
|
|
1309
|
+
for (let e = 0; e < 2; e++) J(a[e], r, t, T(e)) && (s ??= []).push(e);
|
|
1310
|
+
return s;
|
|
1304
1311
|
}
|
|
1305
|
-
if ("prefix" ===
|
|
1306
|
-
if ("function" !==
|
|
1307
|
-
const
|
|
1308
|
-
if (!
|
|
1309
|
-
const
|
|
1310
|
-
for (let e = 0; e <
|
|
1311
|
-
const n =
|
|
1312
|
+
if ("prefix" === o && W.has(e.value)) return J(a[0], r, t, T(0)) && (s = [0]), s;
|
|
1313
|
+
if ("function" !== o) return null;
|
|
1314
|
+
const i = _(e), p = r.getFunction(i);
|
|
1315
|
+
if (!p) return null;
|
|
1316
|
+
const A = w(p);
|
|
1317
|
+
for (let e = 0; e < a.length; e++) {
|
|
1318
|
+
const n = $(i, p, e);
|
|
1312
1319
|
if (null === n) break;
|
|
1313
1320
|
if (n) {
|
|
1314
|
-
|
|
1321
|
+
J(a[e], r, t, T(e)) && (s ??= []).push(e);
|
|
1315
1322
|
continue;
|
|
1316
1323
|
}
|
|
1317
|
-
if (
|
|
1318
|
-
const E =
|
|
1319
|
-
E < 0 || !
|
|
1324
|
+
if (l(i)) continue;
|
|
1325
|
+
const E = q(A, e);
|
|
1326
|
+
E < 0 || !A.valueTyped[E] || N(i, E) || z(a[e], r, t) && (s ??= []).push(e);
|
|
1320
1327
|
}
|
|
1321
|
-
return
|
|
1322
|
-
},
|
|
1328
|
+
return s;
|
|
1329
|
+
}, ee = (e) => ({
|
|
1323
1330
|
type: "prefix",
|
|
1324
1331
|
value: "@",
|
|
1325
1332
|
inputs: [e],
|
|
1326
1333
|
isReference: !0
|
|
1327
|
-
}),
|
|
1334
|
+
}), re = (e, r) => {
|
|
1328
1335
|
if (!e) return !1;
|
|
1329
1336
|
const t = /* @__PURE__ */ new Set();
|
|
1330
|
-
if (
|
|
1337
|
+
if (J(e, r, t, !0)) return !0;
|
|
1331
1338
|
let n = !1;
|
|
1332
|
-
const E = (e,
|
|
1339
|
+
const E = (e, a, o) => {
|
|
1333
1340
|
if (n || !e) return;
|
|
1334
1341
|
if ("call" === e.type) {
|
|
1335
1342
|
const t = e.inputs?.[0], E = "named" === t?.type ? t.value : null;
|
|
1336
1343
|
if (!E?.name || null !== r.getNamedRoot(E.name, E.scope)) return void (n = !0);
|
|
1337
1344
|
}
|
|
1338
|
-
if (
|
|
1345
|
+
if (j(e, r, t, a, o)) return void (n = !0);
|
|
1339
1346
|
const T = e.inputs;
|
|
1340
1347
|
if (!T) return;
|
|
1341
|
-
const s =
|
|
1348
|
+
const s = Q(e, r, a), i = Z(e, r, o);
|
|
1342
1349
|
for (let e = 0; e < T.length && !n; e++) T[e] && E(T[e], s(e), i(e));
|
|
1343
1350
|
};
|
|
1344
1351
|
return E(e, !1, !0), n;
|
|
1345
1352
|
};
|
|
1346
|
-
function
|
|
1353
|
+
function te(e) {
|
|
1347
1354
|
const r = (e) => {
|
|
1348
1355
|
const r = e.type;
|
|
1349
1356
|
if ("function" === r) {
|
|
1350
|
-
const r = String(e.value ?? ""), t =
|
|
1357
|
+
const r = String(e.value ?? ""), t = F(r), n = t.toUpperCase(), E = e.inputs;
|
|
1351
1358
|
if ("SINGLE" === n && 1 === E?.length) return {
|
|
1352
1359
|
type: "prefix",
|
|
1353
1360
|
value: "@",
|
|
@@ -1360,12 +1367,12 @@ function w(e) {
|
|
|
1360
1367
|
inputs: [E[0]],
|
|
1361
1368
|
isReference: !0
|
|
1362
1369
|
};
|
|
1363
|
-
const
|
|
1364
|
-
if (
|
|
1370
|
+
const a = G.get(n);
|
|
1371
|
+
if (a && 1 === E?.length && 2 === E[0]?.inputs?.length) {
|
|
1365
1372
|
const e = E[0];
|
|
1366
1373
|
return {
|
|
1367
1374
|
type: "infix",
|
|
1368
|
-
value:
|
|
1375
|
+
value: a,
|
|
1369
1376
|
inputs: [e.inputs[0], e.inputs[1]],
|
|
1370
1377
|
isReference: e.isReference ?? !0
|
|
1371
1378
|
};
|
|
@@ -1376,8 +1383,8 @@ function w(e) {
|
|
|
1376
1383
|
};
|
|
1377
1384
|
} else if ("named" === r) {
|
|
1378
1385
|
const r = e.value, t = r?.name ?? "";
|
|
1379
|
-
if (
|
|
1380
|
-
const n =
|
|
1386
|
+
if (y(t, "_xlop.")) {
|
|
1387
|
+
const n = F(t.substring(6));
|
|
1381
1388
|
return {
|
|
1382
1389
|
...e,
|
|
1383
1390
|
value: {
|
|
@@ -1387,7 +1394,7 @@ function w(e) {
|
|
|
1387
1394
|
}
|
|
1388
1395
|
};
|
|
1389
1396
|
}
|
|
1390
|
-
const n =
|
|
1397
|
+
const n = F(t);
|
|
1391
1398
|
if (n !== t) return {
|
|
1392
1399
|
...e,
|
|
1393
1400
|
value: {
|
|
@@ -1396,42 +1403,42 @@ function w(e) {
|
|
|
1396
1403
|
}
|
|
1397
1404
|
};
|
|
1398
1405
|
}
|
|
1399
|
-
}, t =
|
|
1406
|
+
}, t = h(e);
|
|
1400
1407
|
return (e, n) => {
|
|
1401
1408
|
const E = r(e, n) ?? e;
|
|
1402
1409
|
return void 0 !== n ? E === e ? void 0 : E : "function" === E.type && String(E.value).toUpperCase() === "__sxl.INTERSECT".toUpperCase() && 1 === E.inputs?.length ? ((e, r) => {
|
|
1403
1410
|
if (!e) return e;
|
|
1404
|
-
const t = /* @__PURE__ */ new Set(), n = (e, E,
|
|
1405
|
-
const
|
|
1411
|
+
const t = /* @__PURE__ */ new Set(), n = (e, E, a) => {
|
|
1412
|
+
const o = e.inputs;
|
|
1406
1413
|
let T = e;
|
|
1407
|
-
if (
|
|
1408
|
-
const t =
|
|
1414
|
+
if (o) {
|
|
1415
|
+
const t = Q(e, r, E), s = Z(e, r, a);
|
|
1409
1416
|
let i;
|
|
1410
|
-
for (let e = 0; e <
|
|
1411
|
-
const r =
|
|
1417
|
+
for (let e = 0; e < o.length; e++) {
|
|
1418
|
+
const r = o[e];
|
|
1412
1419
|
if (!r) continue;
|
|
1413
1420
|
const E = n(r, t(e), s(e));
|
|
1414
|
-
E !== r && (i || (i = [...
|
|
1421
|
+
E !== r && (i || (i = [...o]), i[e] = E);
|
|
1415
1422
|
}
|
|
1416
1423
|
i && (T = {
|
|
1417
1424
|
...e,
|
|
1418
1425
|
inputs: i
|
|
1419
1426
|
});
|
|
1420
1427
|
}
|
|
1421
|
-
const s =
|
|
1428
|
+
const s = j(T, r, t, E, a);
|
|
1422
1429
|
if (!s) return T;
|
|
1423
1430
|
const i = [...T.inputs];
|
|
1424
|
-
for (const e of s) i[e] =
|
|
1431
|
+
for (const e of s) i[e] = ee(i[e]);
|
|
1425
1432
|
return {
|
|
1426
1433
|
...T,
|
|
1427
1434
|
inputs: i
|
|
1428
1435
|
};
|
|
1429
1436
|
}, E = n(e, !1, !0);
|
|
1430
|
-
return
|
|
1437
|
+
return J(E, r, t, !0) ? ee(E) : E;
|
|
1431
1438
|
})(E.inputs[0], t) : E === e ? void 0 : E;
|
|
1432
1439
|
};
|
|
1433
1440
|
}
|
|
1434
|
-
var
|
|
1441
|
+
var ne = 67108864, Ee = class {
|
|
1435
1442
|
constructor(e) {
|
|
1436
1443
|
this._structurallyChanged = !1, this._parts = e;
|
|
1437
1444
|
let r = 0;
|
|
@@ -1456,17 +1463,17 @@ var b = 67108864, $ = class {
|
|
|
1456
1463
|
markStructuralChange() {
|
|
1457
1464
|
this._structurallyChanged = !0;
|
|
1458
1465
|
}
|
|
1459
|
-
},
|
|
1460
|
-
function
|
|
1461
|
-
return e ?
|
|
1466
|
+
}, ae = /* @__PURE__ */ new WeakMap();
|
|
1467
|
+
function oe(e) {
|
|
1468
|
+
return e ? ae.get(e) ?? null : null;
|
|
1462
1469
|
}
|
|
1463
|
-
function
|
|
1464
|
-
|
|
1470
|
+
function Te(e, r) {
|
|
1471
|
+
ae.set(e, r);
|
|
1465
1472
|
}
|
|
1466
|
-
function
|
|
1467
|
-
e &&
|
|
1473
|
+
function se(e) {
|
|
1474
|
+
e && ae.delete(e);
|
|
1468
1475
|
}
|
|
1469
|
-
var
|
|
1476
|
+
var ie = /* @__PURE__ */ new Set([
|
|
1470
1477
|
"A1.R1C1",
|
|
1471
1478
|
"ABSREF",
|
|
1472
1479
|
"ACTIVATE",
|
|
@@ -1970,31 +1977,31 @@ var J = /* @__PURE__ */ new Set([
|
|
|
1970
1977
|
"WORKGROUP.OPTIONS",
|
|
1971
1978
|
"WORKSPACE",
|
|
1972
1979
|
"ZOOM"
|
|
1973
|
-
]),
|
|
1980
|
+
]), pe = "__xludf.DUMMYFUNCTION", Ae = "\"COMPUTED_VALUE\"", ce = (e) => `"${e.replace(/"/g, "\"\"")}"`, Se = (r) => {
|
|
1974
1981
|
if (null == r) return "\"\"";
|
|
1975
1982
|
if ("number" == typeof r) return Number.isFinite(r) ? "" + r : null;
|
|
1976
1983
|
if ("boolean" == typeof r) return r ? "TRUE" : "FALSE";
|
|
1977
|
-
if ("string" == typeof r) return
|
|
1984
|
+
if ("string" == typeof r) return ce(r);
|
|
1978
1985
|
const t = r;
|
|
1979
1986
|
if ("function" == typeof t?.getCode) {
|
|
1980
1987
|
const r = t.getCode();
|
|
1981
1988
|
return r < 1 ? null : r > 7 ? e.BuiltIn.Value.getLabel() : t.getLabel();
|
|
1982
1989
|
}
|
|
1983
1990
|
return null;
|
|
1984
|
-
},
|
|
1985
|
-
const t =
|
|
1986
|
-
return null === t ? null : `IFERROR(${
|
|
1987
|
-
},
|
|
1988
|
-
const r =
|
|
1989
|
-
return null === r ? null : `IFERROR(${
|
|
1990
|
-
},
|
|
1991
|
+
}, Oe = (e, r) => {
|
|
1992
|
+
const t = Se(r);
|
|
1993
|
+
return null === t ? null : `IFERROR(${pe}(${ce(e)}),${t})`;
|
|
1994
|
+
}, Re = (e) => {
|
|
1995
|
+
const r = Se(e);
|
|
1996
|
+
return null === r ? null : `IFERROR(${pe}(${ce(Ae)}),${r})`;
|
|
1997
|
+
}, ue = async (e, r) => {
|
|
1991
1998
|
const t = /* @__PURE__ */ new Set();
|
|
1992
1999
|
if (0 === r.size) return t;
|
|
1993
2000
|
const n = e.getCalculation().getFunctions();
|
|
1994
2001
|
for (const e of r) {
|
|
1995
2002
|
const r = n.getByName(e);
|
|
1996
2003
|
if (!r) {
|
|
1997
|
-
|
|
2004
|
+
ie.has(e.toUpperCase()) && t.add(e.toUpperCase());
|
|
1998
2005
|
continue;
|
|
1999
2006
|
}
|
|
2000
2007
|
if (!r.isBuiltIn()) {
|
|
@@ -2005,7 +2012,7 @@ var J = /* @__PURE__ */ new Set([
|
|
|
2005
2012
|
"Sheets" !== E && "SheetXL" !== E || t.add(e.toUpperCase());
|
|
2006
2013
|
}
|
|
2007
2014
|
return t;
|
|
2008
|
-
},
|
|
2015
|
+
}, Ie = (e) => -1 === e.indexOf("_x") ? e : e.replace(/_x([0-9A-Fa-f]{4})_/g, (e, r) => String.fromCharCode(parseInt(r, 16))), le = (e) => Ne(e) ? e.replace(/(_x[0-9A-Fa-f]{4}_)/g, "_x005F$1").replace(/[\x00-\x08\x0B-\x1F]/g, (e) => `_x${e.charCodeAt(0).toString(16).toUpperCase().padStart(4, "0")}_`) : e, Ne = (e) => {
|
|
2009
2016
|
const r = e.length;
|
|
2010
2017
|
for (let t = 0; t < r; t++) {
|
|
2011
2018
|
const n = e.charCodeAt(t);
|
|
@@ -2016,19 +2023,19 @@ var J = /* @__PURE__ */ new Set([
|
|
|
2016
2023
|
}
|
|
2017
2024
|
}
|
|
2018
2025
|
return !1;
|
|
2019
|
-
},
|
|
2020
|
-
function
|
|
2026
|
+
}, Le = /^\s|\s$/, fe = { "xml:space": "preserve" };
|
|
2027
|
+
function Ce(e) {
|
|
2021
2028
|
if (void 0 === e) return;
|
|
2022
2029
|
if (0 === e.trim().length) return e;
|
|
2023
2030
|
const r = t(e);
|
|
2024
2031
|
return void 0 !== r ? r : "=" + e;
|
|
2025
2032
|
}
|
|
2026
|
-
function
|
|
2033
|
+
function De(r) {
|
|
2027
2034
|
if (null == r) return;
|
|
2028
2035
|
if ("number" == typeof r) return String(r);
|
|
2029
2036
|
if ("boolean" == typeof r) return r ? "TRUE" : "FALSE";
|
|
2030
2037
|
if (e.isError(r)) return r.getLabel();
|
|
2031
|
-
if ("string" == typeof r) return r.startsWith("=") ? r.slice(1) :
|
|
2038
|
+
if ("string" == typeof r) return r.startsWith("=") ? r.slice(1) : Me(r);
|
|
2032
2039
|
const t = r;
|
|
2033
2040
|
if ("e" === t.t && "number" == typeof t.v) {
|
|
2034
2041
|
const r = e.getBuiltInByCode(t.v);
|
|
@@ -2036,50 +2043,50 @@ function Ae(r) {
|
|
|
2036
2043
|
}
|
|
2037
2044
|
return String(r);
|
|
2038
2045
|
}
|
|
2039
|
-
function
|
|
2046
|
+
function Me(e) {
|
|
2040
2047
|
return `"${e.split("\"").join("\"\"")}"`;
|
|
2041
2048
|
}
|
|
2042
|
-
var
|
|
2043
|
-
equal: { operator:
|
|
2049
|
+
var Pe = "aboveAverage", ye = "beginsWith", me = "cellIs", ve = "colorScale", xe = "containsBlanks", Ue = "containsErrors", Be = "containsText", Fe = "dataBar", Ge = "duplicateValues", ge = "endsWith", de = "expression", Ve = "iconSet", he = "notContainsBlanks", He = "notContainsErrors", We = "notContainsText", Ye = "timePeriod", Ke = "top10", Xe = "uniqueValues", _e = r.BuiltInOperatorNames, be = {
|
|
2050
|
+
equal: { operator: _e.EqualTo },
|
|
2044
2051
|
notEqual: {
|
|
2045
|
-
operator:
|
|
2052
|
+
operator: _e.EqualTo,
|
|
2046
2053
|
negate: !0
|
|
2047
2054
|
},
|
|
2048
|
-
greaterThan: { operator:
|
|
2049
|
-
greaterThanOrEqual: { operator:
|
|
2050
|
-
lessThan: { operator:
|
|
2051
|
-
lessThanOrEqual: { operator:
|
|
2052
|
-
between: { operator:
|
|
2055
|
+
greaterThan: { operator: _e.GreaterThan },
|
|
2056
|
+
greaterThanOrEqual: { operator: _e.GreaterThanEqualTo },
|
|
2057
|
+
lessThan: { operator: _e.LessThan },
|
|
2058
|
+
lessThanOrEqual: { operator: _e.LessThanEqualTo },
|
|
2059
|
+
between: { operator: _e.Between },
|
|
2053
2060
|
notBetween: {
|
|
2054
|
-
operator:
|
|
2061
|
+
operator: _e.Between,
|
|
2055
2062
|
negate: !0
|
|
2056
2063
|
}
|
|
2057
|
-
},
|
|
2058
|
-
[
|
|
2064
|
+
}, we = {
|
|
2065
|
+
[_e.EqualTo]: {
|
|
2059
2066
|
plain: "equal",
|
|
2060
2067
|
negated: "notEqual"
|
|
2061
2068
|
},
|
|
2062
|
-
[
|
|
2069
|
+
[_e.GreaterThan]: {
|
|
2063
2070
|
plain: "greaterThan",
|
|
2064
2071
|
negated: ""
|
|
2065
2072
|
},
|
|
2066
|
-
[
|
|
2073
|
+
[_e.GreaterThanEqualTo]: {
|
|
2067
2074
|
plain: "greaterThanOrEqual",
|
|
2068
2075
|
negated: ""
|
|
2069
2076
|
},
|
|
2070
|
-
[
|
|
2077
|
+
[_e.LessThan]: {
|
|
2071
2078
|
plain: "lessThan",
|
|
2072
2079
|
negated: ""
|
|
2073
2080
|
},
|
|
2074
|
-
[
|
|
2081
|
+
[_e.LessThanEqualTo]: {
|
|
2075
2082
|
plain: "lessThanOrEqual",
|
|
2076
2083
|
negated: ""
|
|
2077
2084
|
},
|
|
2078
|
-
[
|
|
2085
|
+
[_e.Between]: {
|
|
2079
2086
|
plain: "between",
|
|
2080
2087
|
negated: "notBetween"
|
|
2081
2088
|
}
|
|
2082
|
-
},
|
|
2089
|
+
}, qe = /* @__PURE__ */ new Set([
|
|
2083
2090
|
"today",
|
|
2084
2091
|
"yesterday",
|
|
2085
2092
|
"tomorrow",
|
|
@@ -2091,323 +2098,384 @@ var Oe = "aboveAverage", ce = "beginsWith", Re = "cellIs", Ie = "colorScale", ue
|
|
|
2091
2098
|
"lastWeek",
|
|
2092
2099
|
"nextWeek"
|
|
2093
2100
|
]);
|
|
2094
|
-
function
|
|
2095
|
-
return
|
|
2101
|
+
function $e(e) {
|
|
2102
|
+
return Ce(e);
|
|
2096
2103
|
}
|
|
2097
|
-
function
|
|
2098
|
-
return
|
|
2104
|
+
function ke(e) {
|
|
2105
|
+
return De(e) ?? "";
|
|
2099
2106
|
}
|
|
2100
|
-
function
|
|
2107
|
+
function Qe(e, r) {
|
|
2101
2108
|
return r ? {
|
|
2102
|
-
operator:
|
|
2109
|
+
operator: _e.Not,
|
|
2103
2110
|
param: e
|
|
2104
2111
|
} : e;
|
|
2105
2112
|
}
|
|
2106
|
-
function
|
|
2113
|
+
function Ze(e, t) {
|
|
2107
2114
|
const n = e.type;
|
|
2108
2115
|
if (!n) return null;
|
|
2109
2116
|
const E = e.formulas ?? [];
|
|
2110
2117
|
switch (n) {
|
|
2111
|
-
case
|
|
2112
|
-
case
|
|
2113
|
-
case
|
|
2114
|
-
case
|
|
2115
|
-
const r = e.operator ?
|
|
2118
|
+
case ve:
|
|
2119
|
+
case Fe:
|
|
2120
|
+
case Ve: return null;
|
|
2121
|
+
case me: {
|
|
2122
|
+
const r = e.operator ? be[e.operator] : void 0;
|
|
2116
2123
|
if (!r) return t?.(`Conditional format operator '${e.operator}' is not a known cellIs operator.`), null;
|
|
2117
|
-
const n = r.operator ===
|
|
2118
|
-
from:
|
|
2119
|
-
to:
|
|
2120
|
-
} :
|
|
2121
|
-
return
|
|
2124
|
+
const n = r.operator === _e.Between ? {
|
|
2125
|
+
from: $e(E[0]),
|
|
2126
|
+
to: $e(E[1])
|
|
2127
|
+
} : $e(E[0]);
|
|
2128
|
+
return Qe({
|
|
2122
2129
|
operator: r.operator,
|
|
2123
2130
|
param: n
|
|
2124
2131
|
}, r.negate);
|
|
2125
2132
|
}
|
|
2126
|
-
case
|
|
2127
|
-
operator:
|
|
2133
|
+
case de: return {
|
|
2134
|
+
operator: _e.Expression,
|
|
2128
2135
|
param: E[0] ?? ""
|
|
2129
2136
|
};
|
|
2130
|
-
case
|
|
2131
|
-
operator:
|
|
2137
|
+
case Be: return {
|
|
2138
|
+
operator: _e.TextContains,
|
|
2132
2139
|
param: e.text
|
|
2133
2140
|
};
|
|
2134
|
-
case
|
|
2135
|
-
operator:
|
|
2141
|
+
case We: return Qe({
|
|
2142
|
+
operator: _e.TextContains,
|
|
2136
2143
|
param: e.text
|
|
2137
2144
|
}, !0);
|
|
2138
|
-
case
|
|
2139
|
-
operator:
|
|
2145
|
+
case ye: return {
|
|
2146
|
+
operator: _e.TextStartsWith,
|
|
2140
2147
|
param: e.text
|
|
2141
2148
|
};
|
|
2142
|
-
case
|
|
2143
|
-
operator:
|
|
2149
|
+
case ge: return {
|
|
2150
|
+
operator: _e.TextEndsWith,
|
|
2144
2151
|
param: e.text
|
|
2145
2152
|
};
|
|
2146
|
-
case
|
|
2147
|
-
case
|
|
2148
|
-
case
|
|
2149
|
-
case
|
|
2150
|
-
case
|
|
2151
|
-
case
|
|
2152
|
-
case
|
|
2153
|
+
case xe: return { operator: _e.Blank };
|
|
2154
|
+
case he: return Qe({ operator: _e.Blank }, !0);
|
|
2155
|
+
case Ue: return { operator: _e.Error };
|
|
2156
|
+
case He: return Qe({ operator: _e.Error }, !0);
|
|
2157
|
+
case Xe: return { operator: _e.Unique };
|
|
2158
|
+
case Ge: return Qe({ operator: _e.Unique }, !0);
|
|
2159
|
+
case Ye: {
|
|
2153
2160
|
const r = {};
|
|
2154
2161
|
return e.timePeriod && (r.type = e.timePeriod), {
|
|
2155
|
-
operator:
|
|
2162
|
+
operator: _e.TimePeriod,
|
|
2156
2163
|
param: r
|
|
2157
2164
|
};
|
|
2158
2165
|
}
|
|
2159
|
-
case
|
|
2166
|
+
case Ke: {
|
|
2160
2167
|
const r = {
|
|
2161
2168
|
top: !e.bottom,
|
|
2162
2169
|
percent: e.percent ?? !1
|
|
2163
2170
|
};
|
|
2164
2171
|
return void 0 !== e.rank && (r.limit = e.rank), {
|
|
2165
|
-
operator:
|
|
2172
|
+
operator: _e.TopN,
|
|
2166
2173
|
param: r
|
|
2167
2174
|
};
|
|
2168
2175
|
}
|
|
2169
|
-
case
|
|
2176
|
+
case Pe: {
|
|
2170
2177
|
const t = e.aboveAverage ?? !0, n = e.equalAverage ?? !1, E = { type: t ? n ? r.AverageType.AboveOrEqual : r.AverageType.Above : n ? r.AverageType.BelowOrEqual : r.AverageType.Below };
|
|
2171
2178
|
return void 0 !== e.stdDev && (E.stdDevs = e.stdDev), {
|
|
2172
|
-
operator:
|
|
2179
|
+
operator: _e.Average,
|
|
2173
2180
|
param: E
|
|
2174
2181
|
};
|
|
2175
2182
|
}
|
|
2176
2183
|
default: return t?.(`Conditional format type '${n}' has no condition mapping.`), null;
|
|
2177
2184
|
}
|
|
2178
2185
|
}
|
|
2179
|
-
function
|
|
2186
|
+
function Je(e, t, n) {
|
|
2180
2187
|
if (!e) return null;
|
|
2181
|
-
const E = e.operator ===
|
|
2182
|
-
if (!
|
|
2183
|
-
const s =
|
|
2188
|
+
const E = e.operator === _e.Not, a = (E ? e.param : e) ?? {}, o = a.operator, T = a.param;
|
|
2189
|
+
if (!o) return null;
|
|
2190
|
+
const s = we[o];
|
|
2184
2191
|
if (s) {
|
|
2185
2192
|
const e = E ? s.negated : s.plain;
|
|
2186
|
-
if (!e) return n?.(`Conditional format operator 'not(${
|
|
2193
|
+
if (!e) return n?.(`Conditional format operator 'not(${o})' has no OOXML form.`), null;
|
|
2187
2194
|
return {
|
|
2188
|
-
type:
|
|
2195
|
+
type: me,
|
|
2189
2196
|
operator: e,
|
|
2190
|
-
formulas:
|
|
2197
|
+
formulas: o === _e.Between ? [ke(T?.from), ke(T?.to)] : [ke(T)]
|
|
2191
2198
|
};
|
|
2192
2199
|
}
|
|
2193
|
-
switch (
|
|
2194
|
-
case
|
|
2200
|
+
switch (o) {
|
|
2201
|
+
case _e.Expression:
|
|
2195
2202
|
if (E) break;
|
|
2196
2203
|
return {
|
|
2197
|
-
type:
|
|
2204
|
+
type: de,
|
|
2198
2205
|
formulas: [null == T ? "" : String(T)]
|
|
2199
2206
|
};
|
|
2200
|
-
case
|
|
2207
|
+
case _e.TextContains: {
|
|
2201
2208
|
const e = String(T ?? "");
|
|
2202
2209
|
return E ? {
|
|
2203
|
-
type:
|
|
2210
|
+
type: We,
|
|
2204
2211
|
text: e,
|
|
2205
|
-
formulas: [`ISERROR(SEARCH(${
|
|
2212
|
+
formulas: [`ISERROR(SEARCH(${Me(e)},${t}))`]
|
|
2206
2213
|
} : {
|
|
2207
|
-
type:
|
|
2214
|
+
type: Be,
|
|
2208
2215
|
text: e,
|
|
2209
|
-
formulas: [`NOT(ISERROR(SEARCH(${
|
|
2216
|
+
formulas: [`NOT(ISERROR(SEARCH(${Me(e)},${t})))`]
|
|
2210
2217
|
};
|
|
2211
2218
|
}
|
|
2212
|
-
case
|
|
2219
|
+
case _e.TextStartsWith: {
|
|
2213
2220
|
if (E) break;
|
|
2214
2221
|
const e = String(T ?? "");
|
|
2215
2222
|
return {
|
|
2216
|
-
type:
|
|
2223
|
+
type: ye,
|
|
2217
2224
|
text: e,
|
|
2218
|
-
formulas: [`LEFT(${t},LEN(${
|
|
2225
|
+
formulas: [`LEFT(${t},LEN(${Me(e)}))=${Me(e)}`]
|
|
2219
2226
|
};
|
|
2220
2227
|
}
|
|
2221
|
-
case
|
|
2228
|
+
case _e.TextEndsWith: {
|
|
2222
2229
|
if (E) break;
|
|
2223
2230
|
const e = String(T ?? "");
|
|
2224
2231
|
return {
|
|
2225
|
-
type:
|
|
2232
|
+
type: ge,
|
|
2226
2233
|
text: e,
|
|
2227
|
-
formulas: [`RIGHT(${t},LEN(${
|
|
2234
|
+
formulas: [`RIGHT(${t},LEN(${Me(e)}))=${Me(e)}`]
|
|
2228
2235
|
};
|
|
2229
2236
|
}
|
|
2230
|
-
case
|
|
2231
|
-
type:
|
|
2237
|
+
case _e.Blank: return E ? {
|
|
2238
|
+
type: he,
|
|
2232
2239
|
formulas: [`LEN(TRIM(${t}))>0`]
|
|
2233
2240
|
} : {
|
|
2234
|
-
type:
|
|
2241
|
+
type: xe,
|
|
2235
2242
|
formulas: [`LEN(TRIM(${t}))=0`]
|
|
2236
2243
|
};
|
|
2237
|
-
case
|
|
2238
|
-
type:
|
|
2244
|
+
case _e.Error: return E ? {
|
|
2245
|
+
type: He,
|
|
2239
2246
|
formulas: [`NOT(ISERROR(${t}))`]
|
|
2240
2247
|
} : {
|
|
2241
|
-
type:
|
|
2248
|
+
type: Ue,
|
|
2242
2249
|
formulas: [`ISERROR(${t})`]
|
|
2243
2250
|
};
|
|
2244
|
-
case
|
|
2245
|
-
case
|
|
2251
|
+
case _e.Unique: return { type: E ? Ge : Xe };
|
|
2252
|
+
case _e.TimePeriod: {
|
|
2246
2253
|
if (E) break;
|
|
2247
2254
|
const e = T?.type;
|
|
2248
|
-
return e && !
|
|
2249
|
-
type:
|
|
2255
|
+
return e && !qe.has(e) ? (n?.(`Conditional format time period '${e}' has no OOXML form; rule skipped.`), null) : {
|
|
2256
|
+
type: Ye,
|
|
2250
2257
|
timePeriod: e
|
|
2251
2258
|
};
|
|
2252
2259
|
}
|
|
2253
|
-
case
|
|
2260
|
+
case _e.TopN: {
|
|
2254
2261
|
if (E) break;
|
|
2255
2262
|
const e = T ?? {};
|
|
2256
2263
|
return {
|
|
2257
|
-
type:
|
|
2264
|
+
type: Ke,
|
|
2258
2265
|
bottom: !(e.top ?? 1),
|
|
2259
2266
|
percent: e.percent ?? !1,
|
|
2260
2267
|
rank: e.limit
|
|
2261
2268
|
};
|
|
2262
2269
|
}
|
|
2263
|
-
case
|
|
2270
|
+
case _e.Average: {
|
|
2264
2271
|
if (E) break;
|
|
2265
2272
|
const e = T ?? {}, t = e.type ?? r.AverageType.Above;
|
|
2266
2273
|
return {
|
|
2267
|
-
type:
|
|
2274
|
+
type: Pe,
|
|
2268
2275
|
aboveAverage: t === r.AverageType.Above || t === r.AverageType.AboveOrEqual,
|
|
2269
2276
|
equalAverage: t === r.AverageType.AboveOrEqual || t === r.AverageType.BelowOrEqual,
|
|
2270
2277
|
stdDev: e.stdDevs
|
|
2271
2278
|
};
|
|
2272
2279
|
}
|
|
2273
2280
|
}
|
|
2274
|
-
return n?.(`Conditional format operator '${E ? `not(${
|
|
2281
|
+
return n?.(`Conditional format operator '${E ? `not(${o})` : o}' has no OOXML form.`), null;
|
|
2282
|
+
}
|
|
2283
|
+
var ze = "equal", je = "notEqual", er = "greaterThan", rr = "greaterThanOrEqual", tr = "lessThan", nr = "lessThanOrEqual", Er = r.BuiltInOperatorNames, ar = {
|
|
2284
|
+
[ze]: { operator: Er.EqualTo },
|
|
2285
|
+
[je]: {
|
|
2286
|
+
operator: Er.EqualTo,
|
|
2287
|
+
negate: !0
|
|
2288
|
+
},
|
|
2289
|
+
[er]: { operator: Er.GreaterThan },
|
|
2290
|
+
[rr]: { operator: Er.GreaterThanEqualTo },
|
|
2291
|
+
[tr]: { operator: Er.LessThan },
|
|
2292
|
+
[nr]: { operator: Er.LessThanEqualTo }
|
|
2293
|
+
}, or = {
|
|
2294
|
+
[Er.EqualTo]: {
|
|
2295
|
+
plain: ze,
|
|
2296
|
+
negated: je
|
|
2297
|
+
},
|
|
2298
|
+
[Er.GreaterThan]: {
|
|
2299
|
+
plain: er,
|
|
2300
|
+
negated: nr
|
|
2301
|
+
},
|
|
2302
|
+
[Er.GreaterThanEqualTo]: {
|
|
2303
|
+
plain: rr,
|
|
2304
|
+
negated: tr
|
|
2305
|
+
},
|
|
2306
|
+
[Er.LessThan]: {
|
|
2307
|
+
plain: tr,
|
|
2308
|
+
negated: rr
|
|
2309
|
+
},
|
|
2310
|
+
[Er.LessThanEqualTo]: {
|
|
2311
|
+
plain: nr,
|
|
2312
|
+
negated: er
|
|
2313
|
+
}
|
|
2314
|
+
};
|
|
2315
|
+
function Tr(e) {
|
|
2316
|
+
return "string" == typeof e && void 0 !== or[e];
|
|
2317
|
+
}
|
|
2318
|
+
function sr(e) {
|
|
2319
|
+
if (null != e) return "" + e;
|
|
2275
2320
|
}
|
|
2276
|
-
|
|
2277
|
-
|
|
2278
|
-
|
|
2279
|
-
|
|
2280
|
-
|
|
2281
|
-
|
|
2282
|
-
|
|
2283
|
-
|
|
2284
|
-
|
|
2285
|
-
|
|
2286
|
-
|
|
2287
|
-
|
|
2288
|
-
|
|
2289
|
-
|
|
2290
|
-
|
|
2321
|
+
function ir(e, r) {
|
|
2322
|
+
const t = function(e) {
|
|
2323
|
+
if (null == e || "" === e) return e ?? void 0;
|
|
2324
|
+
const r = Number(e);
|
|
2325
|
+
return Number.isFinite(r) ? r : e;
|
|
2326
|
+
}(e.val);
|
|
2327
|
+
if (void 0 === t) return null;
|
|
2328
|
+
const n = e.operator ?? ze, E = ar[n];
|
|
2329
|
+
if (!E) return r?.(`AutoFilter operator '${n}' has no mapping; the rule is carried but inert.`), {
|
|
2330
|
+
operator: n,
|
|
2331
|
+
param: t
|
|
2332
|
+
};
|
|
2333
|
+
const a = {
|
|
2334
|
+
operator: E.operator,
|
|
2335
|
+
param: t
|
|
2336
|
+
};
|
|
2337
|
+
return E.negate ? {
|
|
2338
|
+
operator: Er.Not,
|
|
2339
|
+
param: a
|
|
2340
|
+
} : a;
|
|
2341
|
+
}
|
|
2342
|
+
function pr(e, r) {
|
|
2343
|
+
if (!e) return null;
|
|
2344
|
+
const t = e.operator === Er.Not, n = (t ? e.param : e) ?? {}, E = n.operator;
|
|
2345
|
+
if (!E) return null;
|
|
2346
|
+
const a = or[E];
|
|
2347
|
+
return a ? {
|
|
2348
|
+
operator: t ? a.negated : a.plain,
|
|
2349
|
+
val: sr(n.param)
|
|
2350
|
+
} : !t && ar[E] ? {
|
|
2351
|
+
operator: E,
|
|
2352
|
+
val: sr(n.param)
|
|
2353
|
+
} : (r?.(`AutoFilter operator '${t ? `not(${E})` : E}' has no OOXML form.`), null);
|
|
2354
|
+
}
|
|
2355
|
+
var Ar = "custom", cr = "date", Sr = "decimal", Or = "list", Rr = "none", ur = "textLength", Ir = "time", lr = "whole", Nr = r.BuiltInOperatorNames, Lr = r.BuiltInSelectorNames, fr = {
|
|
2356
|
+
[lr]: Lr.Whole,
|
|
2357
|
+
[Sr]: Lr.Number,
|
|
2358
|
+
[cr]: Lr.Date,
|
|
2359
|
+
[Ir]: Lr.Time,
|
|
2360
|
+
[ur]: Lr.TextLength
|
|
2361
|
+
}, Cr = {
|
|
2362
|
+
[Lr.Whole]: lr,
|
|
2363
|
+
[Lr.Number]: Sr,
|
|
2364
|
+
[Lr.Date]: cr,
|
|
2365
|
+
[Lr.DateTime]: cr,
|
|
2366
|
+
[Lr.Time]: Ir,
|
|
2367
|
+
[Lr.TextLength]: ur
|
|
2368
|
+
}, Dr = {
|
|
2369
|
+
between: { operator: Nr.Between },
|
|
2291
2370
|
notBetween: {
|
|
2292
|
-
operator:
|
|
2371
|
+
operator: Nr.Between,
|
|
2293
2372
|
negate: !0
|
|
2294
2373
|
},
|
|
2295
|
-
equal: { operator:
|
|
2374
|
+
equal: { operator: Nr.EqualTo },
|
|
2296
2375
|
notEqual: {
|
|
2297
|
-
operator:
|
|
2376
|
+
operator: Nr.EqualTo,
|
|
2298
2377
|
negate: !0
|
|
2299
2378
|
},
|
|
2300
|
-
greaterThan: { operator:
|
|
2301
|
-
greaterThanOrEqual: { operator:
|
|
2302
|
-
lessThan: { operator:
|
|
2303
|
-
lessThanOrEqual: { operator:
|
|
2304
|
-
},
|
|
2305
|
-
[
|
|
2379
|
+
greaterThan: { operator: Nr.GreaterThan },
|
|
2380
|
+
greaterThanOrEqual: { operator: Nr.GreaterThanEqualTo },
|
|
2381
|
+
lessThan: { operator: Nr.LessThan },
|
|
2382
|
+
lessThanOrEqual: { operator: Nr.LessThanEqualTo }
|
|
2383
|
+
}, Mr = {
|
|
2384
|
+
[Nr.Between]: {
|
|
2306
2385
|
plain: "between",
|
|
2307
2386
|
negated: "notBetween"
|
|
2308
2387
|
},
|
|
2309
|
-
[
|
|
2388
|
+
[Nr.EqualTo]: {
|
|
2310
2389
|
plain: "equal",
|
|
2311
2390
|
negated: "notEqual"
|
|
2312
2391
|
},
|
|
2313
|
-
[
|
|
2392
|
+
[Nr.GreaterThan]: {
|
|
2314
2393
|
plain: "greaterThan",
|
|
2315
2394
|
negated: ""
|
|
2316
2395
|
},
|
|
2317
|
-
[
|
|
2396
|
+
[Nr.GreaterThanEqualTo]: {
|
|
2318
2397
|
plain: "greaterThanOrEqual",
|
|
2319
2398
|
negated: ""
|
|
2320
2399
|
},
|
|
2321
|
-
[
|
|
2400
|
+
[Nr.LessThan]: {
|
|
2322
2401
|
plain: "lessThan",
|
|
2323
2402
|
negated: ""
|
|
2324
2403
|
},
|
|
2325
|
-
[
|
|
2404
|
+
[Nr.LessThanEqualTo]: {
|
|
2326
2405
|
plain: "lessThanOrEqual",
|
|
2327
2406
|
negated: ""
|
|
2328
2407
|
}
|
|
2329
2408
|
};
|
|
2330
|
-
function
|
|
2331
|
-
return r ===
|
|
2409
|
+
function Pr(e, r) {
|
|
2410
|
+
return r === Or || r === Ar ? e : Ce(e);
|
|
2332
2411
|
}
|
|
2333
|
-
function
|
|
2334
|
-
return
|
|
2412
|
+
function yr(e) {
|
|
2413
|
+
return De(e);
|
|
2335
2414
|
}
|
|
2336
|
-
function
|
|
2415
|
+
function mr(e, r) {
|
|
2337
2416
|
const t = e.type;
|
|
2338
|
-
if (!t || t ===
|
|
2339
|
-
if (t ===
|
|
2340
|
-
|
|
2417
|
+
if (!t || t === Rr) return null;
|
|
2418
|
+
if (t === Or) return {
|
|
2419
|
+
selector: Lr.List,
|
|
2420
|
+
operator: Nr.InSet,
|
|
2341
2421
|
param: e.formula1
|
|
2342
2422
|
};
|
|
2343
|
-
if (t ===
|
|
2344
|
-
operator:
|
|
2423
|
+
if (t === Ar) return {
|
|
2424
|
+
operator: Nr.Expression,
|
|
2345
2425
|
param: e.formula1
|
|
2346
2426
|
};
|
|
2347
|
-
const n =
|
|
2427
|
+
const n = fr[t];
|
|
2348
2428
|
if (!n) return r?.(`DataValidation type '${t}' has no selector mapping.`), null;
|
|
2349
|
-
const E = e.operator ?? "between",
|
|
2350
|
-
if (!
|
|
2429
|
+
const E = e.operator ?? "between", a = Dr[E];
|
|
2430
|
+
if (!a) return r?.(`DataValidation operator '${E}' has no mapping; the rule is carried but inert.`), {
|
|
2351
2431
|
selector: n,
|
|
2352
2432
|
operator: E,
|
|
2353
2433
|
param: e.formula1
|
|
2354
2434
|
};
|
|
2355
|
-
const
|
|
2435
|
+
const o = a.operator === Nr.Between ? {
|
|
2356
2436
|
from: e.formula1,
|
|
2357
2437
|
to: e.formula2
|
|
2358
2438
|
} : e.formula1, T = {
|
|
2359
|
-
operator:
|
|
2360
|
-
param:
|
|
2439
|
+
operator: a.operator,
|
|
2440
|
+
param: o
|
|
2361
2441
|
};
|
|
2362
|
-
return
|
|
2442
|
+
return a.negate ? {
|
|
2363
2443
|
selector: n,
|
|
2364
|
-
operator:
|
|
2444
|
+
operator: Nr.Not,
|
|
2365
2445
|
param: T
|
|
2366
2446
|
} : {
|
|
2367
2447
|
selector: n,
|
|
2368
2448
|
...T
|
|
2369
2449
|
};
|
|
2370
2450
|
}
|
|
2371
|
-
function
|
|
2451
|
+
function vr(e, r) {
|
|
2372
2452
|
if (!e) return null;
|
|
2373
|
-
const t = e.operator ===
|
|
2453
|
+
const t = e.operator === Nr.Not, n = (t ? e.param : e) ?? {}, E = n.operator, a = n.param;
|
|
2374
2454
|
if (!E) return null;
|
|
2375
|
-
if (!t && (E ===
|
|
2376
|
-
type:
|
|
2377
|
-
formula1: "string" == typeof
|
|
2455
|
+
if (!t && (E === Nr.InSet || E === Or)) return {
|
|
2456
|
+
type: Or,
|
|
2457
|
+
formula1: "string" == typeof a ? a : Array.isArray(a?.items) ? `"${a.items.join(",")}"` : a?.items
|
|
2378
2458
|
};
|
|
2379
|
-
if (!t && (E ===
|
|
2380
|
-
type:
|
|
2381
|
-
formula1: "string" == typeof
|
|
2459
|
+
if (!t && (E === Nr.Expression || E === Ar)) return {
|
|
2460
|
+
type: Ar,
|
|
2461
|
+
formula1: "string" == typeof a ? a : a?.formula ?? a?.formula1
|
|
2382
2462
|
};
|
|
2383
|
-
const
|
|
2384
|
-
if (!
|
|
2385
|
-
type:
|
|
2463
|
+
const o = Mr[E];
|
|
2464
|
+
if (!o) return !t && Dr[E] ? {
|
|
2465
|
+
type: xr(e.selector),
|
|
2386
2466
|
operator: E,
|
|
2387
|
-
formula1:
|
|
2388
|
-
formula2:
|
|
2467
|
+
formula1: yr(a?.from ?? a),
|
|
2468
|
+
formula2: yr(a?.to)
|
|
2389
2469
|
} : (r?.(`DataValidation operator '${t ? `not(${E})` : E}' has no OOXML form.`), null);
|
|
2390
|
-
const T = t ?
|
|
2470
|
+
const T = t ? o.negated : o.plain;
|
|
2391
2471
|
return T ? {
|
|
2392
|
-
type:
|
|
2472
|
+
type: xr(e.selector),
|
|
2393
2473
|
operator: T,
|
|
2394
|
-
formula1:
|
|
2395
|
-
formula2: E ===
|
|
2474
|
+
formula1: yr(E === Nr.Between ? a?.from : a),
|
|
2475
|
+
formula2: E === Nr.Between ? yr(a?.to) : void 0
|
|
2396
2476
|
} : (r?.(`DataValidation operator 'not(${E})' has no OOXML form.`), null);
|
|
2397
2477
|
}
|
|
2398
|
-
function
|
|
2399
|
-
return (e ?
|
|
2400
|
-
}
|
|
2401
|
-
var or = "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main", ar = "http://schemas.microsoft.com/office/excel/2006/main", Tr = "{CCE6A557-97BC-4b89-ADB6-D9C93CAAB3DF}", sr = "{78C0D931-6437-407d-A8EE-F0AAD7539E65}", ir = "{78C0D931-6839-4c89-B8D6-976A2CC4E5B4}", pr = "{B025F937-C7B1-47D3-B67F-A62EFF666E3E}", Ar = "{A8765BA9-456A-4dab-B4F3-ACF838C121DE}", Sr = "{3A4CF648-6AED-40f4-86FF-DC5316D8AED3}", Or = {
|
|
2402
|
-
"{05C60535-1F16-4FD2-B633-F4F36F0B64E0}": "sparklines",
|
|
2403
|
-
"{7E03D99C-DC04-49D9-9315-930204A7B6E9}": "timelines",
|
|
2404
|
-
"{01252117-D84E-4E92-8308-4BE1C098FCBB}": "ignoredErrors",
|
|
2405
|
-
"{F7C9EE02-42E1-4005-9D12-6889AFFD525C}": "workbook protection extensions"
|
|
2406
|
-
}, cr = /* @__PURE__ */ new Set(["{77BFE23E-C014-4D31-8A63-9C772DBF06B6}"]);
|
|
2407
|
-
function Rr(e) {
|
|
2408
|
-
return (e ?? "").toUpperCase();
|
|
2409
|
-
}
|
|
2410
|
-
function Ir(e) {
|
|
2411
|
-
return `{${e().toUpperCase()}}`;
|
|
2478
|
+
function xr(e) {
|
|
2479
|
+
return (e ? Cr[e] : void 0) ?? Sr;
|
|
2412
2480
|
}
|
|
2413
|
-
export {
|
|
2481
|
+
export { o as A, S as B, d as C, V as D, re as E, n as F, E as I, c as L, a as M, i as N, P as O, p as P, A as R, Te as S, te as T, Re as _, Tr as a, oe as b, Ze as c, Ie as d, le as f, Oe as g, ue as h, pr as i, T as j, s as k, fe as l, pe as m, vr as n, ir as o, Ae as p, mr as r, Je as s, Pr as t, Le as u, ne as v, h as w, se as x, Ee as y, O as z };
|