@beyondwork/xlsx-substrate-bindings 0.1.0 → 0.3.1

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