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