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