windmill-parser-wasm-ts 1.438.2 → 1.504.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/package.json +2 -2
- package/windmill_parser_wasm.d.ts +14 -23
- package/windmill_parser_wasm.js +266 -275
- 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.504.0",
|
|
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,25 @@
|
|
|
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;
|
|
6
|
+
export function parse_assets_ts(code: string): string;
|
|
19
7
|
|
|
20
8
|
export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
|
|
21
9
|
|
|
22
10
|
export interface InitOutput {
|
|
23
11
|
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
|
|
12
|
+
readonly parse_deno: (a: number, b: number, c: number, d: number) => [number, number];
|
|
13
|
+
readonly parse_outputs: (a: number, b: number) => [number, number];
|
|
14
|
+
readonly parse_ts_imports: (a: number, b: number) => [number, number];
|
|
15
|
+
readonly parse_assets_ts: (a: number, b: number) => [number, number];
|
|
16
|
+
readonly __wbindgen_exn_store: (a: number) => void;
|
|
17
|
+
readonly __externref_table_alloc: () => number;
|
|
18
|
+
readonly __wbindgen_export_2: WebAssembly.Table;
|
|
27
19
|
readonly __wbindgen_malloc: (a: number, b: number) => number;
|
|
28
20
|
readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
|
|
29
|
-
readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
|
|
30
21
|
readonly __wbindgen_free: (a: number, b: number, c: number) => void;
|
|
31
|
-
readonly
|
|
22
|
+
readonly __wbindgen_start: () => void;
|
|
32
23
|
}
|
|
33
24
|
|
|
34
25
|
export type SyncInitInput = BufferSource | WebAssembly.Module;
|
|
@@ -36,18 +27,18 @@ export type SyncInitInput = BufferSource | WebAssembly.Module;
|
|
|
36
27
|
* Instantiates the given `module`, which can either be bytes or
|
|
37
28
|
* a precompiled `WebAssembly.Module`.
|
|
38
29
|
*
|
|
39
|
-
* @param {SyncInitInput} module
|
|
30
|
+
* @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
|
|
40
31
|
*
|
|
41
32
|
* @returns {InitOutput}
|
|
42
33
|
*/
|
|
43
|
-
export function initSync(module: SyncInitInput): InitOutput;
|
|
34
|
+
export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
|
|
44
35
|
|
|
45
36
|
/**
|
|
46
37
|
* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
|
|
47
38
|
* for everything else, calls `WebAssembly.instantiate` directly.
|
|
48
39
|
*
|
|
49
|
-
* @param {InitInput | Promise<InitInput>} module_or_path
|
|
40
|
+
* @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
|
|
50
41
|
*
|
|
51
42
|
* @returns {Promise<InitOutput>}
|
|
52
43
|
*/
|
|
53
|
-
export default function __wbg_init (module_or_path?: InitInput | Promise<InitInput>): Promise<InitOutput>;
|
|
44
|
+
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
|
|
40
|
+
let cachedDataViewMemory0 = null;
|
|
55
41
|
|
|
56
|
-
function
|
|
57
|
-
if (
|
|
58
|
-
|
|
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);
|
|
59
45
|
}
|
|
60
|
-
return
|
|
61
|
-
}
|
|
62
|
-
|
|
63
|
-
let cachedInt32Memory0 = null;
|
|
64
|
-
|
|
65
|
-
function getInt32Memory0() {
|
|
66
|
-
if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
|
|
67
|
-
cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
|
|
68
|
-
}
|
|
69
|
-
return cachedInt32Memory0;
|
|
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,83 +110,138 @@ 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
|
-
|
|
229
|
+
/**
|
|
230
|
+
* @param {string} code
|
|
231
|
+
* @returns {string}
|
|
232
|
+
*/
|
|
233
|
+
export function parse_assets_ts(code) {
|
|
234
|
+
let deferred2_0;
|
|
235
|
+
let deferred2_1;
|
|
274
236
|
try {
|
|
275
|
-
|
|
276
|
-
|
|
277
|
-
wasm.
|
|
237
|
+
const ptr0 = passStringToWasm0(code, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
238
|
+
const len0 = WASM_VECTOR_LEN;
|
|
239
|
+
const ret = wasm.parse_assets_ts(ptr0, len0);
|
|
240
|
+
deferred2_0 = ret[0];
|
|
241
|
+
deferred2_1 = ret[1];
|
|
242
|
+
return getStringFromWasm0(ret[0], ret[1]);
|
|
243
|
+
} finally {
|
|
244
|
+
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
278
245
|
}
|
|
279
246
|
}
|
|
280
247
|
|
|
@@ -286,7 +253,7 @@ async function __wbg_load(module, imports) {
|
|
|
286
253
|
|
|
287
254
|
} catch (e) {
|
|
288
255
|
if (module.headers.get('Content-Type') != 'application/wasm') {
|
|
289
|
-
console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve
|
|
256
|
+
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
257
|
|
|
291
258
|
} else {
|
|
292
259
|
throw e;
|
|
@@ -312,205 +279,220 @@ async function __wbg_load(module, imports) {
|
|
|
312
279
|
function __wbg_get_imports() {
|
|
313
280
|
const imports = {};
|
|
314
281
|
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;
|
|
282
|
+
imports.wbg.__wbg_buffer_609cc3eee51ed158 = function(arg0) {
|
|
283
|
+
const ret = arg0.buffer;
|
|
321
284
|
return ret;
|
|
322
285
|
};
|
|
323
|
-
imports.wbg.
|
|
324
|
-
const
|
|
325
|
-
const ret = typeof(val) === 'object' && val !== null;
|
|
286
|
+
imports.wbg.__wbg_call_672a4d21634d4a24 = function() { return handleError(function (arg0, arg1) {
|
|
287
|
+
const ret = arg0.call(arg1);
|
|
326
288
|
return ret;
|
|
327
|
-
};
|
|
328
|
-
imports.wbg.__wbg_next_40fc327bfc8770e6 = function(arg0) {
|
|
329
|
-
const ret = getObject(arg0).next;
|
|
330
|
-
return addHeapObject(ret);
|
|
331
|
-
};
|
|
332
|
-
imports.wbg.__wbindgen_is_function = function(arg0) {
|
|
333
|
-
const ret = typeof(getObject(arg0)) === 'function';
|
|
334
|
-
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
289
|
}, arguments) };
|
|
343
|
-
imports.wbg.
|
|
344
|
-
const ret =
|
|
290
|
+
imports.wbg.__wbg_done_769e5ede4b31c67b = function(arg0) {
|
|
291
|
+
const ret = arg0.done;
|
|
345
292
|
return ret;
|
|
346
293
|
};
|
|
347
|
-
imports.wbg.
|
|
348
|
-
const ret =
|
|
349
|
-
return
|
|
294
|
+
imports.wbg.__wbg_entries_3265d4158b33e5dc = function(arg0) {
|
|
295
|
+
const ret = Object.entries(arg0);
|
|
296
|
+
return ret;
|
|
350
297
|
};
|
|
351
|
-
imports.wbg.
|
|
352
|
-
const ret =
|
|
353
|
-
return
|
|
298
|
+
imports.wbg.__wbg_eval_907c7552de1a5dc7 = function(arg0, arg1) {
|
|
299
|
+
const ret = eval(getStringFromWasm0(arg0, arg1));
|
|
300
|
+
return ret;
|
|
354
301
|
};
|
|
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);
|
|
302
|
+
imports.wbg.__wbg_get_67b2ba62fc30de12 = function() { return handleError(function (arg0, arg1) {
|
|
303
|
+
const ret = Reflect.get(arg0, arg1);
|
|
304
|
+
return ret;
|
|
362
305
|
}, arguments) };
|
|
363
|
-
imports.wbg.
|
|
364
|
-
const ret =
|
|
306
|
+
imports.wbg.__wbg_get_b9b93047fe3cf45b = function(arg0, arg1) {
|
|
307
|
+
const ret = arg0[arg1 >>> 0];
|
|
365
308
|
return ret;
|
|
366
309
|
};
|
|
367
|
-
imports.wbg.
|
|
310
|
+
imports.wbg.__wbg_instanceof_ArrayBuffer_e14585432e3737fc = function(arg0) {
|
|
368
311
|
let result;
|
|
369
312
|
try {
|
|
370
|
-
result =
|
|
313
|
+
result = arg0 instanceof ArrayBuffer;
|
|
371
314
|
} catch (_) {
|
|
372
315
|
result = false;
|
|
373
316
|
}
|
|
374
317
|
const ret = result;
|
|
375
318
|
return ret;
|
|
376
319
|
};
|
|
377
|
-
imports.wbg.
|
|
320
|
+
imports.wbg.__wbg_instanceof_Map_f3469ce2244d2430 = function(arg0) {
|
|
378
321
|
let result;
|
|
379
322
|
try {
|
|
380
|
-
result =
|
|
323
|
+
result = arg0 instanceof Map;
|
|
381
324
|
} catch (_) {
|
|
382
325
|
result = false;
|
|
383
326
|
}
|
|
384
327
|
const ret = result;
|
|
385
328
|
return ret;
|
|
386
329
|
};
|
|
387
|
-
imports.wbg.
|
|
388
|
-
|
|
330
|
+
imports.wbg.__wbg_instanceof_Uint8Array_17156bcf118086a9 = function(arg0) {
|
|
331
|
+
let result;
|
|
332
|
+
try {
|
|
333
|
+
result = arg0 instanceof Uint8Array;
|
|
334
|
+
} catch (_) {
|
|
335
|
+
result = false;
|
|
336
|
+
}
|
|
337
|
+
const ret = result;
|
|
389
338
|
return ret;
|
|
390
339
|
};
|
|
391
|
-
imports.wbg.
|
|
392
|
-
const ret =
|
|
393
|
-
return
|
|
394
|
-
};
|
|
395
|
-
imports.wbg.__wbindgen_memory = function() {
|
|
396
|
-
const ret = wasm.memory;
|
|
397
|
-
return addHeapObject(ret);
|
|
340
|
+
imports.wbg.__wbg_isArray_a1eab7e0d067391b = function(arg0) {
|
|
341
|
+
const ret = Array.isArray(arg0);
|
|
342
|
+
return ret;
|
|
398
343
|
};
|
|
399
|
-
imports.wbg.
|
|
400
|
-
const ret =
|
|
401
|
-
return
|
|
344
|
+
imports.wbg.__wbg_isSafeInteger_343e2beeeece1bb0 = function(arg0) {
|
|
345
|
+
const ret = Number.isSafeInteger(arg0);
|
|
346
|
+
return ret;
|
|
402
347
|
};
|
|
403
|
-
imports.wbg.
|
|
404
|
-
const ret =
|
|
405
|
-
return
|
|
348
|
+
imports.wbg.__wbg_iterator_9a24c88df860dc65 = function() {
|
|
349
|
+
const ret = Symbol.iterator;
|
|
350
|
+
return ret;
|
|
406
351
|
};
|
|
407
|
-
imports.wbg.
|
|
408
|
-
|
|
352
|
+
imports.wbg.__wbg_length_a446193dc22c12f8 = function(arg0) {
|
|
353
|
+
const ret = arg0.length;
|
|
354
|
+
return ret;
|
|
409
355
|
};
|
|
410
|
-
imports.wbg.
|
|
411
|
-
const ret =
|
|
356
|
+
imports.wbg.__wbg_length_e2d2a49132c1b256 = function(arg0) {
|
|
357
|
+
const ret = arg0.length;
|
|
412
358
|
return ret;
|
|
413
359
|
};
|
|
414
|
-
imports.wbg.
|
|
415
|
-
|
|
416
|
-
try {
|
|
417
|
-
result = getObject(arg0) instanceof Uint8Array;
|
|
418
|
-
} catch (_) {
|
|
419
|
-
result = false;
|
|
420
|
-
}
|
|
421
|
-
const ret = result;
|
|
360
|
+
imports.wbg.__wbg_new_a12002a7f91c75be = function(arg0) {
|
|
361
|
+
const ret = new Uint8Array(arg0);
|
|
422
362
|
return ret;
|
|
423
363
|
};
|
|
424
|
-
imports.wbg.
|
|
425
|
-
const ret =
|
|
426
|
-
return
|
|
364
|
+
imports.wbg.__wbg_next_25feadfc0913fea9 = function(arg0) {
|
|
365
|
+
const ret = arg0.next;
|
|
366
|
+
return ret;
|
|
427
367
|
};
|
|
428
|
-
imports.wbg.
|
|
429
|
-
const ret =
|
|
368
|
+
imports.wbg.__wbg_next_6574e1a8a62d1055 = function() { return handleError(function (arg0) {
|
|
369
|
+
const ret = arg0.next();
|
|
430
370
|
return ret;
|
|
371
|
+
}, arguments) };
|
|
372
|
+
imports.wbg.__wbg_set_65595bdd868b3009 = function(arg0, arg1, arg2) {
|
|
373
|
+
arg0.set(arg1, arg2 >>> 0);
|
|
431
374
|
};
|
|
432
|
-
imports.wbg.
|
|
433
|
-
const
|
|
434
|
-
const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
|
|
375
|
+
imports.wbg.__wbg_value_cd1ffa7b1ab794f1 = function(arg0) {
|
|
376
|
+
const ret = arg0.value;
|
|
435
377
|
return ret;
|
|
436
378
|
};
|
|
437
|
-
imports.wbg.
|
|
438
|
-
const
|
|
439
|
-
|
|
440
|
-
getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret;
|
|
441
|
-
getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
|
|
379
|
+
imports.wbg.__wbindgen_bigint_from_i64 = function(arg0) {
|
|
380
|
+
const ret = arg0;
|
|
381
|
+
return ret;
|
|
442
382
|
};
|
|
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;
|
|
383
|
+
imports.wbg.__wbindgen_bigint_from_u64 = function(arg0) {
|
|
384
|
+
const ret = BigInt.asUintN(64, arg0);
|
|
385
|
+
return ret;
|
|
450
386
|
};
|
|
451
387
|
imports.wbg.__wbindgen_bigint_get_as_i64 = function(arg0, arg1) {
|
|
452
|
-
const v =
|
|
388
|
+
const v = arg1;
|
|
453
389
|
const ret = typeof(v) === 'bigint' ? v : undefined;
|
|
454
|
-
|
|
455
|
-
|
|
390
|
+
getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
|
|
391
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
|
|
392
|
+
};
|
|
393
|
+
imports.wbg.__wbindgen_boolean_get = function(arg0) {
|
|
394
|
+
const v = arg0;
|
|
395
|
+
const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
|
|
396
|
+
return ret;
|
|
456
397
|
};
|
|
457
398
|
imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
|
|
458
|
-
const ret = debugString(
|
|
399
|
+
const ret = debugString(arg1);
|
|
459
400
|
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
460
401
|
const len1 = WASM_VECTOR_LEN;
|
|
461
|
-
|
|
462
|
-
|
|
402
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
403
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
463
404
|
};
|
|
464
|
-
imports.wbg.
|
|
465
|
-
|
|
405
|
+
imports.wbg.__wbindgen_error_new = function(arg0, arg1) {
|
|
406
|
+
const ret = new Error(getStringFromWasm0(arg0, arg1));
|
|
407
|
+
return ret;
|
|
408
|
+
};
|
|
409
|
+
imports.wbg.__wbindgen_in = function(arg0, arg1) {
|
|
410
|
+
const ret = arg0 in arg1;
|
|
411
|
+
return ret;
|
|
412
|
+
};
|
|
413
|
+
imports.wbg.__wbindgen_init_externref_table = function() {
|
|
414
|
+
const table = wasm.__wbindgen_export_2;
|
|
415
|
+
const offset = table.grow(4);
|
|
416
|
+
table.set(0, undefined);
|
|
417
|
+
table.set(offset + 0, undefined);
|
|
418
|
+
table.set(offset + 1, null);
|
|
419
|
+
table.set(offset + 2, true);
|
|
420
|
+
table.set(offset + 3, false);
|
|
421
|
+
;
|
|
466
422
|
};
|
|
467
423
|
imports.wbg.__wbindgen_is_bigint = function(arg0) {
|
|
468
|
-
const ret = typeof(
|
|
424
|
+
const ret = typeof(arg0) === 'bigint';
|
|
469
425
|
return ret;
|
|
470
426
|
};
|
|
471
|
-
imports.wbg.
|
|
472
|
-
const ret =
|
|
427
|
+
imports.wbg.__wbindgen_is_function = function(arg0) {
|
|
428
|
+
const ret = typeof(arg0) === 'function';
|
|
473
429
|
return ret;
|
|
474
430
|
};
|
|
475
|
-
imports.wbg.
|
|
476
|
-
const
|
|
477
|
-
|
|
431
|
+
imports.wbg.__wbindgen_is_object = function(arg0) {
|
|
432
|
+
const val = arg0;
|
|
433
|
+
const ret = typeof(val) === 'object' && val !== null;
|
|
434
|
+
return ret;
|
|
478
435
|
};
|
|
479
436
|
imports.wbg.__wbindgen_jsval_eq = function(arg0, arg1) {
|
|
480
|
-
const ret =
|
|
437
|
+
const ret = arg0 === arg1;
|
|
481
438
|
return ret;
|
|
482
439
|
};
|
|
483
|
-
imports.wbg.
|
|
484
|
-
const ret =
|
|
485
|
-
return
|
|
440
|
+
imports.wbg.__wbindgen_jsval_loose_eq = function(arg0, arg1) {
|
|
441
|
+
const ret = arg0 == arg1;
|
|
442
|
+
return ret;
|
|
486
443
|
};
|
|
487
|
-
imports.wbg.
|
|
488
|
-
const ret =
|
|
489
|
-
return
|
|
444
|
+
imports.wbg.__wbindgen_memory = function() {
|
|
445
|
+
const ret = wasm.memory;
|
|
446
|
+
return ret;
|
|
447
|
+
};
|
|
448
|
+
imports.wbg.__wbindgen_number_get = function(arg0, arg1) {
|
|
449
|
+
const obj = arg1;
|
|
450
|
+
const ret = typeof(obj) === 'number' ? obj : undefined;
|
|
451
|
+
getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
|
|
452
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
|
|
453
|
+
};
|
|
454
|
+
imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
|
|
455
|
+
const obj = arg1;
|
|
456
|
+
const ret = typeof(obj) === 'string' ? obj : undefined;
|
|
457
|
+
var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
458
|
+
var len1 = WASM_VECTOR_LEN;
|
|
459
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
460
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
461
|
+
};
|
|
462
|
+
imports.wbg.__wbindgen_throw = function(arg0, arg1) {
|
|
463
|
+
throw new Error(getStringFromWasm0(arg0, arg1));
|
|
490
464
|
};
|
|
491
465
|
|
|
492
466
|
return imports;
|
|
493
467
|
}
|
|
494
468
|
|
|
495
|
-
function __wbg_init_memory(imports,
|
|
469
|
+
function __wbg_init_memory(imports, memory) {
|
|
496
470
|
|
|
497
471
|
}
|
|
498
472
|
|
|
499
473
|
function __wbg_finalize_init(instance, module) {
|
|
500
474
|
wasm = instance.exports;
|
|
501
475
|
__wbg_init.__wbindgen_wasm_module = module;
|
|
502
|
-
|
|
503
|
-
|
|
504
|
-
cachedInt32Memory0 = null;
|
|
505
|
-
cachedUint8Memory0 = null;
|
|
476
|
+
cachedDataViewMemory0 = null;
|
|
477
|
+
cachedUint8ArrayMemory0 = null;
|
|
506
478
|
|
|
507
479
|
|
|
480
|
+
wasm.__wbindgen_start();
|
|
508
481
|
return wasm;
|
|
509
482
|
}
|
|
510
483
|
|
|
511
484
|
function initSync(module) {
|
|
512
485
|
if (wasm !== undefined) return wasm;
|
|
513
486
|
|
|
487
|
+
|
|
488
|
+
if (typeof module !== 'undefined') {
|
|
489
|
+
if (Object.getPrototypeOf(module) === Object.prototype) {
|
|
490
|
+
({module} = module)
|
|
491
|
+
} else {
|
|
492
|
+
console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
|
|
493
|
+
}
|
|
494
|
+
}
|
|
495
|
+
|
|
514
496
|
const imports = __wbg_get_imports();
|
|
515
497
|
|
|
516
498
|
__wbg_init_memory(imports);
|
|
@@ -524,24 +506,33 @@ function initSync(module) {
|
|
|
524
506
|
return __wbg_finalize_init(instance, module);
|
|
525
507
|
}
|
|
526
508
|
|
|
527
|
-
async function __wbg_init(
|
|
509
|
+
async function __wbg_init(module_or_path) {
|
|
528
510
|
if (wasm !== undefined) return wasm;
|
|
529
511
|
|
|
530
|
-
|
|
531
|
-
|
|
512
|
+
|
|
513
|
+
if (typeof module_or_path !== 'undefined') {
|
|
514
|
+
if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
|
|
515
|
+
({module_or_path} = module_or_path)
|
|
516
|
+
} else {
|
|
517
|
+
console.warn('using deprecated parameters for the initialization function; pass a single object instead')
|
|
518
|
+
}
|
|
519
|
+
}
|
|
520
|
+
|
|
521
|
+
if (typeof module_or_path === 'undefined') {
|
|
522
|
+
module_or_path = new URL('windmill_parser_wasm_bg.wasm', import.meta.url);
|
|
532
523
|
}
|
|
533
524
|
const imports = __wbg_get_imports();
|
|
534
525
|
|
|
535
|
-
if (typeof
|
|
536
|
-
|
|
526
|
+
if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
|
|
527
|
+
module_or_path = fetch(module_or_path);
|
|
537
528
|
}
|
|
538
529
|
|
|
539
530
|
__wbg_init_memory(imports);
|
|
540
531
|
|
|
541
|
-
const { instance, module } = await __wbg_load(await
|
|
532
|
+
const { instance, module } = await __wbg_load(await module_or_path, imports);
|
|
542
533
|
|
|
543
534
|
return __wbg_finalize_init(instance, module);
|
|
544
535
|
}
|
|
545
536
|
|
|
546
|
-
export { initSync }
|
|
537
|
+
export { initSync };
|
|
547
538
|
export default __wbg_init;
|
|
Binary file
|