@beyondwork/xlsx-substrate-bindings 0.0.0-stage → 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (50) hide show
  1. package/LICENSE.md +31 -0
  2. package/dist/ai/index.d.ts +2 -0
  3. package/dist/ai/index.js +1 -0
  4. package/dist/ai/types.d.ts +320 -0
  5. package/dist/ai/types.js +23 -0
  6. package/dist/index.d.ts +46 -0
  7. package/dist/index.js +72 -0
  8. package/dist/runtime/index.d.ts +2 -0
  9. package/dist/runtime/index.js +1 -0
  10. package/dist/runtime/types.d.ts +1379 -0
  11. package/dist/runtime/types.js +15 -0
  12. package/dist/shared.d.ts +69 -0
  13. package/dist/shared.js +1 -0
  14. package/dist/ui/index.d.ts +2 -0
  15. package/dist/ui/index.js +1 -0
  16. package/dist/ui/types.d.ts +765 -0
  17. package/dist/ui/types.js +12 -0
  18. package/dist/wasm/bridge-contract.d.ts +541 -0
  19. package/dist/wasm/bridge-contract.js +862 -0
  20. package/dist/wasm/chart-test-fixture.d.ts +19 -0
  21. package/dist/wasm/chart-test-fixture.js +42 -0
  22. package/dist/wasm/index.d.ts +9 -0
  23. package/dist/wasm/index.js +67 -0
  24. package/dist/wasm/media-test-fixture.d.ts +44 -0
  25. package/dist/wasm/media-test-fixture.js +160 -0
  26. package/dist/wasm/session-router.d.ts +98 -0
  27. package/dist/wasm/session-router.js +184 -0
  28. package/dist/wasm/sheet-window-binary-reference.d.ts +9 -0
  29. package/dist/wasm/sheet-window-binary-reference.js +308 -0
  30. package/dist/wasm/sheet-window-binary.d.ts +279 -0
  31. package/dist/wasm/sheet-window-binary.js +636 -0
  32. package/dist/wasm/volatile-test-fixture.d.ts +7 -0
  33. package/dist/wasm/volatile-test-fixture.js +35 -0
  34. package/dist/wasm/web.d.ts +59 -0
  35. package/dist/wasm/web.js +60 -0
  36. package/generated/wasm/package.json +3 -0
  37. package/generated/wasm/sheet-window-binary.mjs +482 -0
  38. package/generated/wasm/snippets/ironcalc_base-89b4f49381e1e289/inline0.js +45 -0
  39. package/generated/wasm/xlsx_substrate_wasm.d.ts +336 -0
  40. package/generated/wasm/xlsx_substrate_wasm.js +2108 -0
  41. package/generated/wasm/xlsx_substrate_wasm_bg.wasm +0 -0
  42. package/generated/wasm/xlsx_substrate_wasm_bg.wasm.d.ts +105 -0
  43. package/generated/wasm-web/package.json +3 -0
  44. package/generated/wasm-web/snippets/ironcalc_base-89b4f49381e1e289/inline0.js +42 -0
  45. package/generated/wasm-web/xlsx_substrate_wasm.d.ts +466 -0
  46. package/generated/wasm-web/xlsx_substrate_wasm.js +2109 -0
  47. package/generated/wasm-web/xlsx_substrate_wasm_bg.wasm +0 -0
  48. package/generated/wasm-web/xlsx_substrate_wasm_bg.wasm.d.ts +105 -0
  49. package/package.json +41 -3
  50. package/README.md +0 -3
