windmill-parser-wasm-ts 1.438.1 → 1.486.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/package.json +2 -2
- package/windmill_parser_wasm.d.ts +12 -23
- package/windmill_parser_wasm.js +251 -279
- package/windmill_parser_wasm_bg.wasm +0 -0
package/package.json
CHANGED
|
@@ -4,7 +4,7 @@
|
|
|
4
4
|
"collaborators": [
|
|
5
5
|
"Ruben Fiszel <ruben@windmill.dev>"
|
|
6
6
|
],
|
|
7
|
-
"version": "1.
|
|
7
|
+
"version": "1.486.1",
|
|
8
8
|
"files": [
|
|
9
9
|
"windmill_parser_wasm_bg.wasm",
|
|
10
10
|
"windmill_parser_wasm.js",
|
|
@@ -15,4 +15,4 @@
|
|
|
15
15
|
"sideEffects": [
|
|
16
16
|
"./snippets/*"
|
|
17
17
|
]
|
|
18
|
-
}
|
|
18
|
+
}
|
|
@@ -1,34 +1,23 @@
|
|
|
1
1
|
/* tslint:disable */
|
|
2
2
|
/* eslint-disable */
|
|
3
|
-
|
|
4
|
-
* @param {string} code
|
|
5
|
-
* @param {string | undefined} [main_override]
|
|
6
|
-
* @returns {string}
|
|
7
|
-
*/
|
|
8
|
-
export function parse_deno(code: string, main_override?: string): string;
|
|
9
|
-
/**
|
|
10
|
-
* @param {string} code
|
|
11
|
-
* @returns {string}
|
|
12
|
-
*/
|
|
3
|
+
export function parse_deno(code: string, main_override?: string | null): string;
|
|
13
4
|
export function parse_outputs(code: string): string;
|
|
14
|
-
/**
|
|
15
|
-
* @param {string} code
|
|
16
|
-
* @returns {string}
|
|
17
|
-
*/
|
|
18
5
|
export function parse_ts_imports(code: string): string;
|
|
19
6
|
|
|
20
7
|
export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
|
|
21
8
|
|
|
22
9
|
export interface InitOutput {
|
|
23
10
|
readonly memory: WebAssembly.Memory;
|
|
24
|
-
readonly parse_deno: (a: number, b: number, c: number, d: number
|
|
25
|
-
readonly parse_outputs: (a: number, b: number
|
|
26
|
-
readonly parse_ts_imports: (a: number, b: number
|
|
11
|
+
readonly parse_deno: (a: number, b: number, c: number, d: number) => [number, number];
|
|
12
|
+
readonly parse_outputs: (a: number, b: number) => [number, number];
|
|
13
|
+
readonly parse_ts_imports: (a: number, b: number) => [number, number];
|
|
14
|
+
readonly __wbindgen_exn_store: (a: number) => void;
|
|
15
|
+
readonly __externref_table_alloc: () => number;
|
|
16
|
+
readonly __wbindgen_export_2: WebAssembly.Table;
|
|
27
17
|
readonly __wbindgen_malloc: (a: number, b: number) => number;
|
|
28
18
|
readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
|
|
29
|
-
readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
|
|
30
19
|
readonly __wbindgen_free: (a: number, b: number, c: number) => void;
|
|
31
|
-
readonly
|
|
20
|
+
readonly __wbindgen_start: () => void;
|
|
32
21
|
}
|
|
33
22
|
|
|
34
23
|
export type SyncInitInput = BufferSource | WebAssembly.Module;
|
|
@@ -36,18 +25,18 @@ export type SyncInitInput = BufferSource | WebAssembly.Module;
|
|
|
36
25
|
* Instantiates the given `module`, which can either be bytes or
|
|
37
26
|
* a precompiled `WebAssembly.Module`.
|
|
38
27
|
*
|
|
39
|
-
* @param {SyncInitInput} module
|
|
28
|
+
* @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
|
|
40
29
|
*
|
|
41
30
|
* @returns {InitOutput}
|
|
42
31
|
*/
|
|
43
|
-
export function initSync(module: SyncInitInput): InitOutput;
|
|
32
|
+
export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
|
|
44
33
|
|
|
45
34
|
/**
|
|
46
35
|
* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
|
|
47
36
|
* for everything else, calls `WebAssembly.instantiate` directly.
|
|
48
37
|
*
|
|
49
|
-
* @param {InitInput | Promise<InitInput>} module_or_path
|
|
38
|
+
* @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
|
|
50
39
|
*
|
|
51
40
|
* @returns {Promise<InitOutput>}
|
|
52
41
|
*/
|
|
53
|
-
export default function __wbg_init (module_or_path?: InitInput | Promise<InitInput>): Promise<InitOutput>;
|
|
42
|
+
export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;
|
package/windmill_parser_wasm.js
CHANGED
|
@@ -1,137 +1,49 @@
|
|
|
1
1
|
let wasm;
|
|
2
2
|
|
|
3
|
-
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
function getObject(idx) { return heap[idx]; }
|
|
8
|
-
|
|
9
|
-
let heap_next = heap.length;
|
|
10
|
-
|
|
11
|
-
function dropObject(idx) {
|
|
12
|
-
if (idx < 132) return;
|
|
13
|
-
heap[idx] = heap_next;
|
|
14
|
-
heap_next = idx;
|
|
15
|
-
}
|
|
16
|
-
|
|
17
|
-
function takeObject(idx) {
|
|
18
|
-
const ret = getObject(idx);
|
|
19
|
-
dropObject(idx);
|
|
20
|
-
return ret;
|
|
3
|
+
function addToExternrefTable0(obj) {
|
|
4
|
+
const idx = wasm.__externref_table_alloc();
|
|
5
|
+
wasm.__wbindgen_export_2.set(idx, obj);
|
|
6
|
+
return idx;
|
|
21
7
|
}
|
|
22
8
|
|
|
23
|
-
function
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
9
|
+
function handleError(f, args) {
|
|
10
|
+
try {
|
|
11
|
+
return f.apply(this, args);
|
|
12
|
+
} catch (e) {
|
|
13
|
+
const idx = addToExternrefTable0(e);
|
|
14
|
+
wasm.__wbindgen_exn_store(idx);
|
|
15
|
+
}
|
|
30
16
|
}
|
|
31
17
|
|
|
32
18
|
const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
|
|
33
19
|
|
|
34
20
|
if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
|
|
35
21
|
|
|
36
|
-
let
|
|
22
|
+
let cachedUint8ArrayMemory0 = null;
|
|
37
23
|
|
|
38
|
-
function
|
|
39
|
-
if (
|
|
40
|
-
|
|
24
|
+
function getUint8ArrayMemory0() {
|
|
25
|
+
if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
|
|
26
|
+
cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
|
|
41
27
|
}
|
|
42
|
-
return
|
|
28
|
+
return cachedUint8ArrayMemory0;
|
|
43
29
|
}
|
|
44
30
|
|
|
45
31
|
function getStringFromWasm0(ptr, len) {
|
|
46
32
|
ptr = ptr >>> 0;
|
|
47
|
-
return cachedTextDecoder.decode(
|
|
33
|
+
return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
|
|
48
34
|
}
|
|
49
35
|
|
|
50
36
|
function isLikeNone(x) {
|
|
51
37
|
return x === undefined || x === null;
|
|
52
38
|
}
|
|
53
39
|
|
|
54
|
-
let
|
|
55
|
-
|
|
56
|
-
function getFloat64Memory0() {
|
|
57
|
-
if (cachedFloat64Memory0 === null || cachedFloat64Memory0.byteLength === 0) {
|
|
58
|
-
cachedFloat64Memory0 = new Float64Array(wasm.memory.buffer);
|
|
59
|
-
}
|
|
60
|
-
return cachedFloat64Memory0;
|
|
61
|
-
}
|
|
62
|
-
|
|
63
|
-
let cachedInt32Memory0 = null;
|
|
40
|
+
let cachedDataViewMemory0 = null;
|
|
64
41
|
|
|
65
|
-
function
|
|
66
|
-
if (
|
|
67
|
-
|
|
42
|
+
function getDataViewMemory0() {
|
|
43
|
+
if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
|
|
44
|
+
cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
|
|
68
45
|
}
|
|
69
|
-
return
|
|
70
|
-
}
|
|
71
|
-
|
|
72
|
-
let WASM_VECTOR_LEN = 0;
|
|
73
|
-
|
|
74
|
-
const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
|
|
75
|
-
|
|
76
|
-
const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
|
|
77
|
-
? function (arg, view) {
|
|
78
|
-
return cachedTextEncoder.encodeInto(arg, view);
|
|
79
|
-
}
|
|
80
|
-
: function (arg, view) {
|
|
81
|
-
const buf = cachedTextEncoder.encode(arg);
|
|
82
|
-
view.set(buf);
|
|
83
|
-
return {
|
|
84
|
-
read: arg.length,
|
|
85
|
-
written: buf.length
|
|
86
|
-
};
|
|
87
|
-
});
|
|
88
|
-
|
|
89
|
-
function passStringToWasm0(arg, malloc, realloc) {
|
|
90
|
-
|
|
91
|
-
if (realloc === undefined) {
|
|
92
|
-
const buf = cachedTextEncoder.encode(arg);
|
|
93
|
-
const ptr = malloc(buf.length, 1) >>> 0;
|
|
94
|
-
getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
|
|
95
|
-
WASM_VECTOR_LEN = buf.length;
|
|
96
|
-
return ptr;
|
|
97
|
-
}
|
|
98
|
-
|
|
99
|
-
let len = arg.length;
|
|
100
|
-
let ptr = malloc(len, 1) >>> 0;
|
|
101
|
-
|
|
102
|
-
const mem = getUint8Memory0();
|
|
103
|
-
|
|
104
|
-
let offset = 0;
|
|
105
|
-
|
|
106
|
-
for (; offset < len; offset++) {
|
|
107
|
-
const code = arg.charCodeAt(offset);
|
|
108
|
-
if (code > 0x7F) break;
|
|
109
|
-
mem[ptr + offset] = code;
|
|
110
|
-
}
|
|
111
|
-
|
|
112
|
-
if (offset !== len) {
|
|
113
|
-
if (offset !== 0) {
|
|
114
|
-
arg = arg.slice(offset);
|
|
115
|
-
}
|
|
116
|
-
ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
|
|
117
|
-
const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
|
|
118
|
-
const ret = encodeString(arg, view);
|
|
119
|
-
|
|
120
|
-
offset += ret.written;
|
|
121
|
-
ptr = realloc(ptr, len, offset, 1) >>> 0;
|
|
122
|
-
}
|
|
123
|
-
|
|
124
|
-
WASM_VECTOR_LEN = offset;
|
|
125
|
-
return ptr;
|
|
126
|
-
}
|
|
127
|
-
|
|
128
|
-
let cachedBigInt64Memory0 = null;
|
|
129
|
-
|
|
130
|
-
function getBigInt64Memory0() {
|
|
131
|
-
if (cachedBigInt64Memory0 === null || cachedBigInt64Memory0.byteLength === 0) {
|
|
132
|
-
cachedBigInt64Memory0 = new BigInt64Array(wasm.memory.buffer);
|
|
133
|
-
}
|
|
134
|
-
return cachedBigInt64Memory0;
|
|
46
|
+
return cachedDataViewMemory0;
|
|
135
47
|
}
|
|
136
48
|
|
|
137
49
|
function debugString(val) {
|
|
@@ -175,7 +87,7 @@ function debugString(val) {
|
|
|
175
87
|
// Test for built-in
|
|
176
88
|
const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
|
|
177
89
|
let className;
|
|
178
|
-
if (builtInMatches.length > 1) {
|
|
90
|
+
if (builtInMatches && builtInMatches.length > 1) {
|
|
179
91
|
className = builtInMatches[1];
|
|
180
92
|
} else {
|
|
181
93
|
// Failed to match the standard '[object ClassName]'
|
|
@@ -198,86 +110,122 @@ function debugString(val) {
|
|
|
198
110
|
// TODO we could test for more things here, like `Set`s and `Map`s.
|
|
199
111
|
return className;
|
|
200
112
|
}
|
|
113
|
+
|
|
114
|
+
let WASM_VECTOR_LEN = 0;
|
|
115
|
+
|
|
116
|
+
const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
|
|
117
|
+
|
|
118
|
+
const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
|
|
119
|
+
? function (arg, view) {
|
|
120
|
+
return cachedTextEncoder.encodeInto(arg, view);
|
|
121
|
+
}
|
|
122
|
+
: function (arg, view) {
|
|
123
|
+
const buf = cachedTextEncoder.encode(arg);
|
|
124
|
+
view.set(buf);
|
|
125
|
+
return {
|
|
126
|
+
read: arg.length,
|
|
127
|
+
written: buf.length
|
|
128
|
+
};
|
|
129
|
+
});
|
|
130
|
+
|
|
131
|
+
function passStringToWasm0(arg, malloc, realloc) {
|
|
132
|
+
|
|
133
|
+
if (realloc === undefined) {
|
|
134
|
+
const buf = cachedTextEncoder.encode(arg);
|
|
135
|
+
const ptr = malloc(buf.length, 1) >>> 0;
|
|
136
|
+
getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
|
|
137
|
+
WASM_VECTOR_LEN = buf.length;
|
|
138
|
+
return ptr;
|
|
139
|
+
}
|
|
140
|
+
|
|
141
|
+
let len = arg.length;
|
|
142
|
+
let ptr = malloc(len, 1) >>> 0;
|
|
143
|
+
|
|
144
|
+
const mem = getUint8ArrayMemory0();
|
|
145
|
+
|
|
146
|
+
let offset = 0;
|
|
147
|
+
|
|
148
|
+
for (; offset < len; offset++) {
|
|
149
|
+
const code = arg.charCodeAt(offset);
|
|
150
|
+
if (code > 0x7F) break;
|
|
151
|
+
mem[ptr + offset] = code;
|
|
152
|
+
}
|
|
153
|
+
|
|
154
|
+
if (offset !== len) {
|
|
155
|
+
if (offset !== 0) {
|
|
156
|
+
arg = arg.slice(offset);
|
|
157
|
+
}
|
|
158
|
+
ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
|
|
159
|
+
const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
|
|
160
|
+
const ret = encodeString(arg, view);
|
|
161
|
+
|
|
162
|
+
offset += ret.written;
|
|
163
|
+
ptr = realloc(ptr, len, offset, 1) >>> 0;
|
|
164
|
+
}
|
|
165
|
+
|
|
166
|
+
WASM_VECTOR_LEN = offset;
|
|
167
|
+
return ptr;
|
|
168
|
+
}
|
|
201
169
|
/**
|
|
202
|
-
* @param {string} code
|
|
203
|
-
* @param {string |
|
|
204
|
-
* @returns {string}
|
|
205
|
-
*/
|
|
170
|
+
* @param {string} code
|
|
171
|
+
* @param {string | null} [main_override]
|
|
172
|
+
* @returns {string}
|
|
173
|
+
*/
|
|
206
174
|
export function parse_deno(code, main_override) {
|
|
207
175
|
let deferred3_0;
|
|
208
176
|
let deferred3_1;
|
|
209
177
|
try {
|
|
210
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
211
178
|
const ptr0 = passStringToWasm0(code, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
212
179
|
const len0 = WASM_VECTOR_LEN;
|
|
213
180
|
var ptr1 = isLikeNone(main_override) ? 0 : passStringToWasm0(main_override, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
214
181
|
var len1 = WASM_VECTOR_LEN;
|
|
215
|
-
wasm.parse_deno(
|
|
216
|
-
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
deferred3_1 = r1;
|
|
220
|
-
return getStringFromWasm0(r0, r1);
|
|
182
|
+
const ret = wasm.parse_deno(ptr0, len0, ptr1, len1);
|
|
183
|
+
deferred3_0 = ret[0];
|
|
184
|
+
deferred3_1 = ret[1];
|
|
185
|
+
return getStringFromWasm0(ret[0], ret[1]);
|
|
221
186
|
} finally {
|
|
222
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
223
187
|
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
224
188
|
}
|
|
225
189
|
}
|
|
226
190
|
|
|
227
191
|
/**
|
|
228
|
-
* @param {string} code
|
|
229
|
-
* @returns {string}
|
|
230
|
-
*/
|
|
192
|
+
* @param {string} code
|
|
193
|
+
* @returns {string}
|
|
194
|
+
*/
|
|
231
195
|
export function parse_outputs(code) {
|
|
232
196
|
let deferred2_0;
|
|
233
197
|
let deferred2_1;
|
|
234
198
|
try {
|
|
235
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
236
199
|
const ptr0 = passStringToWasm0(code, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
237
200
|
const len0 = WASM_VECTOR_LEN;
|
|
238
|
-
wasm.parse_outputs(
|
|
239
|
-
|
|
240
|
-
|
|
241
|
-
|
|
242
|
-
deferred2_1 = r1;
|
|
243
|
-
return getStringFromWasm0(r0, r1);
|
|
201
|
+
const ret = wasm.parse_outputs(ptr0, len0);
|
|
202
|
+
deferred2_0 = ret[0];
|
|
203
|
+
deferred2_1 = ret[1];
|
|
204
|
+
return getStringFromWasm0(ret[0], ret[1]);
|
|
244
205
|
} finally {
|
|
245
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
246
206
|
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
247
207
|
}
|
|
248
208
|
}
|
|
249
209
|
|
|
250
210
|
/**
|
|
251
|
-
* @param {string} code
|
|
252
|
-
* @returns {string}
|
|
253
|
-
*/
|
|
211
|
+
* @param {string} code
|
|
212
|
+
* @returns {string}
|
|
213
|
+
*/
|
|
254
214
|
export function parse_ts_imports(code) {
|
|
255
215
|
let deferred2_0;
|
|
256
216
|
let deferred2_1;
|
|
257
217
|
try {
|
|
258
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
259
218
|
const ptr0 = passStringToWasm0(code, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
260
219
|
const len0 = WASM_VECTOR_LEN;
|
|
261
|
-
wasm.parse_ts_imports(
|
|
262
|
-
|
|
263
|
-
|
|
264
|
-
|
|
265
|
-
deferred2_1 = r1;
|
|
266
|
-
return getStringFromWasm0(r0, r1);
|
|
220
|
+
const ret = wasm.parse_ts_imports(ptr0, len0);
|
|
221
|
+
deferred2_0 = ret[0];
|
|
222
|
+
deferred2_1 = ret[1];
|
|
223
|
+
return getStringFromWasm0(ret[0], ret[1]);
|
|
267
224
|
} finally {
|
|
268
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
269
225
|
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
270
226
|
}
|
|
271
227
|
}
|
|
272
228
|
|
|
273
|
-
function handleError(f, args) {
|
|
274
|
-
try {
|
|
275
|
-
return f.apply(this, args);
|
|
276
|
-
} catch (e) {
|
|
277
|
-
wasm.__wbindgen_exn_store(addHeapObject(e));
|
|
278
|
-
}
|
|
279
|
-
}
|
|
280
|
-
|
|
281
229
|
async function __wbg_load(module, imports) {
|
|
282
230
|
if (typeof Response === 'function' && module instanceof Response) {
|
|
283
231
|
if (typeof WebAssembly.instantiateStreaming === 'function') {
|
|
@@ -286,7 +234,7 @@ async function __wbg_load(module, imports) {
|
|
|
286
234
|
|
|
287
235
|
} catch (e) {
|
|
288
236
|
if (module.headers.get('Content-Type') != 'application/wasm') {
|
|
289
|
-
console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve
|
|
237
|
+
console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
|
|
290
238
|
|
|
291
239
|
} else {
|
|
292
240
|
throw e;
|
|
@@ -312,205 +260,220 @@ async function __wbg_load(module, imports) {
|
|
|
312
260
|
function __wbg_get_imports() {
|
|
313
261
|
const imports = {};
|
|
314
262
|
imports.wbg = {};
|
|
315
|
-
imports.wbg.
|
|
316
|
-
const ret =
|
|
317
|
-
return addHeapObject(ret);
|
|
318
|
-
};
|
|
319
|
-
imports.wbg.__wbg_length_cd7af8117672b8b8 = function(arg0) {
|
|
320
|
-
const ret = getObject(arg0).length;
|
|
321
|
-
return ret;
|
|
322
|
-
};
|
|
323
|
-
imports.wbg.__wbindgen_is_object = function(arg0) {
|
|
324
|
-
const val = getObject(arg0);
|
|
325
|
-
const ret = typeof(val) === 'object' && val !== null;
|
|
263
|
+
imports.wbg.__wbg_buffer_609cc3eee51ed158 = function(arg0) {
|
|
264
|
+
const ret = arg0.buffer;
|
|
326
265
|
return ret;
|
|
327
266
|
};
|
|
328
|
-
imports.wbg.
|
|
329
|
-
const ret =
|
|
330
|
-
return addHeapObject(ret);
|
|
331
|
-
};
|
|
332
|
-
imports.wbg.__wbindgen_is_function = function(arg0) {
|
|
333
|
-
const ret = typeof(getObject(arg0)) === 'function';
|
|
267
|
+
imports.wbg.__wbg_call_672a4d21634d4a24 = function() { return handleError(function (arg0, arg1) {
|
|
268
|
+
const ret = arg0.call(arg1);
|
|
334
269
|
return ret;
|
|
335
|
-
};
|
|
336
|
-
imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
|
|
337
|
-
takeObject(arg0);
|
|
338
|
-
};
|
|
339
|
-
imports.wbg.__wbg_next_196c84450b364254 = function() { return handleError(function (arg0) {
|
|
340
|
-
const ret = getObject(arg0).next();
|
|
341
|
-
return addHeapObject(ret);
|
|
342
270
|
}, arguments) };
|
|
343
|
-
imports.wbg.
|
|
344
|
-
const ret =
|
|
271
|
+
imports.wbg.__wbg_done_769e5ede4b31c67b = function(arg0) {
|
|
272
|
+
const ret = arg0.done;
|
|
345
273
|
return ret;
|
|
346
274
|
};
|
|
347
|
-
imports.wbg.
|
|
348
|
-
const ret =
|
|
349
|
-
return
|
|
275
|
+
imports.wbg.__wbg_entries_3265d4158b33e5dc = function(arg0) {
|
|
276
|
+
const ret = Object.entries(arg0);
|
|
277
|
+
return ret;
|
|
350
278
|
};
|
|
351
|
-
imports.wbg.
|
|
352
|
-
const ret =
|
|
353
|
-
return
|
|
279
|
+
imports.wbg.__wbg_eval_71dda4bf7abd54ec = function(arg0, arg1) {
|
|
280
|
+
const ret = eval(getStringFromWasm0(arg0, arg1));
|
|
281
|
+
return ret;
|
|
354
282
|
};
|
|
355
|
-
imports.wbg.
|
|
356
|
-
const ret = Reflect.get(
|
|
357
|
-
return
|
|
358
|
-
}, arguments) };
|
|
359
|
-
imports.wbg.__wbg_call_27c0f87801dedf93 = function() { return handleError(function (arg0, arg1) {
|
|
360
|
-
const ret = getObject(arg0).call(getObject(arg1));
|
|
361
|
-
return addHeapObject(ret);
|
|
283
|
+
imports.wbg.__wbg_get_67b2ba62fc30de12 = function() { return handleError(function (arg0, arg1) {
|
|
284
|
+
const ret = Reflect.get(arg0, arg1);
|
|
285
|
+
return ret;
|
|
362
286
|
}, arguments) };
|
|
363
|
-
imports.wbg.
|
|
364
|
-
const ret =
|
|
287
|
+
imports.wbg.__wbg_get_b9b93047fe3cf45b = function(arg0, arg1) {
|
|
288
|
+
const ret = arg0[arg1 >>> 0];
|
|
365
289
|
return ret;
|
|
366
290
|
};
|
|
367
|
-
imports.wbg.
|
|
291
|
+
imports.wbg.__wbg_instanceof_ArrayBuffer_e14585432e3737fc = function(arg0) {
|
|
368
292
|
let result;
|
|
369
293
|
try {
|
|
370
|
-
result =
|
|
294
|
+
result = arg0 instanceof ArrayBuffer;
|
|
371
295
|
} catch (_) {
|
|
372
296
|
result = false;
|
|
373
297
|
}
|
|
374
298
|
const ret = result;
|
|
375
299
|
return ret;
|
|
376
300
|
};
|
|
377
|
-
imports.wbg.
|
|
301
|
+
imports.wbg.__wbg_instanceof_Map_f3469ce2244d2430 = function(arg0) {
|
|
378
302
|
let result;
|
|
379
303
|
try {
|
|
380
|
-
result =
|
|
304
|
+
result = arg0 instanceof Map;
|
|
381
305
|
} catch (_) {
|
|
382
306
|
result = false;
|
|
383
307
|
}
|
|
384
308
|
const ret = result;
|
|
385
309
|
return ret;
|
|
386
310
|
};
|
|
387
|
-
imports.wbg.
|
|
388
|
-
|
|
311
|
+
imports.wbg.__wbg_instanceof_Uint8Array_17156bcf118086a9 = function(arg0) {
|
|
312
|
+
let result;
|
|
313
|
+
try {
|
|
314
|
+
result = arg0 instanceof Uint8Array;
|
|
315
|
+
} catch (_) {
|
|
316
|
+
result = false;
|
|
317
|
+
}
|
|
318
|
+
const ret = result;
|
|
389
319
|
return ret;
|
|
390
320
|
};
|
|
391
|
-
imports.wbg.
|
|
392
|
-
const ret =
|
|
393
|
-
return
|
|
394
|
-
};
|
|
395
|
-
imports.wbg.__wbindgen_memory = function() {
|
|
396
|
-
const ret = wasm.memory;
|
|
397
|
-
return addHeapObject(ret);
|
|
321
|
+
imports.wbg.__wbg_isArray_a1eab7e0d067391b = function(arg0) {
|
|
322
|
+
const ret = Array.isArray(arg0);
|
|
323
|
+
return ret;
|
|
398
324
|
};
|
|
399
|
-
imports.wbg.
|
|
400
|
-
const ret =
|
|
401
|
-
return
|
|
325
|
+
imports.wbg.__wbg_isSafeInteger_343e2beeeece1bb0 = function(arg0) {
|
|
326
|
+
const ret = Number.isSafeInteger(arg0);
|
|
327
|
+
return ret;
|
|
402
328
|
};
|
|
403
|
-
imports.wbg.
|
|
404
|
-
const ret =
|
|
405
|
-
return
|
|
329
|
+
imports.wbg.__wbg_iterator_9a24c88df860dc65 = function() {
|
|
330
|
+
const ret = Symbol.iterator;
|
|
331
|
+
return ret;
|
|
406
332
|
};
|
|
407
|
-
imports.wbg.
|
|
408
|
-
|
|
333
|
+
imports.wbg.__wbg_length_a446193dc22c12f8 = function(arg0) {
|
|
334
|
+
const ret = arg0.length;
|
|
335
|
+
return ret;
|
|
409
336
|
};
|
|
410
|
-
imports.wbg.
|
|
411
|
-
const ret =
|
|
337
|
+
imports.wbg.__wbg_length_e2d2a49132c1b256 = function(arg0) {
|
|
338
|
+
const ret = arg0.length;
|
|
412
339
|
return ret;
|
|
413
340
|
};
|
|
414
|
-
imports.wbg.
|
|
415
|
-
|
|
416
|
-
try {
|
|
417
|
-
result = getObject(arg0) instanceof Uint8Array;
|
|
418
|
-
} catch (_) {
|
|
419
|
-
result = false;
|
|
420
|
-
}
|
|
421
|
-
const ret = result;
|
|
341
|
+
imports.wbg.__wbg_new_a12002a7f91c75be = function(arg0) {
|
|
342
|
+
const ret = new Uint8Array(arg0);
|
|
422
343
|
return ret;
|
|
423
344
|
};
|
|
424
|
-
imports.wbg.
|
|
425
|
-
const ret =
|
|
426
|
-
return
|
|
345
|
+
imports.wbg.__wbg_next_25feadfc0913fea9 = function(arg0) {
|
|
346
|
+
const ret = arg0.next;
|
|
347
|
+
return ret;
|
|
427
348
|
};
|
|
428
|
-
imports.wbg.
|
|
429
|
-
const ret =
|
|
349
|
+
imports.wbg.__wbg_next_6574e1a8a62d1055 = function() { return handleError(function (arg0) {
|
|
350
|
+
const ret = arg0.next();
|
|
430
351
|
return ret;
|
|
352
|
+
}, arguments) };
|
|
353
|
+
imports.wbg.__wbg_set_65595bdd868b3009 = function(arg0, arg1, arg2) {
|
|
354
|
+
arg0.set(arg1, arg2 >>> 0);
|
|
431
355
|
};
|
|
432
|
-
imports.wbg.
|
|
433
|
-
const
|
|
434
|
-
const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
|
|
356
|
+
imports.wbg.__wbg_value_cd1ffa7b1ab794f1 = function(arg0) {
|
|
357
|
+
const ret = arg0.value;
|
|
435
358
|
return ret;
|
|
436
359
|
};
|
|
437
|
-
imports.wbg.
|
|
438
|
-
const
|
|
439
|
-
|
|
440
|
-
getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret;
|
|
441
|
-
getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
|
|
360
|
+
imports.wbg.__wbindgen_bigint_from_i64 = function(arg0) {
|
|
361
|
+
const ret = arg0;
|
|
362
|
+
return ret;
|
|
442
363
|
};
|
|
443
|
-
imports.wbg.
|
|
444
|
-
const
|
|
445
|
-
|
|
446
|
-
var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
447
|
-
var len1 = WASM_VECTOR_LEN;
|
|
448
|
-
getInt32Memory0()[arg0 / 4 + 1] = len1;
|
|
449
|
-
getInt32Memory0()[arg0 / 4 + 0] = ptr1;
|
|
364
|
+
imports.wbg.__wbindgen_bigint_from_u64 = function(arg0) {
|
|
365
|
+
const ret = BigInt.asUintN(64, arg0);
|
|
366
|
+
return ret;
|
|
450
367
|
};
|
|
451
368
|
imports.wbg.__wbindgen_bigint_get_as_i64 = function(arg0, arg1) {
|
|
452
|
-
const v =
|
|
369
|
+
const v = arg1;
|
|
453
370
|
const ret = typeof(v) === 'bigint' ? v : undefined;
|
|
454
|
-
|
|
455
|
-
|
|
371
|
+
getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
|
|
372
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
|
|
373
|
+
};
|
|
374
|
+
imports.wbg.__wbindgen_boolean_get = function(arg0) {
|
|
375
|
+
const v = arg0;
|
|
376
|
+
const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
|
|
377
|
+
return ret;
|
|
456
378
|
};
|
|
457
379
|
imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
|
|
458
|
-
const ret = debugString(
|
|
380
|
+
const ret = debugString(arg1);
|
|
459
381
|
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
460
382
|
const len1 = WASM_VECTOR_LEN;
|
|
461
|
-
|
|
462
|
-
|
|
383
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
384
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
463
385
|
};
|
|
464
|
-
imports.wbg.
|
|
465
|
-
|
|
386
|
+
imports.wbg.__wbindgen_error_new = function(arg0, arg1) {
|
|
387
|
+
const ret = new Error(getStringFromWasm0(arg0, arg1));
|
|
388
|
+
return ret;
|
|
389
|
+
};
|
|
390
|
+
imports.wbg.__wbindgen_in = function(arg0, arg1) {
|
|
391
|
+
const ret = arg0 in arg1;
|
|
392
|
+
return ret;
|
|
393
|
+
};
|
|
394
|
+
imports.wbg.__wbindgen_init_externref_table = function() {
|
|
395
|
+
const table = wasm.__wbindgen_export_2;
|
|
396
|
+
const offset = table.grow(4);
|
|
397
|
+
table.set(0, undefined);
|
|
398
|
+
table.set(offset + 0, undefined);
|
|
399
|
+
table.set(offset + 1, null);
|
|
400
|
+
table.set(offset + 2, true);
|
|
401
|
+
table.set(offset + 3, false);
|
|
402
|
+
;
|
|
466
403
|
};
|
|
467
404
|
imports.wbg.__wbindgen_is_bigint = function(arg0) {
|
|
468
|
-
const ret = typeof(
|
|
405
|
+
const ret = typeof(arg0) === 'bigint';
|
|
469
406
|
return ret;
|
|
470
407
|
};
|
|
471
|
-
imports.wbg.
|
|
472
|
-
const ret =
|
|
408
|
+
imports.wbg.__wbindgen_is_function = function(arg0) {
|
|
409
|
+
const ret = typeof(arg0) === 'function';
|
|
473
410
|
return ret;
|
|
474
411
|
};
|
|
475
|
-
imports.wbg.
|
|
476
|
-
const
|
|
477
|
-
|
|
412
|
+
imports.wbg.__wbindgen_is_object = function(arg0) {
|
|
413
|
+
const val = arg0;
|
|
414
|
+
const ret = typeof(val) === 'object' && val !== null;
|
|
415
|
+
return ret;
|
|
478
416
|
};
|
|
479
417
|
imports.wbg.__wbindgen_jsval_eq = function(arg0, arg1) {
|
|
480
|
-
const ret =
|
|
418
|
+
const ret = arg0 === arg1;
|
|
481
419
|
return ret;
|
|
482
420
|
};
|
|
483
|
-
imports.wbg.
|
|
484
|
-
const ret =
|
|
485
|
-
return
|
|
421
|
+
imports.wbg.__wbindgen_jsval_loose_eq = function(arg0, arg1) {
|
|
422
|
+
const ret = arg0 == arg1;
|
|
423
|
+
return ret;
|
|
486
424
|
};
|
|
487
|
-
imports.wbg.
|
|
488
|
-
const ret =
|
|
489
|
-
return
|
|
425
|
+
imports.wbg.__wbindgen_memory = function() {
|
|
426
|
+
const ret = wasm.memory;
|
|
427
|
+
return ret;
|
|
428
|
+
};
|
|
429
|
+
imports.wbg.__wbindgen_number_get = function(arg0, arg1) {
|
|
430
|
+
const obj = arg1;
|
|
431
|
+
const ret = typeof(obj) === 'number' ? obj : undefined;
|
|
432
|
+
getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
|
|
433
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
|
|
434
|
+
};
|
|
435
|
+
imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
|
|
436
|
+
const obj = arg1;
|
|
437
|
+
const ret = typeof(obj) === 'string' ? obj : undefined;
|
|
438
|
+
var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
439
|
+
var len1 = WASM_VECTOR_LEN;
|
|
440
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
441
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
442
|
+
};
|
|
443
|
+
imports.wbg.__wbindgen_throw = function(arg0, arg1) {
|
|
444
|
+
throw new Error(getStringFromWasm0(arg0, arg1));
|
|
490
445
|
};
|
|
491
446
|
|
|
492
447
|
return imports;
|
|
493
448
|
}
|
|
494
449
|
|
|
495
|
-
function __wbg_init_memory(imports,
|
|
450
|
+
function __wbg_init_memory(imports, memory) {
|
|
496
451
|
|
|
497
452
|
}
|
|
498
453
|
|
|
499
454
|
function __wbg_finalize_init(instance, module) {
|
|
500
455
|
wasm = instance.exports;
|
|
501
456
|
__wbg_init.__wbindgen_wasm_module = module;
|
|
502
|
-
|
|
503
|
-
|
|
504
|
-
cachedInt32Memory0 = null;
|
|
505
|
-
cachedUint8Memory0 = null;
|
|
457
|
+
cachedDataViewMemory0 = null;
|
|
458
|
+
cachedUint8ArrayMemory0 = null;
|
|
506
459
|
|
|
507
460
|
|
|
461
|
+
wasm.__wbindgen_start();
|
|
508
462
|
return wasm;
|
|
509
463
|
}
|
|
510
464
|
|
|
511
465
|
function initSync(module) {
|
|
512
466
|
if (wasm !== undefined) return wasm;
|
|
513
467
|
|
|
468
|
+
|
|
469
|
+
if (typeof module !== 'undefined') {
|
|
470
|
+
if (Object.getPrototypeOf(module) === Object.prototype) {
|
|
471
|
+
({module} = module)
|
|
472
|
+
} else {
|
|
473
|
+
console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
|
|
474
|
+
}
|
|
475
|
+
}
|
|
476
|
+
|
|
514
477
|
const imports = __wbg_get_imports();
|
|
515
478
|
|
|
516
479
|
__wbg_init_memory(imports);
|
|
@@ -524,24 +487,33 @@ function initSync(module) {
|
|
|
524
487
|
return __wbg_finalize_init(instance, module);
|
|
525
488
|
}
|
|
526
489
|
|
|
527
|
-
async function __wbg_init(
|
|
490
|
+
async function __wbg_init(module_or_path) {
|
|
528
491
|
if (wasm !== undefined) return wasm;
|
|
529
492
|
|
|
530
|
-
|
|
531
|
-
|
|
493
|
+
|
|
494
|
+
if (typeof module_or_path !== 'undefined') {
|
|
495
|
+
if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
|
|
496
|
+
({module_or_path} = module_or_path)
|
|
497
|
+
} else {
|
|
498
|
+
console.warn('using deprecated parameters for the initialization function; pass a single object instead')
|
|
499
|
+
}
|
|
500
|
+
}
|
|
501
|
+
|
|
502
|
+
if (typeof module_or_path === 'undefined') {
|
|
503
|
+
module_or_path = new URL('windmill_parser_wasm_bg.wasm', import.meta.url);
|
|
532
504
|
}
|
|
533
505
|
const imports = __wbg_get_imports();
|
|
534
506
|
|
|
535
|
-
if (typeof
|
|
536
|
-
|
|
507
|
+
if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
|
|
508
|
+
module_or_path = fetch(module_or_path);
|
|
537
509
|
}
|
|
538
510
|
|
|
539
511
|
__wbg_init_memory(imports);
|
|
540
512
|
|
|
541
|
-
const { instance, module } = await __wbg_load(await
|
|
513
|
+
const { instance, module } = await __wbg_load(await module_or_path, imports);
|
|
542
514
|
|
|
543
515
|
return __wbg_finalize_init(instance, module);
|
|
544
516
|
}
|
|
545
517
|
|
|
546
|
-
export { initSync }
|
|
518
|
+
export { initSync };
|
|
547
519
|
export default __wbg_init;
|
|
Binary file
|