@@ -0,0 +1,2108 @@
1
+ /* @ts-self-types="./xlsx_substrate_wasm.d.ts" */
2
+ const { ic_tz_parts, ic_tz_validate } = require(String.raw`./snippets/ironcalc_base-89b4f49381e1e289/inline0.js`);
3
+
4
+ /**
5
+ * @param {string} handle_id
6
+ * @param {string | null} [requested_active_sheet_id]
7
+ * @returns {any}
8
+ */
9
+ function bindUiRuntimeSession(handle_id, requested_active_sheet_id) {
10
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
11
+ const len0 = WASM_VECTOR_LEN;
12
+ var ptr1 = isLikeNone(requested_active_sheet_id) ? 0 : passStringToWasm0(requested_active_sheet_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
13
+ var len1 = WASM_VECTOR_LEN;
14
+ const ret = wasm.bindUiRuntimeSession(ptr0, len0, ptr1, len1);
15
+ if (ret[2]) {
16
+ throw takeFromExternrefTable0(ret[1]);
17
+ }
18
+ return takeFromExternrefTable0(ret[0]);
19
+ }
20
+ exports.bindUiRuntimeSession = bindUiRuntimeSession;
21
+
22
+ /**
23
+ * @param {Uint8Array} bytes
24
+ * @param {string | null} [requested_active_sheet_id]
25
+ * @returns {any}
26
+ */
27
+ function bindUiSession(bytes, requested_active_sheet_id) {
28
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
29
+ const len0 = WASM_VECTOR_LEN;
30
+ var ptr1 = isLikeNone(requested_active_sheet_id) ? 0 : passStringToWasm0(requested_active_sheet_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
31
+ var len1 = WASM_VECTOR_LEN;
32
+ const ret = wasm.bindUiSession(ptr0, len0, ptr1, len1);
33
+ if (ret[2]) {
34
+ throw takeFromExternrefTable0(ret[1]);
35
+ }
36
+ return takeFromExternrefTable0(ret[0]);
37
+ }
38
+ exports.bindUiSession = bindUiSession;
39
+
40
+ /**
41
+ * @param {Uint8Array} bytes
42
+ * @param {any} request
43
+ * @returns {any}
44
+ */
45
+ function cancelKernelRun(bytes, request) {
46
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
47
+ const len0 = WASM_VECTOR_LEN;
48
+ const ret = wasm.cancelKernelRun(ptr0, len0, request);
49
+ if (ret[2]) {
50
+ throw takeFromExternrefTable0(ret[1]);
51
+ }
52
+ return takeFromExternrefTable0(ret[0]);
53
+ }
54
+ exports.cancelKernelRun = cancelKernelRun;
55
+
56
+ /**
57
+ * @param {string} namespace
58
+ * @returns {any}
59
+ */
60
+ function classifyUiState(namespace) {
61
+ const ptr0 = passStringToWasm0(namespace, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
62
+ const len0 = WASM_VECTOR_LEN;
63
+ const ret = wasm.classifyUiState(ptr0, len0);
64
+ if (ret[2]) {
65
+ throw takeFromExternrefTable0(ret[1]);
66
+ }
67
+ return takeFromExternrefTable0(ret[0]);
68
+ }
69
+ exports.classifyUiState = classifyUiState;
70
+
71
+ /**
72
+ * @param {Uint8Array} bytes
73
+ * @param {any} request
74
+ * @returns {any}
75
+ */
76
+ function commitApplyFilter(bytes, request) {
77
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
78
+ const len0 = WASM_VECTOR_LEN;
79
+ const ret = wasm.commitApplyFilter(ptr0, len0, request);
80
+ if (ret[2]) {
81
+ throw takeFromExternrefTable0(ret[1]);
82
+ }
83
+ return takeFromExternrefTable0(ret[0]);
84
+ }
85
+ exports.commitApplyFilter = commitApplyFilter;
86
+
87
+ /**
88
+ * @param {Uint8Array} bytes
89
+ * @param {any} request
90
+ * @returns {any}
91
+ */
92
+ function commitApplySort(bytes, request) {
93
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
94
+ const len0 = WASM_VECTOR_LEN;
95
+ const ret = wasm.commitApplySort(ptr0, len0, request);
96
+ if (ret[2]) {
97
+ throw takeFromExternrefTable0(ret[1]);
98
+ }
99
+ return takeFromExternrefTable0(ret[0]);
100
+ }
101
+ exports.commitApplySort = commitApplySort;
102
+
103
+ /**
104
+ * @param {Uint8Array} bytes
105
+ * @param {any} request
106
+ * @returns {any}
107
+ */
108
+ function commitCellFormula(bytes, request) {
109
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
110
+ const len0 = WASM_VECTOR_LEN;
111
+ const ret = wasm.commitCellFormula(ptr0, len0, request);
112
+ if (ret[2]) {
113
+ throw takeFromExternrefTable0(ret[1]);
114
+ }
115
+ return takeFromExternrefTable0(ret[0]);
116
+ }
117
+ exports.commitCellFormula = commitCellFormula;
118
+
119
+ /**
120
+ * @param {string} handle_id
121
+ * @param {any} request
122
+ * @returns {any}
123
+ */
124
+ function commitCellFormulaInSession(handle_id, request) {
125
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
126
+ const len0 = WASM_VECTOR_LEN;
127
+ const ret = wasm.commitCellFormulaInSession(ptr0, len0, request);
128
+ if (ret[2]) {
129
+ throw takeFromExternrefTable0(ret[1]);
130
+ }
131
+ return takeFromExternrefTable0(ret[0]);
132
+ }
133
+ exports.commitCellFormulaInSession = commitCellFormulaInSession;
134
+
135
+ /**
136
+ * @param {Uint8Array} bytes
137
+ * @param {any} request
138
+ * @returns {any}
139
+ */
140
+ function commitClearFilter(bytes, request) {
141
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
142
+ const len0 = WASM_VECTOR_LEN;
143
+ const ret = wasm.commitClearFilter(ptr0, len0, request);
144
+ if (ret[2]) {
145
+ throw takeFromExternrefTable0(ret[1]);
146
+ }
147
+ return takeFromExternrefTable0(ret[0]);
148
+ }
149
+ exports.commitClearFilter = commitClearFilter;
150
+
151
+ /**
152
+ * @param {Uint8Array} bytes
153
+ * @param {any} request
154
+ * @returns {any}
155
+ */
156
+ function commitRangeClear(bytes, request) {
157
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
158
+ const len0 = WASM_VECTOR_LEN;
159
+ const ret = wasm.commitRangeClear(ptr0, len0, request);
160
+ if (ret[2]) {
161
+ throw takeFromExternrefTable0(ret[1]);
162
+ }
163
+ return takeFromExternrefTable0(ret[0]);
164
+ }
165
+ exports.commitRangeClear = commitRangeClear;
166
+
167
+ /**
168
+ * @param {string} handle_id
169
+ * @param {any} request
170
+ * @returns {any}
171
+ */
172
+ function commitRangeClearInSession(handle_id, request) {
173
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
174
+ const len0 = WASM_VECTOR_LEN;
175
+ const ret = wasm.commitRangeClearInSession(ptr0, len0, request);
176
+ if (ret[2]) {
177
+ throw takeFromExternrefTable0(ret[1]);
178
+ }
179
+ return takeFromExternrefTable0(ret[0]);
180
+ }
181
+ exports.commitRangeClearInSession = commitRangeClearInSession;
182
+
183
+ /**
184
+ * X5-U-011 data-validation authoring (byte path). Sets or clears a rule
185
+ * over the target range (a scope handle, a single address, or an explicit
186
+ * `targetRange`), then re-exports the mutated package. Rule shape is
187
+ * validated runtime-side, so a caller that skips the dialog is refused here.
188
+ * @param {Uint8Array} bytes
189
+ * @param {any} request
190
+ * @returns {any}
191
+ */
192
+ function commitRangeDataValidation(bytes, request) {
193
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
194
+ const len0 = WASM_VECTOR_LEN;
195
+ const ret = wasm.commitRangeDataValidation(ptr0, len0, request);
196
+ if (ret[2]) {
197
+ throw takeFromExternrefTable0(ret[1]);
198
+ }
199
+ return takeFromExternrefTable0(ret[0]);
200
+ }
201
+ exports.commitRangeDataValidation = commitRangeDataValidation;
202
+
203
+ /**
204
+ * @param {Uint8Array} bytes
205
+ * @param {any} request
206
+ * @returns {any}
207
+ */
208
+ function commitRangeFill(bytes, request) {
209
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
210
+ const len0 = WASM_VECTOR_LEN;
211
+ const ret = wasm.commitRangeFill(ptr0, len0, request);
212
+ if (ret[2]) {
213
+ throw takeFromExternrefTable0(ret[1]);
214
+ }
215
+ return takeFromExternrefTable0(ret[0]);
216
+ }
217
+ exports.commitRangeFill = commitRangeFill;
218
+
219
+ /**
220
+ * @param {string} handle_id
221
+ * @param {any} request
222
+ * @returns {any}
223
+ */
224
+ function commitRangeFillInSession(handle_id, request) {
225
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
226
+ const len0 = WASM_VECTOR_LEN;
227
+ const ret = wasm.commitRangeFillInSession(ptr0, len0, request);
228
+ if (ret[2]) {
229
+ throw takeFromExternrefTable0(ret[1]);
230
+ }
231
+ return takeFromExternrefTable0(ret[0]);
232
+ }
233
+ exports.commitRangeFillInSession = commitRangeFillInSession;
234
+
235
+ /**
236
+ * @param {Uint8Array} bytes
237
+ * @param {any} request
238
+ * @returns {any}
239
+ */
240
+ function commitRangeFormat(bytes, request) {
241
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
242
+ const len0 = WASM_VECTOR_LEN;
243
+ const ret = wasm.commitRangeFormat(ptr0, len0, request);
244
+ if (ret[2]) {
245
+ throw takeFromExternrefTable0(ret[1]);
246
+ }
247
+ return takeFromExternrefTable0(ret[0]);
248
+ }
249
+ exports.commitRangeFormat = commitRangeFormat;
250
+
251
+ /**
252
+ * @param {string} handle_id
253
+ * @param {any} request
254
+ * @returns {any}
255
+ */
256
+ function commitRangeFormatInSession(handle_id, request) {
257
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
258
+ const len0 = WASM_VECTOR_LEN;
259
+ const ret = wasm.commitRangeFormatInSession(ptr0, len0, request);
260
+ if (ret[2]) {
261
+ throw takeFromExternrefTable0(ret[1]);
262
+ }
263
+ return takeFromExternrefTable0(ret[0]);
264
+ }
265
+ exports.commitRangeFormatInSession = commitRangeFormatInSession;
266
+
267
+ /**
268
+ * X5-U-009 hyperlink authoring (byte path). Attaches, replaces or removes a
269
+ * cell hyperlink over the target range, then re-exports the mutated package.
270
+ * Destination policy is enforced runtime-side, so a caller that skips the
271
+ * product surface is refused here, not silently allowed.
272
+ * @param {Uint8Array} bytes
273
+ * @param {any} request
274
+ * @returns {any}
275
+ */
276
+ function commitRangeHyperlink(bytes, request) {
277
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
278
+ const len0 = WASM_VECTOR_LEN;
279
+ const ret = wasm.commitRangeHyperlink(ptr0, len0, request);
280
+ if (ret[2]) {
281
+ throw takeFromExternrefTable0(ret[1]);
282
+ }
283
+ return takeFromExternrefTable0(ret[0]);
284
+ }
285
+ exports.commitRangeHyperlink = commitRangeHyperlink;
286
+
287
+ /**
288
+ * @param {Uint8Array} bytes
289
+ * @param {any} request
290
+ * @returns {any}
291
+ */
292
+ function commitRangePaste(bytes, request) {
293
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
294
+ const len0 = WASM_VECTOR_LEN;
295
+ const ret = wasm.commitRangePaste(ptr0, len0, request);
296
+ if (ret[2]) {
297
+ throw takeFromExternrefTable0(ret[1]);
298
+ }
299
+ return takeFromExternrefTable0(ret[0]);
300
+ }
301
+ exports.commitRangePaste = commitRangePaste;
302
+
303
+ /**
304
+ * @param {string} handle_id
305
+ * @param {any} request
306
+ * @returns {any}
307
+ */
308
+ function commitRangePasteInSession(handle_id, request) {
309
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
310
+ const len0 = WASM_VECTOR_LEN;
311
+ const ret = wasm.commitRangePasteInSession(ptr0, len0, request);
312
+ if (ret[2]) {
313
+ throw takeFromExternrefTable0(ret[1]);
314
+ }
315
+ return takeFromExternrefTable0(ret[0]);
316
+ }
317
+ exports.commitRangePasteInSession = commitRangePasteInSession;
318
+
319
+ /**
320
+ * @param {Uint8Array} bytes
321
+ * @param {any} request
322
+ * @returns {any}
323
+ */
324
+ function commitRangeTransfer(bytes, request) {
325
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
326
+ const len0 = WASM_VECTOR_LEN;
327
+ const ret = wasm.commitRangeTransfer(ptr0, len0, request);
328
+ if (ret[2]) {
329
+ throw takeFromExternrefTable0(ret[1]);
330
+ }
331
+ return takeFromExternrefTable0(ret[0]);
332
+ }
333
+ exports.commitRangeTransfer = commitRangeTransfer;
334
+
335
+ /**
336
+ * @param {string} handle_id
337
+ * @param {any} request
338
+ * @returns {any}
339
+ */
340
+ function commitRangeTransferInSession(handle_id, request) {
341
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
342
+ const len0 = WASM_VECTOR_LEN;
343
+ const ret = wasm.commitRangeTransferInSession(ptr0, len0, request);
344
+ if (ret[2]) {
345
+ throw takeFromExternrefTable0(ret[1]);
346
+ }
347
+ return takeFromExternrefTable0(ret[0]);
348
+ }
349
+ exports.commitRangeTransferInSession = commitRangeTransferInSession;
350
+
351
+ /**
352
+ * X5-U-010b `review.comment` (byte path). Creates, edits, replies to,
353
+ * resolves, reopens or deletes the comment thread on ONE cell (a scope
354
+ * handle or a single address), then re-exports the mutated package. Verb
355
+ * and text shape are validated runtime-side.
356
+ * @param {Uint8Array} bytes
357
+ * @param {any} request
358
+ * @returns {any}
359
+ */
360
+ function commitReviewComment(bytes, request) {
361
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
362
+ const len0 = WASM_VECTOR_LEN;
363
+ const ret = wasm.commitReviewComment(ptr0, len0, request);
364
+ if (ret[2]) {
365
+ throw takeFromExternrefTable0(ret[1]);
366
+ }
367
+ return takeFromExternrefTable0(ret[0]);
368
+ }
369
+ exports.commitReviewComment = commitReviewComment;
370
+
371
+ /**
372
+ * @param {Uint8Array} bytes
373
+ * @param {any} request
374
+ * @returns {any}
375
+ */
376
+ function commitSelectionSetClear(bytes, request) {
377
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
378
+ const len0 = WASM_VECTOR_LEN;
379
+ const ret = wasm.commitSelectionSetClear(ptr0, len0, request);
380
+ if (ret[2]) {
381
+ throw takeFromExternrefTable0(ret[1]);
382
+ }
383
+ return takeFromExternrefTable0(ret[0]);
384
+ }
385
+ exports.commitSelectionSetClear = commitSelectionSetClear;
386
+
387
+ /**
388
+ * @param {Uint8Array} bytes
389
+ * @param {any} request
390
+ * @returns {any}
391
+ */
392
+ function commitSelectionSetFormat(bytes, request) {
393
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
394
+ const len0 = WASM_VECTOR_LEN;
395
+ const ret = wasm.commitSelectionSetFormat(ptr0, len0, request);
396
+ if (ret[2]) {
397
+ throw takeFromExternrefTable0(ret[1]);
398
+ }
399
+ return takeFromExternrefTable0(ret[0]);
400
+ }
401
+ exports.commitSelectionSetFormat = commitSelectionSetFormat;
402
+
403
+ /**
404
+ * @param {Uint8Array} bytes
405
+ * @param {any} request
406
+ * @returns {any}
407
+ */
408
+ function commitSelectionSetPaste(bytes, request) {
409
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
410
+ const len0 = WASM_VECTOR_LEN;
411
+ const ret = wasm.commitSelectionSetPaste(ptr0, len0, request);
412
+ if (ret[2]) {
413
+ throw takeFromExternrefTable0(ret[1]);
414
+ }
415
+ return takeFromExternrefTable0(ret[0]);
416
+ }
417
+ exports.commitSelectionSetPaste = commitSelectionSetPaste;
418
+
419
+ /**
420
+ * X5-U-006 insert/delete cells with shift (byte path). Applies
421
+ * `runtime_sheet_shift_cells` over one rectangle and a shift direction, then
422
+ * exports the mutated workbook. Refusals come back typed with no bytes.
423
+ * @param {Uint8Array} bytes
424
+ * @param {any} request
425
+ * @returns {any}
426
+ */
427
+ function commitShiftCells(bytes, request) {
428
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
429
+ const len0 = WASM_VECTOR_LEN;
430
+ const ret = wasm.commitShiftCells(ptr0, len0, request);
431
+ if (ret[2]) {
432
+ throw takeFromExternrefTable0(ret[1]);
433
+ }
434
+ return takeFromExternrefTable0(ret[0]);
435
+ }
436
+ exports.commitShiftCells = commitShiftCells;
437
+
438
+ /**
439
+ * X5-U-006 insert/delete cells with shift (session path). A cell shift
440
+ * re-addresses every cell in the moved band and rewrites the formulas that
441
+ * follow them, which incremental graph maintenance cannot see — so, like a
442
+ * row/column structure mutation, it forces the full-recalc fallback.
443
+ * @param {string} handle_id
444
+ * @param {any} request
445
+ * @returns {any}
446
+ */
447
+ function commitShiftCellsInSession(handle_id, request) {
448
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
449
+ const len0 = WASM_VECTOR_LEN;
450
+ const ret = wasm.commitShiftCellsInSession(ptr0, len0, request);
451
+ if (ret[2]) {
452
+ throw takeFromExternrefTable0(ret[1]);
453
+ }
454
+ return takeFromExternrefTable0(ret[0]);
455
+ }
456
+ exports.commitShiftCellsInSession = commitShiftCellsInSession;
457
+
458
+ /**
459
+ * @param {Uint8Array} bytes
460
+ * @param {any} request
461
+ * @returns {any}
462
+ */
463
+ function commitTableAppendRow(bytes, request) {
464
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
465
+ const len0 = WASM_VECTOR_LEN;
466
+ const ret = wasm.commitTableAppendRow(ptr0, len0, request);
467
+ if (ret[2]) {
468
+ throw takeFromExternrefTable0(ret[1]);
469
+ }
470
+ return takeFromExternrefTable0(ret[0]);
471
+ }
472
+ exports.commitTableAppendRow = commitTableAppendRow;
473
+
474
+ /**
475
+ * @param {string} handle_id
476
+ * @param {any} request
477
+ * @returns {any}
478
+ */
479
+ function commitTableAppendRowInSession(handle_id, request) {
480
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
481
+ const len0 = WASM_VECTOR_LEN;
482
+ const ret = wasm.commitTableAppendRowInSession(ptr0, len0, request);
483
+ if (ret[2]) {
484
+ throw takeFromExternrefTable0(ret[1]);
485
+ }
486
+ return takeFromExternrefTable0(ret[0]);
487
+ }
488
+ exports.commitTableAppendRowInSession = commitTableAppendRowInSession;
489
+
490
+ /**
491
+ * @param {Uint8Array} bytes
492
+ * @param {any} request
493
+ * @returns {any}
494
+ */
495
+ function completeKernelRun(bytes, request) {
496
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
497
+ const len0 = WASM_VECTOR_LEN;
498
+ const ret = wasm.completeKernelRun(ptr0, len0, request);
499
+ if (ret[2]) {
500
+ throw takeFromExternrefTable0(ret[1]);
501
+ }
502
+ return takeFromExternrefTable0(ret[0]);
503
+ }
504
+ exports.completeKernelRun = completeKernelRun;
505
+
506
+ /**
507
+ * @param {Uint8Array} bytes
508
+ * @param {any} request
509
+ * @returns {any}
510
+ */
511
+ function createKernelBinding(bytes, request) {
512
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
513
+ const len0 = WASM_VECTOR_LEN;
514
+ const ret = wasm.createKernelBinding(ptr0, len0, request);
515
+ if (ret[2]) {
516
+ throw takeFromExternrefTable0(ret[1]);
517
+ }
518
+ return takeFromExternrefTable0(ret[0]);
519
+ }
520
+ exports.createKernelBinding = createKernelBinding;
521
+
522
+ /**
523
+ * X3-R-012 (v40): data-region navigation over the session workbook.
524
+ * Read-only: the session is untouched. `query: "edge"` answers Ctrl+Arrow
525
+ * (`Range.End(direction)` of `active`), `query: "extend"` answers
526
+ * Ctrl+Shift+Arrow (the same edge as the head of a selection kept on
527
+ * `anchor`), `query: "current-region"` answers Ctrl+A
528
+ * (`Range.CurrentRegion` of `active`, or the whole sheet when `selection`
529
+ * already covers it). The answer carries the target's sheet, range, label
530
+ * and the selection handle the selection command takes, so the grid
531
+ * readback and the name box follow from the runtime's answer — never from
532
+ * a walk over the loaded window.
533
+ * @param {string} handle_id
534
+ * @param {any} request
535
+ * @returns {any}
536
+ */
537
+ function dataRegionInRuntimeSession(handle_id, request) {
538
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
539
+ const len0 = WASM_VECTOR_LEN;
540
+ const ret = wasm.dataRegionInRuntimeSession(ptr0, len0, request);
541
+ if (ret[2]) {
542
+ throw takeFromExternrefTable0(ret[1]);
543
+ }
544
+ return takeFromExternrefTable0(ret[0]);
545
+ }
546
+ exports.dataRegionInRuntimeSession = dataRegionInRuntimeSession;
547
+
548
+ /**
549
+ * @param {Uint8Array} bytes
550
+ * @param {any} request
551
+ * @returns {any}
552
+ */
553
+ function deleteKernelBinding(bytes, request) {
554
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
555
+ const len0 = WASM_VECTOR_LEN;
556
+ const ret = wasm.deleteKernelBinding(ptr0, len0, request);
557
+ if (ret[2]) {
558
+ throw takeFromExternrefTable0(ret[1]);
559
+ }
560
+ return takeFromExternrefTable0(ret[0]);
561
+ }
562
+ exports.deleteKernelBinding = deleteKernelBinding;
563
+
564
+ /**
565
+ * @param {Uint8Array} bytes
566
+ * @param {any} request
567
+ * @returns {any}
568
+ */
569
+ function detachKernelOutput(bytes, request) {
570
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
571
+ const len0 = WASM_VECTOR_LEN;
572
+ const ret = wasm.detachKernelOutput(ptr0, len0, request);
573
+ if (ret[2]) {
574
+ throw takeFromExternrefTable0(ret[1]);
575
+ }
576
+ return takeFromExternrefTable0(ret[0]);
577
+ }
578
+ exports.detachKernelOutput = detachKernelOutput;
579
+
580
+ /**
581
+ * @param {string} handle_id
582
+ * @returns {any}
583
+ */
584
+ function disposeWorkbookRuntimeSession(handle_id) {
585
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
586
+ const len0 = WASM_VECTOR_LEN;
587
+ const ret = wasm.disposeWorkbookRuntimeSession(ptr0, len0);
588
+ if (ret[2]) {
589
+ throw takeFromExternrefTable0(ret[1]);
590
+ }
591
+ return takeFromExternrefTable0(ret[0]);
592
+ }
593
+ exports.disposeWorkbookRuntimeSession = disposeWorkbookRuntimeSession;
594
+
595
+ /**
596
+ * @param {Uint8Array} bytes
597
+ * @param {any} target
598
+ * @returns {any}
599
+ */
600
+ function explainFormula(bytes, target) {
601
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
602
+ const len0 = WASM_VECTOR_LEN;
603
+ const ret = wasm.explainFormula(ptr0, len0, target);
604
+ if (ret[2]) {
605
+ throw takeFromExternrefTable0(ret[1]);
606
+ }
607
+ return takeFromExternrefTable0(ret[0]);
608
+ }
609
+ exports.explainFormula = explainFormula;
610
+
611
+ /**
612
+ * @param {string} handle_id
613
+ * @param {any} target
614
+ * @returns {any}
615
+ */
616
+ function explainRuntimeSessionFormula(handle_id, target) {
617
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
618
+ const len0 = WASM_VECTOR_LEN;
619
+ const ret = wasm.explainRuntimeSessionFormula(ptr0, len0, target);
620
+ if (ret[2]) {
621
+ throw takeFromExternrefTable0(ret[1]);
622
+ }
623
+ return takeFromExternrefTable0(ret[0]);
624
+ }
625
+ exports.explainRuntimeSessionFormula = explainRuntimeSessionFormula;
626
+
627
+ /**
628
+ * @param {string} handle_id
629
+ * @param {any} request
630
+ * @returns {any}
631
+ */
632
+ function exportRuntimeSessionBytes(handle_id, request) {
633
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
634
+ const len0 = WASM_VECTOR_LEN;
635
+ const ret = wasm.exportRuntimeSessionBytes(ptr0, len0, request);
636
+ if (ret[2]) {
637
+ throw takeFromExternrefTable0(ret[1]);
638
+ }
639
+ return takeFromExternrefTable0(ret[0]);
640
+ }
641
+ exports.exportRuntimeSessionBytes = exportRuntimeSessionBytes;
642
+
643
+ /**
644
+ * X5-U-012: the product's delimited-text (CSV/TSV) export.
645
+ *
646
+ * Read-only, like `exportRuntimeSessionBytes`: no revision bump, no
647
+ * invalidation, no identity advancement. The whole sheet is walked engine
648
+ * side rather than the materialized window the clipboard serializer sees, so
649
+ * what the user downloads is the sheet and not the part of it that happens to
650
+ * be on screen.
651
+ *
652
+ * A refusal comes back as `blockers`, not as an exception: the export is
653
+ * bounded on the range it would emit (a two-cell workbook whose used range
654
+ * spans the grid is `delimited-export-too-many-cells`), and what CSV cannot
655
+ * carry — other sheets, formulas as their last calculated value, formatting —
656
+ * comes back on `refusals` so the surface can tell the user before they open
657
+ * the file somewhere else.
658
+ * @param {string} handle_id
659
+ * @param {any} request
660
+ * @returns {any}
661
+ */
662
+ function exportRuntimeSessionDelimitedText(handle_id, request) {
663
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
664
+ const len0 = WASM_VECTOR_LEN;
665
+ const ret = wasm.exportRuntimeSessionDelimitedText(ptr0, len0, request);
666
+ if (ret[2]) {
667
+ throw takeFromExternrefTable0(ret[1]);
668
+ }
669
+ return takeFromExternrefTable0(ret[0]);
670
+ }
671
+ exports.exportRuntimeSessionDelimitedText = exportRuntimeSessionDelimitedText;
672
+
673
+ /**
674
+ * X5-U-038 (v34): Excel's Find over the session workbook. Read-only: the
675
+ * session is untouched, so the answer is the match list (with the cell
676
+ * handle the selection command takes for each) or a typed refusal of the
677
+ * query itself. Never a window scan — the runtime walks the canonical cell
678
+ * store, so off-window and off-sheet cells are found.
679
+ * @param {string} handle_id
680
+ * @param {any} request
681
+ * @returns {any}
682
+ */
683
+ function findInRuntimeSession(handle_id, request) {
684
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
685
+ const len0 = WASM_VECTOR_LEN;
686
+ const ret = wasm.findInRuntimeSession(ptr0, len0, request);
687
+ if (ret[2]) {
688
+ throw takeFromExternrefTable0(ret[1]);
689
+ }
690
+ return takeFromExternrefTable0(ret[0]);
691
+ }
692
+ exports.findInRuntimeSession = findInRuntimeSession;
693
+
694
+ /**
695
+ * @returns {any}
696
+ */
697
+ function getWasmStatus() {
698
+ const ret = wasm.getWasmStatus();
699
+ if (ret[2]) {
700
+ throw takeFromExternrefTable0(ret[1]);
701
+ }
702
+ return takeFromExternrefTable0(ret[0]);
703
+ }
704
+ exports.getWasmStatus = getWasmStatus;
705
+
706
+ /**
707
+ * X5-U-023 (v35): name-box / Go To resolution over the session workbook.
708
+ * Read-only: the session is untouched. The answer names the target sheet
709
+ * and range, the label the name box shows, and the selection handle the
710
+ * selection command (`interact` / `readRuntimeSessionSelection`) takes —
711
+ * so the grid readback and the formula bar follow from the runtime's
712
+ * answer, never from a client parse of the typed text. Defined names are
713
+ * resolved here with Excel's scope precedence; the client never scans.
714
+ * @param {string} handle_id
715
+ * @param {any} request
716
+ * @returns {any}
717
+ */
718
+ function goToInRuntimeSession(handle_id, request) {
719
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
720
+ const len0 = WASM_VECTOR_LEN;
721
+ const ret = wasm.goToInRuntimeSession(ptr0, len0, request);
722
+ if (ret[2]) {
723
+ throw takeFromExternrefTable0(ret[1]);
724
+ }
725
+ return takeFromExternrefTable0(ret[0]);
726
+ }
727
+ exports.goToInRuntimeSession = goToInRuntimeSession;
728
+
729
+ /**
730
+ * @param {Uint8Array} bytes
731
+ * @param {string | null} [source_label]
732
+ * @returns {any}
733
+ */
734
+ function inspectWorkbook(bytes, source_label) {
735
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
736
+ const len0 = WASM_VECTOR_LEN;
737
+ var ptr1 = isLikeNone(source_label) ? 0 : passStringToWasm0(source_label, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
738
+ var len1 = WASM_VECTOR_LEN;
739
+ const ret = wasm.inspectWorkbook(ptr0, len0, ptr1, len1);
740
+ if (ret[2]) {
741
+ throw takeFromExternrefTable0(ret[1]);
742
+ }
743
+ return takeFromExternrefTable0(ret[0]);
744
+ }
745
+ exports.inspectWorkbook = inspectWorkbook;
746
+
747
+ /**
748
+ * @param {string} handle_id
749
+ * @returns {any}
750
+ */
751
+ function inspectWorkbookRuntimeSession(handle_id) {
752
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
753
+ const len0 = WASM_VECTOR_LEN;
754
+ const ret = wasm.inspectWorkbookRuntimeSession(ptr0, len0);
755
+ if (ret[2]) {
756
+ throw takeFromExternrefTable0(ret[1]);
757
+ }
758
+ return takeFromExternrefTable0(ret[0]);
759
+ }
760
+ exports.inspectWorkbookRuntimeSession = inspectWorkbookRuntimeSession;
761
+
762
+ /**
763
+ * @param {string} handle_id
764
+ * @param {any} request
765
+ * @returns {any}
766
+ */
767
+ function listRuntimeSessionScopes(handle_id, request) {
768
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
769
+ const len0 = WASM_VECTOR_LEN;
770
+ const ret = wasm.listRuntimeSessionScopes(ptr0, len0, request);
771
+ if (ret[2]) {
772
+ throw takeFromExternrefTable0(ret[1]);
773
+ }
774
+ return takeFromExternrefTable0(ret[0]);
775
+ }
776
+ exports.listRuntimeSessionScopes = listRuntimeSessionScopes;
777
+
778
+ /**
779
+ * @param {Uint8Array} bytes
780
+ * @param {any} request
781
+ * @returns {any}
782
+ */
783
+ function listScopes(bytes, request) {
784
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
785
+ const len0 = WASM_VECTOR_LEN;
786
+ const ret = wasm.listScopes(ptr0, len0, request);
787
+ if (ret[2]) {
788
+ throw takeFromExternrefTable0(ret[1]);
789
+ }
790
+ return takeFromExternrefTable0(ret[0]);
791
+ }
792
+ exports.listScopes = listScopes;
793
+
794
+ /**
795
+ * X5-U-037 merge/unmerge cells (byte path). Applies the runtime merge
796
+ * command and, on an applied verdict, exports the mutated workbook so the
797
+ * caller can thread the bytes forward. The result carries the discarded
798
+ * covered cells so the host can confirm the loss with the user.
799
+ * @param {Uint8Array} bytes
800
+ * @param {any} request
801
+ * @returns {any}
802
+ */
803
+ function mergeCells(bytes, request) {
804
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
805
+ const len0 = WASM_VECTOR_LEN;
806
+ const ret = wasm.mergeCells(ptr0, len0, request);
807
+ if (ret[2]) {
808
+ throw takeFromExternrefTable0(ret[1]);
809
+ }
810
+ return takeFromExternrefTable0(ret[0]);
811
+ }
812
+ exports.mergeCells = mergeCells;
813
+
814
+ /**
815
+ * X5-U-037 merge/unmerge cells (session path). A merge that discards
816
+ * covered content is a range clear for the keep-alive graph (dirty seeds =
817
+ * the discarded cells' ids); a merge with nothing to discard and every
818
+ * unmerge is value-neutral.
819
+ * @param {string} handle_id
820
+ * @param {any} request
821
+ * @returns {any}
822
+ */
823
+ function mergeCellsInSession(handle_id, request) {
824
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
825
+ const len0 = WASM_VECTOR_LEN;
826
+ const ret = wasm.mergeCellsInSession(ptr0, len0, request);
827
+ if (ret[2]) {
828
+ throw takeFromExternrefTable0(ret[1]);
829
+ }
830
+ return takeFromExternrefTable0(ret[0]);
831
+ }
832
+ exports.mergeCellsInSession = mergeCellsInSession;
833
+
834
+ /**
835
+ * @param {Uint8Array} bytes
836
+ * @param {any} request
837
+ * @returns {any}
838
+ */
839
+ function mutateSheetStructure(bytes, request) {
840
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
841
+ const len0 = WASM_VECTOR_LEN;
842
+ const ret = wasm.mutateSheetStructure(ptr0, len0, request);
843
+ if (ret[2]) {
844
+ throw takeFromExternrefTable0(ret[1]);
845
+ }
846
+ return takeFromExternrefTable0(ret[0]);
847
+ }
848
+ exports.mutateSheetStructure = mutateSheetStructure;
849
+
850
+ /**
851
+ * @param {string} handle_id
852
+ * @param {any} request
853
+ * @returns {any}
854
+ */
855
+ function mutateSheetStructureInSession(handle_id, request) {
856
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
857
+ const len0 = WASM_VECTOR_LEN;
858
+ const ret = wasm.mutateSheetStructureInSession(ptr0, len0, request);
859
+ if (ret[2]) {
860
+ throw takeFromExternrefTable0(ret[1]);
861
+ }
862
+ return takeFromExternrefTable0(ret[0]);
863
+ }
864
+ exports.mutateSheetStructureInSession = mutateSheetStructureInSession;
865
+
866
+ /**
867
+ * @param {Uint8Array} bytes
868
+ * @param {any} request
869
+ * @returns {any}
870
+ */
871
+ function mutateSheetTabs(bytes, request) {
872
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
873
+ const len0 = WASM_VECTOR_LEN;
874
+ const ret = wasm.mutateSheetTabs(ptr0, len0, request);
875
+ if (ret[2]) {
876
+ throw takeFromExternrefTable0(ret[1]);
877
+ }
878
+ return takeFromExternrefTable0(ret[0]);
879
+ }
880
+ exports.mutateSheetTabs = mutateSheetTabs;
881
+
882
+ /**
883
+ * @param {string} handle_id
884
+ * @param {any} request
885
+ * @returns {any}
886
+ */
887
+ function mutateSheetTabsInSession(handle_id, request) {
888
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
889
+ const len0 = WASM_VECTOR_LEN;
890
+ const ret = wasm.mutateSheetTabsInSession(ptr0, len0, request);
891
+ if (ret[2]) {
892
+ throw takeFromExternrefTable0(ret[1]);
893
+ }
894
+ return takeFromExternrefTable0(ret[0]);
895
+ }
896
+ exports.mutateSheetTabsInSession = mutateSheetTabsInSession;
897
+
898
+ /**
899
+ * @param {Uint8Array} bytes
900
+ * @param {any} request
901
+ * @returns {any}
902
+ */
903
+ function openWorkbookRuntimeSession(bytes, request) {
904
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
905
+ const len0 = WASM_VECTOR_LEN;
906
+ const ret = wasm.openWorkbookRuntimeSession(ptr0, len0, request);
907
+ if (ret[2]) {
908
+ throw takeFromExternrefTable0(ret[1]);
909
+ }
910
+ return takeFromExternrefTable0(ret[0]);
911
+ }
912
+ exports.openWorkbookRuntimeSession = openWorkbookRuntimeSession;
913
+
914
+ /**
915
+ * @param {Uint8Array} bytes
916
+ * @param {any} hint
917
+ * @returns {any}
918
+ */
919
+ function projectViewportHint(bytes, hint) {
920
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
921
+ const len0 = WASM_VECTOR_LEN;
922
+ const ret = wasm.projectViewportHint(ptr0, len0, hint);
923
+ if (ret[2]) {
924
+ throw takeFromExternrefTable0(ret[1]);
925
+ }
926
+ return takeFromExternrefTable0(ret[0]);
927
+ }
928
+ exports.projectViewportHint = projectViewportHint;
929
+
930
+ /**
931
+ * @param {Uint8Array} bytes
932
+ * @param {any} request
933
+ * @returns {any}
934
+ */
935
+ function readCompressedContext(bytes, request) {
936
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
937
+ const len0 = WASM_VECTOR_LEN;
938
+ const ret = wasm.readCompressedContext(ptr0, len0, request);
939
+ if (ret[2]) {
940
+ throw takeFromExternrefTable0(ret[1]);
941
+ }
942
+ return takeFromExternrefTable0(ret[0]);
943
+ }
944
+ exports.readCompressedContext = readCompressedContext;
945
+
946
+ /**
947
+ * @param {Uint8Array} bytes
948
+ * @param {any} request
949
+ * @returns {any}
950
+ */
951
+ function readCompressedDrilldown(bytes, request) {
952
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
953
+ const len0 = WASM_VECTOR_LEN;
954
+ const ret = wasm.readCompressedDrilldown(ptr0, len0, request);
955
+ if (ret[2]) {
956
+ throw takeFromExternrefTable0(ret[1]);
957
+ }
958
+ return takeFromExternrefTable0(ret[0]);
959
+ }
960
+ exports.readCompressedDrilldown = readCompressedDrilldown;
961
+
962
+ /**
963
+ * @param {Uint8Array} bytes
964
+ * @param {any} workflow_context
965
+ * @returns {any}
966
+ */
967
+ function readKernelPanel(bytes, workflow_context) {
968
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
969
+ const len0 = WASM_VECTOR_LEN;
970
+ const ret = wasm.readKernelPanel(ptr0, len0, workflow_context);
971
+ if (ret[2]) {
972
+ throw takeFromExternrefTable0(ret[1]);
973
+ }
974
+ return takeFromExternrefTable0(ret[0]);
975
+ }
976
+ exports.readKernelPanel = readKernelPanel;
977
+
978
+ /**
979
+ * X4-CL-002 readable posture: enumerate preserve-only entities so hosts
980
+ * and agents can show typed preserved-object affordances instead of opaque
981
+ * refusals. Metadata-only: keys, kinds, source labels, digest prefixes, and
982
+ * provenance classes — never payload content.
983
+ * @param {Uint8Array} bytes
984
+ * @param {string | null} [source_label]
985
+ * @returns {any}
986
+ */
987
+ function readPreserveOnlyEntities(bytes, source_label) {
988
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
989
+ const len0 = WASM_VECTOR_LEN;
990
+ var ptr1 = isLikeNone(source_label) ? 0 : passStringToWasm0(source_label, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
991
+ var len1 = WASM_VECTOR_LEN;
992
+ const ret = wasm.readPreserveOnlyEntities(ptr0, len0, ptr1, len1);
993
+ if (ret[2]) {
994
+ throw takeFromExternrefTable0(ret[1]);
995
+ }
996
+ return takeFromExternrefTable0(ret[0]);
997
+ }
998
+ exports.readPreserveOnlyEntities = readPreserveOnlyEntities;
999
+
1000
+ /**
1001
+ * D4-R2b (v20): digest-addressed chart XML for a `DrawingChartHandle`
1002
+ * chart id (`chart:sha256:<64-hex>`). One-shot, uncached on the wasm side —
1003
+ * the package seam recomputes the SHA-256 per call, so callers must not
1004
+ * invoke this per paint frame (the client chart-preview store is the
1005
+ * consumer guard). The workbook theme XML rides along when present so the
1006
+ * host-side synthesizer needs no second readback. Refusals are typed
1007
+ * kebab-case `ChartAccessError` codes.
1008
+ * @param {string} handle_id
1009
+ * @param {string} chart_id
1010
+ * @returns {any}
1011
+ */
1012
+ function readRuntimeSessionChartBytes(handle_id, chart_id) {
1013
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1014
+ const len0 = WASM_VECTOR_LEN;
1015
+ const ptr1 = passStringToWasm0(chart_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1016
+ const len1 = WASM_VECTOR_LEN;
1017
+ const ret = wasm.readRuntimeSessionChartBytes(ptr0, len0, ptr1, len1);
1018
+ if (ret[2]) {
1019
+ throw takeFromExternrefTable0(ret[1]);
1020
+ }
1021
+ return takeFromExternrefTable0(ret[0]);
1022
+ }
1023
+ exports.readRuntimeSessionChartBytes = readRuntimeSessionChartBytes;
1024
+
1025
+ /**
1026
+ * @param {string} handle_id
1027
+ * @param {any} request
1028
+ * @returns {any}
1029
+ */
1030
+ function readRuntimeSessionCompressedContext(handle_id, request) {
1031
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1032
+ const len0 = WASM_VECTOR_LEN;
1033
+ const ret = wasm.readRuntimeSessionCompressedContext(ptr0, len0, request);
1034
+ if (ret[2]) {
1035
+ throw takeFromExternrefTable0(ret[1]);
1036
+ }
1037
+ return takeFromExternrefTable0(ret[0]);
1038
+ }
1039
+ exports.readRuntimeSessionCompressedContext = readRuntimeSessionCompressedContext;
1040
+
1041
+ /**
1042
+ * @param {string} handle_id
1043
+ * @param {any} request
1044
+ * @returns {any}
1045
+ */
1046
+ function readRuntimeSessionCompressedDrilldown(handle_id, request) {
1047
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1048
+ const len0 = WASM_VECTOR_LEN;
1049
+ const ret = wasm.readRuntimeSessionCompressedDrilldown(ptr0, len0, request);
1050
+ if (ret[2]) {
1051
+ throw takeFromExternrefTable0(ret[1]);
1052
+ }
1053
+ return takeFromExternrefTable0(ret[0]);
1054
+ }
1055
+ exports.readRuntimeSessionCompressedDrilldown = readRuntimeSessionCompressedDrilldown;
1056
+
1057
+ /**
1058
+ * W-A §5: the explicit integrity readback — the ONLY session read that
1059
+ * materializes the full state SHA on demand (memoized until the next
1060
+ * mutation). Read-only: no revision bump, no identity advancement. Hosts
1061
+ * use it for export-independent integrity verification and idle checks;
1062
+ * every routine surface carries the O(1) chain identity instead.
1063
+ * @param {string} handle_id
1064
+ * @returns {any}
1065
+ */
1066
+ function readRuntimeSessionIntegrity(handle_id) {
1067
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1068
+ const len0 = WASM_VECTOR_LEN;
1069
+ const ret = wasm.readRuntimeSessionIntegrity(ptr0, len0);
1070
+ if (ret[2]) {
1071
+ throw takeFromExternrefTable0(ret[1]);
1072
+ }
1073
+ return takeFromExternrefTable0(ret[0]);
1074
+ }
1075
+ exports.readRuntimeSessionIntegrity = readRuntimeSessionIntegrity;
1076
+
1077
+ /**
1078
+ * @param {string} handle_id
1079
+ * @param {any} workflow_context
1080
+ * @returns {any}
1081
+ */
1082
+ function readRuntimeSessionKernelPanel(handle_id, workflow_context) {
1083
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1084
+ const len0 = WASM_VECTOR_LEN;
1085
+ const ret = wasm.readRuntimeSessionKernelPanel(ptr0, len0, workflow_context);
1086
+ if (ret[2]) {
1087
+ throw takeFromExternrefTable0(ret[1]);
1088
+ }
1089
+ return takeFromExternrefTable0(ret[0]);
1090
+ }
1091
+ exports.readRuntimeSessionKernelPanel = readRuntimeSessionKernelPanel;
1092
+
1093
+ /**
1094
+ * BR-3 (v18): digest-addressed media bytes for a `DrawingMediaHandle`
1095
+ * media id (`media:sha256:<64-hex>`). One-shot, uncached on the wasm side —
1096
+ * the package seam recomputes the SHA-256 per call, so callers must not
1097
+ * invoke this per paint frame (the client decode cache is the consumer
1098
+ * guard). Refusals are typed kebab-case `MediaAccessError` codes.
1099
+ * @param {string} handle_id
1100
+ * @param {string} media_id
1101
+ * @returns {any}
1102
+ */
1103
+ function readRuntimeSessionMediaBytes(handle_id, media_id) {
1104
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1105
+ const len0 = WASM_VECTOR_LEN;
1106
+ const ptr1 = passStringToWasm0(media_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1107
+ const len1 = WASM_VECTOR_LEN;
1108
+ const ret = wasm.readRuntimeSessionMediaBytes(ptr0, len0, ptr1, len1);
1109
+ if (ret[2]) {
1110
+ throw takeFromExternrefTable0(ret[1]);
1111
+ }
1112
+ return takeFromExternrefTable0(ret[0]);
1113
+ }
1114
+ exports.readRuntimeSessionMediaBytes = readRuntimeSessionMediaBytes;
1115
+
1116
+ /**
1117
+ * @param {string} handle_id
1118
+ * @param {any} request
1119
+ * @returns {any}
1120
+ */
1121
+ function readRuntimeSessionOverlayLanes(handle_id, request) {
1122
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1123
+ const len0 = WASM_VECTOR_LEN;
1124
+ const ret = wasm.readRuntimeSessionOverlayLanes(ptr0, len0, request);
1125
+ if (ret[2]) {
1126
+ throw takeFromExternrefTable0(ret[1]);
1127
+ }
1128
+ return takeFromExternrefTable0(ret[0]);
1129
+ }
1130
+ exports.readRuntimeSessionOverlayLanes = readRuntimeSessionOverlayLanes;
1131
+
1132
+ /**
1133
+ * @param {string} handle_id
1134
+ * @returns {any}
1135
+ */
1136
+ function readRuntimeSessionPreserveOnlyEntities(handle_id) {
1137
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1138
+ const len0 = WASM_VECTOR_LEN;
1139
+ const ret = wasm.readRuntimeSessionPreserveOnlyEntities(ptr0, len0);
1140
+ if (ret[2]) {
1141
+ throw takeFromExternrefTable0(ret[1]);
1142
+ }
1143
+ return takeFromExternrefTable0(ret[0]);
1144
+ }
1145
+ exports.readRuntimeSessionPreserveOnlyEntities = readRuntimeSessionPreserveOnlyEntities;
1146
+
1147
+ /**
1148
+ * X5-U-028 (v24): `selection_cursor` is an optional `{anchor, head}`; when
1149
+ * present it is validated against the selected range and echoed on the
1150
+ * readback, so a backwards drag keeps its corners across a refresh.
1151
+ * @param {string} handle_id
1152
+ * @param {any} handle
1153
+ * @param {any} viewport_hint
1154
+ * @param {any} workflow_context
1155
+ * @param {any} selection_cursor
1156
+ * @returns {any}
1157
+ */
1158
+ function readRuntimeSessionSelection(handle_id, handle, viewport_hint, workflow_context, selection_cursor) {
1159
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1160
+ const len0 = WASM_VECTOR_LEN;
1161
+ const ret = wasm.readRuntimeSessionSelection(ptr0, len0, handle, viewport_hint, workflow_context, selection_cursor);
1162
+ if (ret[2]) {
1163
+ throw takeFromExternrefTable0(ret[1]);
1164
+ }
1165
+ return takeFromExternrefTable0(ret[0]);
1166
+ }
1167
+ exports.readRuntimeSessionSelection = readRuntimeSessionSelection;
1168
+
1169
+ /**
1170
+ * @param {string} handle_id
1171
+ * @param {any} request
1172
+ * @returns {any}
1173
+ */
1174
+ function readRuntimeSessionSelectionSet(handle_id, request) {
1175
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1176
+ const len0 = WASM_VECTOR_LEN;
1177
+ const ret = wasm.readRuntimeSessionSelectionSet(ptr0, len0, request);
1178
+ if (ret[2]) {
1179
+ throw takeFromExternrefTable0(ret[1]);
1180
+ }
1181
+ return takeFromExternrefTable0(ret[0]);
1182
+ }
1183
+ exports.readRuntimeSessionSelectionSet = readRuntimeSessionSelectionSet;
1184
+
1185
+ /**
1186
+ * @param {string} handle_id
1187
+ * @param {any} viewport_hint
1188
+ * @param {any} active_handle
1189
+ * @param {any} workflow_context
1190
+ * @returns {any}
1191
+ */
1192
+ function readRuntimeSessionSheetWindow(handle_id, viewport_hint, active_handle, workflow_context) {
1193
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1194
+ const len0 = WASM_VECTOR_LEN;
1195
+ const ret = wasm.readRuntimeSessionSheetWindow(ptr0, len0, viewport_hint, active_handle, workflow_context);
1196
+ if (ret[2]) {
1197
+ throw takeFromExternrefTable0(ret[1]);
1198
+ }
1199
+ return takeFromExternrefTable0(ret[0]);
1200
+ }
1201
+ exports.readRuntimeSessionSheetWindow = readRuntimeSessionSheetWindow;
1202
+
1203
+ /**
1204
+ * T5 hybrid binary sheet-window export (`xlsx-sheet-window-binary/1`).
1205
+ *
1206
+ * Same parameters and window semantics as `readRuntimeSessionSheetWindow`;
1207
+ * returns `{ schemaId, bytes, rest }` where `bytes` carries the four bulk
1208
+ * arrays in the flat layout owned by `sheet_window_binary` and `rest` is a
1209
+ * small JSON DTO (envelope/cache/merges/rare payloads). Cache-warm hits
1210
+ * return the cached bytes verbatim — the serde-per-hit cost of the JSON
1211
+ * export (bench BR-6) is skipped entirely.
1212
+ * @param {string} handle_id
1213
+ * @param {any} viewport_hint
1214
+ * @param {any} active_handle
1215
+ * @param {any} workflow_context
1216
+ * @returns {any}
1217
+ */
1218
+ function readRuntimeSessionSheetWindowBinary(handle_id, viewport_hint, active_handle, workflow_context) {
1219
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1220
+ const len0 = WASM_VECTOR_LEN;
1221
+ const ret = wasm.readRuntimeSessionSheetWindowBinary(ptr0, len0, viewport_hint, active_handle, workflow_context);
1222
+ if (ret[2]) {
1223
+ throw takeFromExternrefTable0(ret[1]);
1224
+ }
1225
+ return takeFromExternrefTable0(ret[0]);
1226
+ }
1227
+ exports.readRuntimeSessionSheetWindowBinary = readRuntimeSessionSheetWindowBinary;
1228
+
1229
+ /**
1230
+ * @param {Uint8Array} bytes
1231
+ * @param {any} handle
1232
+ * @param {any} viewport_hint
1233
+ * @param {any} workflow_context
1234
+ * @param {any} selection_cursor
1235
+ * @returns {any}
1236
+ */
1237
+ function readSelection(bytes, handle, viewport_hint, workflow_context, selection_cursor) {
1238
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
1239
+ const len0 = WASM_VECTOR_LEN;
1240
+ const ret = wasm.readSelection(ptr0, len0, handle, viewport_hint, workflow_context, selection_cursor);
1241
+ if (ret[2]) {
1242
+ throw takeFromExternrefTable0(ret[1]);
1243
+ }
1244
+ return takeFromExternrefTable0(ret[0]);
1245
+ }
1246
+ exports.readSelection = readSelection;
1247
+
1248
+ /**
1249
+ * @param {Uint8Array} bytes
1250
+ * @param {any} request
1251
+ * @returns {any}
1252
+ */
1253
+ function readSelectionSet(bytes, request) {
1254
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
1255
+ const len0 = WASM_VECTOR_LEN;
1256
+ const ret = wasm.readSelectionSet(ptr0, len0, request);
1257
+ if (ret[2]) {
1258
+ throw takeFromExternrefTable0(ret[1]);
1259
+ }
1260
+ return takeFromExternrefTable0(ret[0]);
1261
+ }
1262
+ exports.readSelectionSet = readSelectionSet;
1263
+
1264
+ /**
1265
+ * @param {Uint8Array} bytes
1266
+ * @param {any} viewport_hint
1267
+ * @param {any} active_handle
1268
+ * @param {any} workflow_context
1269
+ * @returns {any}
1270
+ */
1271
+ function readSheetWindow(bytes, viewport_hint, active_handle, workflow_context) {
1272
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
1273
+ const len0 = WASM_VECTOR_LEN;
1274
+ const ret = wasm.readSheetWindow(ptr0, len0, viewport_hint, active_handle, workflow_context);
1275
+ if (ret[2]) {
1276
+ throw takeFromExternrefTable0(ret[1]);
1277
+ }
1278
+ return takeFromExternrefTable0(ret[0]);
1279
+ }
1280
+ exports.readSheetWindow = readSheetWindow;
1281
+
1282
+ /**
1283
+ * @param {Uint8Array} bytes
1284
+ * @param {any} request
1285
+ * @returns {any}
1286
+ */
1287
+ function readWorkflowOverlayLanes(bytes, request) {
1288
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
1289
+ const len0 = WASM_VECTOR_LEN;
1290
+ const ret = wasm.readWorkflowOverlayLanes(ptr0, len0, request);
1291
+ if (ret[2]) {
1292
+ throw takeFromExternrefTable0(ret[1]);
1293
+ }
1294
+ return takeFromExternrefTable0(ret[0]);
1295
+ }
1296
+ exports.readWorkflowOverlayLanes = readWorkflowOverlayLanes;
1297
+
1298
+ /**
1299
+ * @param {Uint8Array} bytes
1300
+ * @param {any} request
1301
+ * @returns {any}
1302
+ */
1303
+ function recalculateFormulas(bytes, request) {
1304
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
1305
+ const len0 = WASM_VECTOR_LEN;
1306
+ const ret = wasm.recalculateFormulas(ptr0, len0, request);
1307
+ if (ret[2]) {
1308
+ throw takeFromExternrefTable0(ret[1]);
1309
+ }
1310
+ return takeFromExternrefTable0(ret[0]);
1311
+ }
1312
+ exports.recalculateFormulas = recalculateFormulas;
1313
+
1314
+ /**
1315
+ * @param {string} handle_id
1316
+ * @param {any} request
1317
+ * @returns {any}
1318
+ */
1319
+ function recalculateInSession(handle_id, request) {
1320
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1321
+ const len0 = WASM_VECTOR_LEN;
1322
+ const ret = wasm.recalculateInSession(ptr0, len0, request);
1323
+ if (ret[2]) {
1324
+ throw takeFromExternrefTable0(ret[1]);
1325
+ }
1326
+ return takeFromExternrefTable0(ret[0]);
1327
+ }
1328
+ exports.recalculateInSession = recalculateInSession;
1329
+
1330
+ /**
1331
+ * @param {Uint8Array} bytes
1332
+ * @param {any} request
1333
+ * @returns {any}
1334
+ */
1335
+ function resizeColumnWidth(bytes, request) {
1336
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
1337
+ const len0 = WASM_VECTOR_LEN;
1338
+ const ret = wasm.resizeColumnWidth(ptr0, len0, request);
1339
+ if (ret[2]) {
1340
+ throw takeFromExternrefTable0(ret[1]);
1341
+ }
1342
+ return takeFromExternrefTable0(ret[0]);
1343
+ }
1344
+ exports.resizeColumnWidth = resizeColumnWidth;
1345
+
1346
+ /**
1347
+ * @param {string} handle_id
1348
+ * @param {any} request
1349
+ * @returns {any}
1350
+ */
1351
+ function resizeColumnWidthInSession(handle_id, request) {
1352
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1353
+ const len0 = WASM_VECTOR_LEN;
1354
+ const ret = wasm.resizeColumnWidthInSession(ptr0, len0, request);
1355
+ if (ret[2]) {
1356
+ throw takeFromExternrefTable0(ret[1]);
1357
+ }
1358
+ return takeFromExternrefTable0(ret[0]);
1359
+ }
1360
+ exports.resizeColumnWidthInSession = resizeColumnWidthInSession;
1361
+
1362
+ /**
1363
+ * @param {Uint8Array} bytes
1364
+ * @param {any} request
1365
+ * @returns {any}
1366
+ */
1367
+ function resizeRowHeight(bytes, request) {
1368
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
1369
+ const len0 = WASM_VECTOR_LEN;
1370
+ const ret = wasm.resizeRowHeight(ptr0, len0, request);
1371
+ if (ret[2]) {
1372
+ throw takeFromExternrefTable0(ret[1]);
1373
+ }
1374
+ return takeFromExternrefTable0(ret[0]);
1375
+ }
1376
+ exports.resizeRowHeight = resizeRowHeight;
1377
+
1378
+ /**
1379
+ * @param {string} handle_id
1380
+ * @param {any} request
1381
+ * @returns {any}
1382
+ */
1383
+ function resizeRowHeightInSession(handle_id, request) {
1384
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1385
+ const len0 = WASM_VECTOR_LEN;
1386
+ const ret = wasm.resizeRowHeightInSession(ptr0, len0, request);
1387
+ if (ret[2]) {
1388
+ throw takeFromExternrefTable0(ret[1]);
1389
+ }
1390
+ return takeFromExternrefTable0(ret[0]);
1391
+ }
1392
+ exports.resizeRowHeightInSession = resizeRowHeightInSession;
1393
+
1394
+ /**
1395
+ * @param {Uint8Array} bytes
1396
+ * @param {any} query
1397
+ * @returns {any}
1398
+ */
1399
+ function resolveReference(bytes, query) {
1400
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
1401
+ const len0 = WASM_VECTOR_LEN;
1402
+ const ret = wasm.resolveReference(ptr0, len0, query);
1403
+ if (ret[2]) {
1404
+ throw takeFromExternrefTable0(ret[1]);
1405
+ }
1406
+ return takeFromExternrefTable0(ret[0]);
1407
+ }
1408
+ exports.resolveReference = resolveReference;
1409
+
1410
+ /**
1411
+ * @param {Uint8Array} bytes
1412
+ * @param {any} request
1413
+ * @returns {any}
1414
+ */
1415
+ function setColumnHidden(bytes, request) {
1416
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
1417
+ const len0 = WASM_VECTOR_LEN;
1418
+ const ret = wasm.setColumnHidden(ptr0, len0, request);
1419
+ if (ret[2]) {
1420
+ throw takeFromExternrefTable0(ret[1]);
1421
+ }
1422
+ return takeFromExternrefTable0(ret[0]);
1423
+ }
1424
+ exports.setColumnHidden = setColumnHidden;
1425
+
1426
+ /**
1427
+ * @param {string} handle_id
1428
+ * @param {any} request
1429
+ * @returns {any}
1430
+ */
1431
+ function setColumnHiddenInSession(handle_id, request) {
1432
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1433
+ const len0 = WASM_VECTOR_LEN;
1434
+ const ret = wasm.setColumnHiddenInSession(ptr0, len0, request);
1435
+ if (ret[2]) {
1436
+ throw takeFromExternrefTable0(ret[1]);
1437
+ }
1438
+ return takeFromExternrefTable0(ret[0]);
1439
+ }
1440
+ exports.setColumnHiddenInSession = setColumnHiddenInSession;
1441
+
1442
+ /**
1443
+ * @param {Uint8Array} bytes
1444
+ * @param {any} request
1445
+ * @returns {any}
1446
+ */
1447
+ function setColumnOutlineGroupHidden(bytes, request) {
1448
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
1449
+ const len0 = WASM_VECTOR_LEN;
1450
+ const ret = wasm.setColumnOutlineGroupHidden(ptr0, len0, request);
1451
+ if (ret[2]) {
1452
+ throw takeFromExternrefTable0(ret[1]);
1453
+ }
1454
+ return takeFromExternrefTable0(ret[0]);
1455
+ }
1456
+ exports.setColumnOutlineGroupHidden = setColumnOutlineGroupHidden;
1457
+
1458
+ /**
1459
+ * X5-U-004: freeze/unfreeze panes (byte path). Applies the runtime frozen
1460
+ * pane command and, on an applied verdict, exports the mutated workbook so
1461
+ * the caller can thread the bytes forward.
1462
+ * @param {Uint8Array} bytes
1463
+ * @param {any} request
1464
+ * @returns {any}
1465
+ */
1466
+ function setFrozenPane(bytes, request) {
1467
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
1468
+ const len0 = WASM_VECTOR_LEN;
1469
+ const ret = wasm.setFrozenPane(ptr0, len0, request);
1470
+ if (ret[2]) {
1471
+ throw takeFromExternrefTable0(ret[1]);
1472
+ }
1473
+ return takeFromExternrefTable0(ret[0]);
1474
+ }
1475
+ exports.setFrozenPane = setFrozenPane;
1476
+
1477
+ /**
1478
+ * X5-U-004: freeze/unfreeze panes (session path). Adopts the mutated
1479
+ * workbook in place with the same value-neutral session bookkeeping as the
1480
+ * layout-metric commits (pane state changes no cell values, so the
1481
+ * keep-alive calc graph stays valid).
1482
+ * @param {string} handle_id
1483
+ * @param {any} request
1484
+ * @returns {any}
1485
+ */
1486
+ function setFrozenPaneInSession(handle_id, request) {
1487
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1488
+ const len0 = WASM_VECTOR_LEN;
1489
+ const ret = wasm.setFrozenPaneInSession(ptr0, len0, request);
1490
+ if (ret[2]) {
1491
+ throw takeFromExternrefTable0(ret[1]);
1492
+ }
1493
+ return takeFromExternrefTable0(ret[0]);
1494
+ }
1495
+ exports.setFrozenPaneInSession = setFrozenPaneInSession;
1496
+
1497
+ /**
1498
+ * @param {Uint8Array} bytes
1499
+ * @param {any} request
1500
+ * @returns {any}
1501
+ */
1502
+ function setRowHidden(bytes, request) {
1503
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
1504
+ const len0 = WASM_VECTOR_LEN;
1505
+ const ret = wasm.setRowHidden(ptr0, len0, request);
1506
+ if (ret[2]) {
1507
+ throw takeFromExternrefTable0(ret[1]);
1508
+ }
1509
+ return takeFromExternrefTable0(ret[0]);
1510
+ }
1511
+ exports.setRowHidden = setRowHidden;
1512
+
1513
+ /**
1514
+ * @param {string} handle_id
1515
+ * @param {any} request
1516
+ * @returns {any}
1517
+ */
1518
+ function setRowHiddenInSession(handle_id, request) {
1519
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1520
+ const len0 = WASM_VECTOR_LEN;
1521
+ const ret = wasm.setRowHiddenInSession(ptr0, len0, request);
1522
+ if (ret[2]) {
1523
+ throw takeFromExternrefTable0(ret[1]);
1524
+ }
1525
+ return takeFromExternrefTable0(ret[0]);
1526
+ }
1527
+ exports.setRowHiddenInSession = setRowHiddenInSession;
1528
+
1529
+ /**
1530
+ * @param {Uint8Array} bytes
1531
+ * @param {any} request
1532
+ * @returns {any}
1533
+ */
1534
+ function setRowOutlineGroupHidden(bytes, request) {
1535
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
1536
+ const len0 = WASM_VECTOR_LEN;
1537
+ const ret = wasm.setRowOutlineGroupHidden(ptr0, len0, request);
1538
+ if (ret[2]) {
1539
+ throw takeFromExternrefTable0(ret[1]);
1540
+ }
1541
+ return takeFromExternrefTable0(ret[0]);
1542
+ }
1543
+ exports.setRowOutlineGroupHidden = setRowOutlineGroupHidden;
1544
+
1545
+ /**
1546
+ * X5-U-005 outline authoring (byte path). Raises/lowers the outline level of
1547
+ * a row/column span, then re-exports the mutated package.
1548
+ * @param {Uint8Array} bytes
1549
+ * @param {any} request
1550
+ * @returns {any}
1551
+ */
1552
+ function setSheetOutlineLevel(bytes, request) {
1553
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
1554
+ const len0 = WASM_VECTOR_LEN;
1555
+ const ret = wasm.setSheetOutlineLevel(ptr0, len0, request);
1556
+ if (ret[2]) {
1557
+ throw takeFromExternrefTable0(ret[1]);
1558
+ }
1559
+ return takeFromExternrefTable0(ret[0]);
1560
+ }
1561
+ exports.setSheetOutlineLevel = setSheetOutlineLevel;
1562
+
1563
+ /**
1564
+ * @param {Uint8Array} bytes
1565
+ * @param {any} request
1566
+ * @returns {any}
1567
+ */
1568
+ function startKernelRun(bytes, request) {
1569
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
1570
+ const len0 = WASM_VECTOR_LEN;
1571
+ const ret = wasm.startKernelRun(ptr0, len0, request);
1572
+ if (ret[2]) {
1573
+ throw takeFromExternrefTable0(ret[1]);
1574
+ }
1575
+ return takeFromExternrefTable0(ret[0]);
1576
+ }
1577
+ exports.startKernelRun = startKernelRun;
1578
+
1579
+ /**
1580
+ * @param {Uint8Array} bytes
1581
+ * @param {any} handle
1582
+ * @param {any} viewport_hint
1583
+ * @param {any} workflow_context
1584
+ * @returns {any}
1585
+ */
1586
+ function summarizeAccessibility(bytes, handle, viewport_hint, workflow_context) {
1587
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
1588
+ const len0 = WASM_VECTOR_LEN;
1589
+ const ret = wasm.summarizeAccessibility(ptr0, len0, handle, viewport_hint, workflow_context);
1590
+ if (ret[2]) {
1591
+ throw takeFromExternrefTable0(ret[1]);
1592
+ }
1593
+ return takeFromExternrefTable0(ret[0]);
1594
+ }
1595
+ exports.summarizeAccessibility = summarizeAccessibility;
1596
+
1597
+ /**
1598
+ * @param {string} handle_id
1599
+ * @param {any} handle
1600
+ * @param {any} viewport_hint
1601
+ * @param {any} workflow_context
1602
+ * @returns {any}
1603
+ */
1604
+ function summarizeRuntimeSessionAccessibility(handle_id, handle, viewport_hint, workflow_context) {
1605
+ const ptr0 = passStringToWasm0(handle_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1606
+ const len0 = WASM_VECTOR_LEN;
1607
+ const ret = wasm.summarizeRuntimeSessionAccessibility(ptr0, len0, handle, viewport_hint, workflow_context);
1608
+ if (ret[2]) {
1609
+ throw takeFromExternrefTable0(ret[1]);
1610
+ }
1611
+ return takeFromExternrefTable0(ret[0]);
1612
+ }
1613
+ exports.summarizeRuntimeSessionAccessibility = summarizeRuntimeSessionAccessibility;
1614
+
1615
+ /**
1616
+ * @param {Uint8Array} bytes
1617
+ * @param {any} request
1618
+ * @returns {any}
1619
+ */
1620
+ function updateKernelSource(bytes, request) {
1621
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
1622
+ const len0 = WASM_VECTOR_LEN;
1623
+ const ret = wasm.updateKernelSource(ptr0, len0, request);
1624
+ if (ret[2]) {
1625
+ throw takeFromExternrefTable0(ret[1]);
1626
+ }
1627
+ return takeFromExternrefTable0(ret[0]);
1628
+ }
1629
+ exports.updateKernelSource = updateKernelSource;
1630
+
1631
+ /**
1632
+ * @param {Uint8Array} bytes
1633
+ * @param {any} request
1634
+ * @returns {any}
1635
+ */
1636
+ function validateKernelAction(bytes, request) {
1637
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
1638
+ const len0 = WASM_VECTOR_LEN;
1639
+ const ret = wasm.validateKernelAction(ptr0, len0, request);
1640
+ if (ret[2]) {
1641
+ throw takeFromExternrefTable0(ret[1]);
1642
+ }
1643
+ return takeFromExternrefTable0(ret[0]);
1644
+ }
1645
+ exports.validateKernelAction = validateKernelAction;
1646
+ function __wbg_get_imports() {
1647
+ const import0 = {
1648
+ __proto__: null,
1649
+ __wbg_Error_3639a60ed15f87e7: function(arg0, arg1) {
1650
+ const ret = Error(getStringFromWasm0(arg0, arg1));
1651
+ return ret;
1652
+ },
1653
+ __wbg_Number_a3d737fd183f7dca: function(arg0) {
1654
+ const ret = Number(arg0);
1655
+ return ret;
1656
+ },
1657
+ __wbg_String_8564e559799eccda: function(arg0, arg1) {
1658
+ const ret = String(arg1);
1659
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1660
+ const len1 = WASM_VECTOR_LEN;
1661
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
1662
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
1663
+ },
1664
+ __wbg___wbindgen_bigint_get_as_i64_3af6d4ca77193a4b: function(arg0, arg1) {
1665
+ const v = arg1;
1666
+ const ret = typeof(v) === 'bigint' ? v : undefined;
1667
+ getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
1668
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
1669
+ },
1670
+ __wbg___wbindgen_boolean_get_c3dd5c39f1b5a12b: function(arg0) {
1671
+ const v = arg0;
1672
+ const ret = typeof(v) === 'boolean' ? v : undefined;
1673
+ return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
1674
+ },
1675
+ __wbg___wbindgen_debug_string_07cb72cfcc952e2b: function(arg0, arg1) {
1676
+ const ret = debugString(arg1);
1677
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1678
+ const len1 = WASM_VECTOR_LEN;
1679
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
1680
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
1681
+ },
1682
+ __wbg___wbindgen_in_2617fa76397620d3: function(arg0, arg1) {
1683
+ const ret = arg0 in arg1;
1684
+ return ret;
1685
+ },
1686
+ __wbg___wbindgen_is_bigint_d6a8167cac401b95: function(arg0) {
1687
+ const ret = typeof(arg0) === 'bigint';
1688
+ return ret;
1689
+ },
1690
+ __wbg___wbindgen_is_function_2f0fd7ceb86e64c5: function(arg0) {
1691
+ const ret = typeof(arg0) === 'function';
1692
+ return ret;
1693
+ },
1694
+ __wbg___wbindgen_is_null_066086be3abe9bb3: function(arg0) {
1695
+ const ret = arg0 === null;
1696
+ return ret;
1697
+ },
1698
+ __wbg___wbindgen_is_object_5b22ff2418063a9c: function(arg0) {
1699
+ const val = arg0;
1700
+ const ret = typeof(val) === 'object' && val !== null;
1701
+ return ret;
1702
+ },
1703
+ __wbg___wbindgen_is_undefined_244a92c34d3b6ec0: function(arg0) {
1704
+ const ret = arg0 === undefined;
1705
+ return ret;
1706
+ },
1707
+ __wbg___wbindgen_jsval_eq_403eaa3610500a25: function(arg0, arg1) {
1708
+ const ret = arg0 === arg1;
1709
+ return ret;
1710
+ },
1711
+ __wbg___wbindgen_jsval_loose_eq_1978f1e77b4bce62: function(arg0, arg1) {
1712
+ const ret = arg0 == arg1;
1713
+ return ret;
1714
+ },
1715
+ __wbg___wbindgen_number_get_dd6d69a6079f26f1: function(arg0, arg1) {
1716
+ const obj = arg1;
1717
+ const ret = typeof(obj) === 'number' ? obj : undefined;
1718
+ getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
1719
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
1720
+ },
1721
+ __wbg___wbindgen_string_get_965592073e5d848c: function(arg0, arg1) {
1722
+ const obj = arg1;
1723
+ const ret = typeof(obj) === 'string' ? obj : undefined;
1724
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1725
+ var len1 = WASM_VECTOR_LEN;
1726
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
1727
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
1728
+ },
1729
+ __wbg___wbindgen_throw_9c75d47bf9e7731e: function(arg0, arg1) {
1730
+ throw new Error(getStringFromWasm0(arg0, arg1));
1731
+ },
1732
+ __wbg_call_add9e5a76382e668: function() { return handleError(function (arg0, arg1) {
1733
+ const ret = arg0.call(arg1);
1734
+ return ret;
1735
+ }, arguments); },
1736
+ __wbg_done_b1afd6201ac045e0: function(arg0) {
1737
+ const ret = arg0.done;
1738
+ return ret;
1739
+ },
1740
+ __wbg_entries_bb9843ba73dc70d6: function(arg0) {
1741
+ const ret = Object.entries(arg0);
1742
+ return ret;
1743
+ },
1744
+ __wbg_get_41476db20fef99a8: function() { return handleError(function (arg0, arg1) {
1745
+ const ret = Reflect.get(arg0, arg1);
1746
+ return ret;
1747
+ }, arguments); },
1748
+ __wbg_get_652f640b3b0b6e3e: function(arg0, arg1) {
1749
+ const ret = arg0[arg1 >>> 0];
1750
+ return ret;
1751
+ },
1752
+ __wbg_get_9cfea9b7bbf12a15: function() { return handleError(function (arg0, arg1) {
1753
+ const ret = Reflect.get(arg0, arg1);
1754
+ return ret;
1755
+ }, arguments); },
1756
+ __wbg_get_unchecked_be562b1421656321: function(arg0, arg1) {
1757
+ const ret = arg0[arg1 >>> 0];
1758
+ return ret;
1759
+ },
1760
+ __wbg_get_with_ref_key_6412cf3094599694: function(arg0, arg1) {
1761
+ const ret = arg0[arg1];
1762
+ return ret;
1763
+ },
1764
+ __wbg_ic_tz_parts_7a8f3f490ae2f177: function(arg0, arg1, arg2) {
1765
+ const ret = ic_tz_parts(arg0, getStringFromWasm0(arg1, arg2));
1766
+ return ret;
1767
+ },
1768
+ __wbg_ic_tz_validate_b18df67ee1109d4d: function(arg0, arg1) {
1769
+ const ret = ic_tz_validate(getStringFromWasm0(arg0, arg1));
1770
+ return ret;
1771
+ },
1772
+ __wbg_instanceof_ArrayBuffer_eab9f28fbec23477: function(arg0) {
1773
+ let result;
1774
+ try {
1775
+ result = arg0 instanceof ArrayBuffer;
1776
+ } catch (_) {
1777
+ result = false;
1778
+ }
1779
+ const ret = result;
1780
+ return ret;
1781
+ },
1782
+ __wbg_instanceof_Map_10d4edf60fcf9327: function(arg0) {
1783
+ let result;
1784
+ try {
1785
+ result = arg0 instanceof Map;
1786
+ } catch (_) {
1787
+ result = false;
1788
+ }
1789
+ const ret = result;
1790
+ return ret;
1791
+ },
1792
+ __wbg_instanceof_Uint8Array_57d77acd50e4c44d: function(arg0) {
1793
+ let result;
1794
+ try {
1795
+ result = arg0 instanceof Uint8Array;
1796
+ } catch (_) {
1797
+ result = false;
1798
+ }
1799
+ const ret = result;
1800
+ return ret;
1801
+ },
1802
+ __wbg_isArray_c6c6ef8308995bcf: function(arg0) {
1803
+ const ret = Array.isArray(arg0);
1804
+ return ret;
1805
+ },
1806
+ __wbg_isSafeInteger_3c56c421a5b4cce4: function(arg0) {
1807
+ const ret = Number.isSafeInteger(arg0);
1808
+ return ret;
1809
+ },
1810
+ __wbg_iterator_9d68985a1d096fc2: function() {
1811
+ const ret = Symbol.iterator;
1812
+ return ret;
1813
+ },
1814
+ __wbg_length_0a6ce016dc1460b0: function(arg0) {
1815
+ const ret = arg0.length;
1816
+ return ret;
1817
+ },
1818
+ __wbg_length_ba3c032602efe310: function(arg0) {
1819
+ const ret = arg0.length;
1820
+ return ret;
1821
+ },
1822
+ __wbg_new_2fad8ca02fd00684: function() {
1823
+ const ret = new Object();
1824
+ return ret;
1825
+ },
1826
+ __wbg_new_3baa8d9866155c79: function() {
1827
+ const ret = new Array();
1828
+ return ret;
1829
+ },
1830
+ __wbg_new_8454eee672b2ba6e: function(arg0) {
1831
+ const ret = new Uint8Array(arg0);
1832
+ return ret;
1833
+ },
1834
+ __wbg_new_from_slice_5a173c243af2e823: function(arg0, arg1) {
1835
+ const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
1836
+ return ret;
1837
+ },
1838
+ __wbg_next_261c3c48c6e309a5: function(arg0) {
1839
+ const ret = arg0.next;
1840
+ return ret;
1841
+ },
1842
+ __wbg_next_aacee310bcfe6461: function() { return handleError(function (arg0) {
1843
+ const ret = arg0.next();
1844
+ return ret;
1845
+ }, arguments); },
1846
+ __wbg_now_4f457f10f864aec5: function() {
1847
+ const ret = Date.now();
1848
+ return ret;
1849
+ },
1850
+ __wbg_prototypesetcall_fd4050e806e1d519: function(arg0, arg1, arg2) {
1851
+ Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
1852
+ },
1853
+ __wbg_random_fc287e2ecb3e2805: function() {
1854
+ const ret = Math.random();
1855
+ return ret;
1856
+ },
1857
+ __wbg_set_5337f8ac82364a3f: function() { return handleError(function (arg0, arg1, arg2) {
1858
+ const ret = Reflect.set(arg0, arg1, arg2);
1859
+ return ret;
1860
+ }, arguments); },
1861
+ __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
1862
+ arg0[arg1] = arg2;
1863
+ },
1864
+ __wbg_set_f614f6a0608d1d1d: function(arg0, arg1, arg2) {
1865
+ arg0[arg1 >>> 0] = arg2;
1866
+ },
1867
+ __wbg_static_accessor_GLOBAL_THIS_1c7f1bd6c6941fdb: function() {
1868
+ const ret = typeof globalThis === 'undefined' ? null : globalThis;
1869
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
1870
+ },
1871
+ __wbg_static_accessor_GLOBAL_e039bc914f83e74e: function() {
1872
+ const ret = typeof global === 'undefined' ? null : global;
1873
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
1874
+ },
1875
+ __wbg_static_accessor_SELF_8bf8c48c28420ad5: function() {
1876
+ const ret = typeof self === 'undefined' ? null : self;
1877
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
1878
+ },
1879
+ __wbg_static_accessor_WINDOW_6aeee9b51652ee0f: function() {
1880
+ const ret = typeof window === 'undefined' ? null : window;
1881
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
1882
+ },
1883
+ __wbg_value_f852716acdeb3e82: function(arg0) {
1884
+ const ret = arg0.value;
1885
+ return ret;
1886
+ },
1887
+ __wbindgen_cast_0000000000000001: function(arg0) {
1888
+ // Cast intrinsic for `F64 -> Externref`.
1889
+ const ret = arg0;
1890
+ return ret;
1891
+ },
1892
+ __wbindgen_cast_0000000000000002: function(arg0) {
1893
+ // Cast intrinsic for `I64 -> Externref`.
1894
+ const ret = arg0;
1895
+ return ret;
1896
+ },
1897
+ __wbindgen_cast_0000000000000003: function(arg0, arg1) {
1898
+ // Cast intrinsic for `Ref(String) -> Externref`.
1899
+ const ret = getStringFromWasm0(arg0, arg1);
1900
+ return ret;
1901
+ },
1902
+ __wbindgen_cast_0000000000000004: function(arg0) {
1903
+ // Cast intrinsic for `U64 -> Externref`.
1904
+ const ret = BigInt.asUintN(64, arg0);
1905
+ return ret;
1906
+ },
1907
+ __wbindgen_init_externref_table: function() {
1908
+ const table = wasm.__wbindgen_externrefs;
1909
+ const offset = table.grow(4);
1910
+ table.set(0, undefined);
1911
+ table.set(offset + 0, undefined);
1912
+ table.set(offset + 1, null);
1913
+ table.set(offset + 2, true);
1914
+ table.set(offset + 3, false);
1915
+ },
1916
+ };
1917
+ return {
1918
+ __proto__: null,
1919
+ "./xlsx_substrate_wasm_bg.js": import0,
1920
+ };
1921
+ }
1922
+
1923
+ function addToExternrefTable0(obj) {
1924
+ const idx = wasm.__externref_table_alloc();
1925
+ wasm.__wbindgen_externrefs.set(idx, obj);
1926
+ return idx;
1927
+ }
1928
+
1929
+ function debugString(val) {
1930
+ // primitive types
1931
+ const type = typeof val;
1932
+ if (type == 'number' || type == 'boolean' || val == null) {
1933
+ return `${val}`;
1934
+ }
1935
+ if (type == 'string') {
1936
+ return `"${val}"`;
1937
+ }
1938
+ if (type == 'symbol') {
1939
+ const description = val.description;
1940
+ if (description == null) {
1941
+ return 'Symbol';
1942
+ } else {
1943
+ return `Symbol(${description})`;
1944
+ }
1945
+ }
1946
+ if (type == 'function') {
1947
+ const name = val.name;
1948
+ if (typeof name == 'string' && name.length > 0) {
1949
+ return `Function(${name})`;
1950
+ } else {
1951
+ return 'Function';
1952
+ }
1953
+ }
1954
+ // objects
1955
+ if (Array.isArray(val)) {
1956
+ const length = val.length;
1957
+ let debug = '[';
1958
+ if (length > 0) {
1959
+ debug += debugString(val[0]);
1960
+ }
1961
+ for(let i = 1; i < length; i++) {
1962
+ debug += ', ' + debugString(val[i]);
1963
+ }
1964
+ debug += ']';
1965
+ return debug;
1966
+ }
1967
+ // Test for built-in
1968
+ const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
1969
+ let className;
1970
+ if (builtInMatches && builtInMatches.length > 1) {
1971
+ className = builtInMatches[1];
1972
+ } else {
1973
+ // Failed to match the standard '[object ClassName]'
1974
+ return toString.call(val);
1975
+ }
1976
+ if (className == 'Object') {
1977
+ // we're a user defined class or Object
1978
+ // JSON.stringify avoids problems with cycles, and is generally much
1979
+ // easier than looping through ownProperties of `val`.
1980
+ try {
1981
+ return 'Object(' + JSON.stringify(val) + ')';
1982
+ } catch (_) {
1983
+ return 'Object';
1984
+ }
1985
+ }
1986
+ // errors
1987
+ if (val instanceof Error) {
1988
+ return `${val.name}: ${val.message}\n${val.stack}`;
1989
+ }
1990
+ // TODO we could test for more things here, like `Set`s and `Map`s.
1991
+ return className;
1992
+ }
1993
+
1994
+ function getArrayU8FromWasm0(ptr, len) {
1995
+ ptr = ptr >>> 0;
1996
+ return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
1997
+ }
1998
+
1999
+ let cachedDataViewMemory0 = null;
2000
+ function getDataViewMemory0() {
2001
+ if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
2002
+ cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
2003
+ }
2004
+ return cachedDataViewMemory0;
2005
+ }
2006
+
2007
+ function getStringFromWasm0(ptr, len) {
2008
+ return decodeText(ptr >>> 0, len);
2009
+ }
2010
+
2011
+ let cachedUint8ArrayMemory0 = null;
2012
+ function getUint8ArrayMemory0() {
2013
+ if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
2014
+ cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
2015
+ }
2016
+ return cachedUint8ArrayMemory0;
2017
+ }
2018
+
2019
+ function handleError(f, args) {
2020
+ try {
2021
+ return f.apply(this, args);
2022
+ } catch (e) {
2023
+ const idx = addToExternrefTable0(e);
2024
+ wasm.__wbindgen_exn_store(idx);
2025
+ }
2026
+ }
2027
+
2028
+ function isLikeNone(x) {
2029
+ return x === undefined || x === null;
2030
+ }
2031
+
2032
+ function passArray8ToWasm0(arg, malloc) {
2033
+ const ptr = malloc(arg.length * 1, 1) >>> 0;
2034
+ getUint8ArrayMemory0().set(arg, ptr / 1);
2035
+ WASM_VECTOR_LEN = arg.length;
2036
+ return ptr;
2037
+ }
2038
+
2039
+ function passStringToWasm0(arg, malloc, realloc) {
2040
+ if (realloc === undefined) {
2041
+ const buf = cachedTextEncoder.encode(arg);
2042
+ const ptr = malloc(buf.length, 1) >>> 0;
2043
+ getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
2044
+ WASM_VECTOR_LEN = buf.length;
2045
+ return ptr;
2046
+ }
2047
+
2048
+ let len = arg.length;
2049
+ let ptr = malloc(len, 1) >>> 0;
2050
+
2051
+ const mem = getUint8ArrayMemory0();
2052
+
2053
+ let offset = 0;
2054
+
2055
+ for (; offset < len; offset++) {
2056
+ const code = arg.charCodeAt(offset);
2057
+ if (code > 0x7F) break;
2058
+ mem[ptr + offset] = code;
2059
+ }
2060
+ if (offset !== len) {
2061
+ if (offset !== 0) {
2062
+ arg = arg.slice(offset);
2063
+ }
2064
+ ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
2065
+ const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
2066
+ const ret = cachedTextEncoder.encodeInto(arg, view);
2067
+
2068
+ offset += ret.written;
2069
+ ptr = realloc(ptr, len, offset, 1) >>> 0;
2070
+ }
2071
+
2072
+ WASM_VECTOR_LEN = offset;
2073
+ return ptr;
2074
+ }
2075
+
2076
+ function takeFromExternrefTable0(idx) {
2077
+ const value = wasm.__wbindgen_externrefs.get(idx);
2078
+ wasm.__externref_table_dealloc(idx);
2079
+ return value;
2080
+ }
2081
+
2082
+ let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
2083
+ cachedTextDecoder.decode();
2084
+ function decodeText(ptr, len) {
2085
+ return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
2086
+ }
2087
+
2088
+ const cachedTextEncoder = new TextEncoder();
2089
+
2090
+ if (!('encodeInto' in cachedTextEncoder)) {
2091
+ cachedTextEncoder.encodeInto = function (arg, view) {
2092
+ const buf = cachedTextEncoder.encode(arg);
2093
+ view.set(buf);
2094
+ return {
2095
+ read: arg.length,
2096
+ written: buf.length
2097
+ };
2098
+ };
2099
+ }
2100
+
2101
+ let WASM_VECTOR_LEN = 0;
2102
+
2103
+ const wasmPath = `${__dirname}/xlsx_substrate_wasm_bg.wasm`;
2104
+ const wasmBytes = require('fs').readFileSync(wasmPath);
2105
+ const wasmModule = new WebAssembly.Module(wasmBytes);
2106
+ let wasmInstance = new WebAssembly.Instance(wasmModule, __wbg_get_imports());
2107
+ let wasm = wasmInstance.exports;
2108
+ wasm.__wbindgen_start();