eddie-jekyll 0.2.4 → 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (9) hide show
  1. checksums.yaml +4 -4
  2. data/assets/eddie-agent-worker.js +536 -0
  3. data/assets/eddie-wasm.js +205 -124
  4. data/assets/eddie-widget.js +1832 -581
  5. data/assets/eddie-worker.js +1123 -182
  6. data/assets/eddie.wasm +0 -0
  7. data/lib/eddie/jekyll.rb +1 -1
  8. data/scripts/install.sh +2 -1
  9. metadata +7 -6
data/assets/eddie-wasm.js CHANGED
@@ -5,58 +5,55 @@ let wasm_bindgen = (function(exports) {
5
5
  }
6
6
 
7
7
  /**
8
- * @param {Uint8Array} index_bytes
8
+ * One chunk by id.
9
+ * @param {number} id
9
10
  * @returns {string}
10
11
  */
11
- function extract_model_id(index_bytes) {
12
- let deferred3_0;
13
- let deferred3_1;
12
+ function chunk(id) {
13
+ let deferred2_0;
14
+ let deferred2_1;
14
15
  try {
15
16
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
16
- const ptr0 = passArray8ToWasm0(index_bytes, wasm.__wbindgen_export);
17
- const len0 = WASM_VECTOR_LEN;
18
- wasm.extract_model_id(retptr, ptr0, len0);
17
+ wasm.chunk(retptr, id);
19
18
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
20
19
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
21
20
  var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
22
21
  var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
23
- var ptr2 = r0;
24
- var len2 = r1;
22
+ var ptr1 = r0;
23
+ var len1 = r1;
25
24
  if (r3) {
26
- ptr2 = 0; len2 = 0;
25
+ ptr1 = 0; len1 = 0;
27
26
  throw takeObject(r2);
28
27
  }
29
- deferred3_0 = ptr2;
30
- deferred3_1 = len2;
31
- return getStringFromWasm0(ptr2, len2);
28
+ deferred2_0 = ptr1;
29
+ deferred2_1 = len1;
30
+ return getStringFromWasm0(ptr1, len1);
32
31
  } finally {
33
32
  wasm.__wbindgen_add_to_stack_pointer(16);
34
- wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
33
+ wasm.__wbindgen_export2(deferred2_0, deferred2_1, 1);
35
34
  }
36
35
  }
37
- exports.extract_model_id = extract_model_id;
36
+ exports.chunk = chunk;
38
37
 
39
38
  /**
40
- * Initialize the search engine from raw model and index bytes.
41
- *
42
- * Called once by the Web Worker after downloading all assets.
43
- * @param {Uint8Array} config_bytes
44
- * @param {Uint8Array} tokenizer_bytes
45
- * @param {Uint8Array} weights_bytes
46
- * @param {Uint8Array} index_bytes
39
+ * Load the BERT-family model for a `wasm-candle` lane of the loaded index.
40
+ * @param {string} lane_id
41
+ * @param {Uint8Array} config
42
+ * @param {Uint8Array} tokenizer
43
+ * @param {Uint8Array} weights
47
44
  */
48
- function init_engine(config_bytes, tokenizer_bytes, weights_bytes, index_bytes) {
45
+ function init_dense_wasm(lane_id, config, tokenizer, weights) {
49
46
  try {
50
47
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
51
- const ptr0 = passArray8ToWasm0(config_bytes, wasm.__wbindgen_export);
48
+ const ptr0 = passStringToWasm0(lane_id, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
52
49
  const len0 = WASM_VECTOR_LEN;
53
- const ptr1 = passArray8ToWasm0(tokenizer_bytes, wasm.__wbindgen_export);
50
+ const ptr1 = passArray8ToWasm0(config, wasm.__wbindgen_export3);
54
51
  const len1 = WASM_VECTOR_LEN;
55
- const ptr2 = passArray8ToWasm0(weights_bytes, wasm.__wbindgen_export);
52
+ const ptr2 = passArray8ToWasm0(tokenizer, wasm.__wbindgen_export3);
56
53
  const len2 = WASM_VECTOR_LEN;
57
- const ptr3 = passArray8ToWasm0(index_bytes, wasm.__wbindgen_export);
54
+ const ptr3 = passArray8ToWasm0(weights, wasm.__wbindgen_export3);
58
55
  const len3 = WASM_VECTOR_LEN;
59
- wasm.init_engine(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
56
+ wasm.init_dense_wasm(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
60
57
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
61
58
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
62
59
  if (r1) {
@@ -66,169 +63,229 @@ let wasm_bindgen = (function(exports) {
66
63
  wasm.__wbindgen_add_to_stack_pointer(16);
67
64
  }
68
65
  }
69
- exports.init_engine = init_engine;
66
+ exports.init_dense_wasm = init_dense_wasm;
70
67
 
71
68
  /**
72
- * Query the embedded claims section semantically.
73
- * @param {string} query
74
- * @param {number} top_k
75
- * @returns {any}
69
+ * Parse and validate the index. Replaces any previously loaded index and
70
+ * forgets its dense embedder / sparse tokenizer.
71
+ * @param {Uint8Array} index_bytes
76
72
  */
77
- function query_claims(query, top_k) {
73
+ function init_index(index_bytes) {
78
74
  try {
79
75
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
80
- const ptr0 = passStringToWasm0(query, wasm.__wbindgen_export, wasm.__wbindgen_export2);
76
+ const ptr0 = passArray8ToWasm0(index_bytes, wasm.__wbindgen_export3);
81
77
  const len0 = WASM_VECTOR_LEN;
82
- wasm.query_claims(retptr, ptr0, len0, top_k);
78
+ wasm.init_index(retptr, ptr0, len0);
79
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
80
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
81
+ if (r1) {
82
+ throw takeObject(r0);
83
+ }
84
+ } finally {
85
+ wasm.__wbindgen_add_to_stack_pointer(16);
86
+ }
87
+ }
88
+ exports.init_index = init_index;
89
+
90
+ /**
91
+ * Load the WordPiece tokenizer that enables the learned-sparse arm. The
92
+ * bytes must be the `tokenizer.json` the index was built with: their
93
+ * SHA-256 is checked against `manifest.sparse.vocab_hash`, because a
94
+ * different vocabulary yields different token ids and a sparse arm that
95
+ * scores noise while still looking healthy.
96
+ * @param {Uint8Array} tokenizer_bytes
97
+ */
98
+ function init_sparse_tokenizer(tokenizer_bytes) {
99
+ try {
100
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
101
+ const ptr0 = passArray8ToWasm0(tokenizer_bytes, wasm.__wbindgen_export3);
102
+ const len0 = WASM_VECTOR_LEN;
103
+ wasm.init_sparse_tokenizer(retptr, ptr0, len0);
104
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
105
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
106
+ if (r1) {
107
+ throw takeObject(r0);
108
+ }
109
+ } finally {
110
+ wasm.__wbindgen_add_to_stack_pointer(16);
111
+ }
112
+ }
113
+ exports.init_sparse_tokenizer = init_sparse_tokenizer;
114
+
115
+ /**
116
+ * Read the uncompressed manifest at the head of an `.ed` file.
117
+ * @param {Uint8Array} index_bytes
118
+ * @returns {string}
119
+ */
120
+ function manifest(index_bytes) {
121
+ let deferred3_0;
122
+ let deferred3_1;
123
+ try {
124
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
125
+ const ptr0 = passArray8ToWasm0(index_bytes, wasm.__wbindgen_export3);
126
+ const len0 = WASM_VECTOR_LEN;
127
+ wasm.manifest(retptr, ptr0, len0);
83
128
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
84
129
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
85
130
  var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
86
- if (r2) {
87
- throw takeObject(r1);
131
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
132
+ var ptr2 = r0;
133
+ var len2 = r1;
134
+ if (r3) {
135
+ ptr2 = 0; len2 = 0;
136
+ throw takeObject(r2);
88
137
  }
89
- return takeObject(r0);
138
+ deferred3_0 = ptr2;
139
+ deferred3_1 = len2;
140
+ return getStringFromWasm0(ptr2, len2);
90
141
  } finally {
91
142
  wasm.__wbindgen_add_to_stack_pointer(16);
143
+ wasm.__wbindgen_export2(deferred3_0, deferred3_1, 1);
92
144
  }
93
145
  }
94
- exports.query_claims = query_claims;
146
+ exports.manifest = manifest;
95
147
 
96
148
  /**
97
- * Query the embedded QA section semantically.
98
- * @param {string} query
99
- * @param {number} top_k
100
- * @returns {any}
149
+ * The text of a page (by URL) in document order: its chunks at the finest
150
+ * granularity present (`fine` when the index has it), so coarse and summary
151
+ * chunks never duplicate the same paragraphs.
152
+ * @param {string} url
153
+ * @returns {string}
101
154
  */
102
- function query_qa(query, top_k) {
155
+ function page(url) {
156
+ let deferred3_0;
157
+ let deferred3_1;
103
158
  try {
104
159
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
105
- const ptr0 = passStringToWasm0(query, wasm.__wbindgen_export, wasm.__wbindgen_export2);
160
+ const ptr0 = passStringToWasm0(url, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
106
161
  const len0 = WASM_VECTOR_LEN;
107
- wasm.query_qa(retptr, ptr0, len0, top_k);
162
+ wasm.page(retptr, ptr0, len0);
108
163
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
109
164
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
110
165
  var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
111
- if (r2) {
112
- throw takeObject(r1);
166
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
167
+ var ptr2 = r0;
168
+ var len2 = r1;
169
+ if (r3) {
170
+ ptr2 = 0; len2 = 0;
171
+ throw takeObject(r2);
113
172
  }
114
- return takeObject(r0);
173
+ deferred3_0 = ptr2;
174
+ deferred3_1 = len2;
175
+ return getStringFromWasm0(ptr2, len2);
115
176
  } finally {
116
177
  wasm.__wbindgen_add_to_stack_pointer(16);
178
+ wasm.__wbindgen_export2(deferred3_0, deferred3_1, 1);
117
179
  }
118
180
  }
119
- exports.query_qa = query_qa;
181
+ exports.page = page;
120
182
 
121
183
  /**
122
- * Search the index and return results as a JS array.
123
- *
124
- * `mode`: "semantic", "keyword", or "hybrid" (default).
184
+ * Nearest QA entries by cosine on the qa dense lane. Returns `[]` when the
185
+ * index has no qa section or no query vector can be produced.
125
186
  * @param {string} query
126
- * @param {number} top_k
127
- * @param {string} mode
128
- * @returns {any}
187
+ * @param {string | null | undefined} dense_lane_id
188
+ * @param {Float32Array | null | undefined} dense_query_vec
189
+ * @param {number} k
190
+ * @returns {string}
129
191
  */
130
- function search_query(query, top_k, mode) {
192
+ function qa_lookup(query, dense_lane_id, dense_query_vec, k) {
193
+ let deferred5_0;
194
+ let deferred5_1;
131
195
  try {
132
196
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
133
- const ptr0 = passStringToWasm0(query, wasm.__wbindgen_export, wasm.__wbindgen_export2);
197
+ const ptr0 = passStringToWasm0(query, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
134
198
  const len0 = WASM_VECTOR_LEN;
135
- const ptr1 = passStringToWasm0(mode, wasm.__wbindgen_export, wasm.__wbindgen_export2);
136
- const len1 = WASM_VECTOR_LEN;
137
- wasm.search_query(retptr, ptr0, len0, top_k, ptr1, len1);
199
+ var ptr1 = isLikeNone(dense_lane_id) ? 0 : passStringToWasm0(dense_lane_id, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
200
+ var len1 = WASM_VECTOR_LEN;
201
+ var ptr2 = isLikeNone(dense_query_vec) ? 0 : passArrayF32ToWasm0(dense_query_vec, wasm.__wbindgen_export3);
202
+ var len2 = WASM_VECTOR_LEN;
203
+ wasm.qa_lookup(retptr, ptr0, len0, ptr1, len1, ptr2, len2, k);
138
204
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
139
205
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
140
206
  var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
141
- if (r2) {
142
- throw takeObject(r1);
207
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
208
+ var ptr4 = r0;
209
+ var len4 = r1;
210
+ if (r3) {
211
+ ptr4 = 0; len4 = 0;
212
+ throw takeObject(r2);
143
213
  }
144
- return takeObject(r0);
214
+ deferred5_0 = ptr4;
215
+ deferred5_1 = len4;
216
+ return getStringFromWasm0(ptr4, len4);
145
217
  } finally {
146
218
  wasm.__wbindgen_add_to_stack_pointer(16);
219
+ wasm.__wbindgen_export2(deferred5_0, deferred5_1, 1);
147
220
  }
148
221
  }
149
- exports.search_query = search_query;
222
+ exports.qa_lookup = qa_lookup;
150
223
 
151
224
  /**
152
- * Search and optionally synthesize a grounded answer inside WASM.
225
+ * Search the loaded index.
226
+ *
227
+ * `mode`: `hybrid` (default), `dense`, `sparse`, or `keyword`.
228
+ * `dense_lane_id` + `dense_query_vec`: a query vector produced outside WASM
229
+ * (transformers.js) for the named lane. With both `null`, the WASM lane
230
+ * loaded by `init_dense_wasm` embeds the query (exactly once); if none is
231
+ * loaded the dense arm is skipped and reported in `degraded`.
153
232
  * @param {string} query
154
233
  * @param {number} top_k
155
- * @param {number} answer_top_k
156
234
  * @param {string} mode
157
- * @param {boolean} answer_mode
158
- * @param {string} qa_subject
159
- * @returns {any}
235
+ * @param {string | null} [dense_lane_id]
236
+ * @param {Float32Array | null} [dense_query_vec]
237
+ * @returns {string}
160
238
  */
161
- function search_with_answer(query, top_k, answer_top_k, mode, answer_mode, qa_subject) {
239
+ function search(query, top_k, mode, dense_lane_id, dense_query_vec) {
240
+ let deferred6_0;
241
+ let deferred6_1;
162
242
  try {
163
243
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
164
- const ptr0 = passStringToWasm0(query, wasm.__wbindgen_export, wasm.__wbindgen_export2);
244
+ const ptr0 = passStringToWasm0(query, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
165
245
  const len0 = WASM_VECTOR_LEN;
166
- const ptr1 = passStringToWasm0(mode, wasm.__wbindgen_export, wasm.__wbindgen_export2);
246
+ const ptr1 = passStringToWasm0(mode, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
167
247
  const len1 = WASM_VECTOR_LEN;
168
- const ptr2 = passStringToWasm0(qa_subject, wasm.__wbindgen_export, wasm.__wbindgen_export2);
169
- const len2 = WASM_VECTOR_LEN;
170
- wasm.search_with_answer(retptr, ptr0, len0, top_k, answer_top_k, ptr1, len1, answer_mode, ptr2, len2);
248
+ var ptr2 = isLikeNone(dense_lane_id) ? 0 : passStringToWasm0(dense_lane_id, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
249
+ var len2 = WASM_VECTOR_LEN;
250
+ var ptr3 = isLikeNone(dense_query_vec) ? 0 : passArrayF32ToWasm0(dense_query_vec, wasm.__wbindgen_export3);
251
+ var len3 = WASM_VECTOR_LEN;
252
+ wasm.search(retptr, ptr0, len0, top_k, ptr1, len1, ptr2, len2, ptr3, len3);
171
253
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
172
254
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
173
255
  var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
174
- if (r2) {
175
- throw takeObject(r1);
256
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
257
+ var ptr5 = r0;
258
+ var len5 = r1;
259
+ if (r3) {
260
+ ptr5 = 0; len5 = 0;
261
+ throw takeObject(r2);
176
262
  }
177
- return takeObject(r0);
263
+ deferred6_0 = ptr5;
264
+ deferred6_1 = len5;
265
+ return getStringFromWasm0(ptr5, len5);
178
266
  } finally {
179
267
  wasm.__wbindgen_add_to_stack_pointer(16);
268
+ wasm.__wbindgen_export2(deferred6_0, deferred6_1, 1);
180
269
  }
181
270
  }
182
- exports.search_with_answer = search_with_answer;
183
-
271
+ exports.search = search;
184
272
  function __wbg_get_imports() {
185
273
  const import0 = {
186
274
  __proto__: null,
187
- __wbg_String_8564e559799eccda: function(arg0, arg1) {
188
- const ret = String(getObject(arg1));
189
- const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
190
- const len1 = WASM_VECTOR_LEN;
191
- getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
192
- getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
193
- },
194
- __wbg___wbindgen_throw_6ddd609b62940d55: function(arg0, arg1) {
275
+ __wbg___wbindgen_throw_bb96b2010945f0bc: function(arg0, arg1) {
195
276
  throw new Error(getStringFromWasm0(arg0, arg1));
196
277
  },
197
- __wbg_getRandomValues_3f44b700395062e5: function() { return handleError(function (arg0, arg1) {
278
+ __wbg_error_dd408a7b3cb542dd: function(arg0) {
279
+ console.error(getObject(arg0));
280
+ },
281
+ __wbg_getRandomValues_a608c4436c19407a: function() { return handleError(function (arg0, arg1) {
198
282
  globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
199
283
  }, arguments); },
200
- __wbg_new_a70fbab9066b301f: function() {
201
- const ret = new Array();
202
- return addHeapObject(ret);
203
- },
204
- __wbg_new_ab79df5bd7c26067: function() {
205
- const ret = new Object();
206
- return addHeapObject(ret);
207
- },
208
- __wbg_now_16f0c993d5dd6c27: function() {
209
- const ret = Date.now();
210
- return ret;
211
- },
212
- __wbg_set_282384002438957f: function(arg0, arg1, arg2) {
213
- getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
214
- },
215
- __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
216
- getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
217
- },
218
- __wbindgen_cast_0000000000000001: function(arg0) {
219
- // Cast intrinsic for `F64 -> Externref`.
220
- const ret = arg0;
221
- return addHeapObject(ret);
222
- },
223
- __wbindgen_cast_0000000000000002: function(arg0, arg1) {
284
+ __wbindgen_cast_0000000000000001: function(arg0, arg1) {
224
285
  // Cast intrinsic for `Ref(String) -> Externref`.
225
286
  const ret = getStringFromWasm0(arg0, arg1);
226
287
  return addHeapObject(ret);
227
288
  },
228
- __wbindgen_object_clone_ref: function(arg0) {
229
- const ret = getObject(arg0);
230
- return addHeapObject(ret);
231
- },
232
289
  __wbindgen_object_drop_ref: function(arg0) {
233
290
  takeObject(arg0);
234
291
  },
@@ -267,9 +324,16 @@ let wasm_bindgen = (function(exports) {
267
324
  return cachedDataViewMemory0;
268
325
  }
269
326
 
327
+ let cachedFloat32ArrayMemory0 = null;
328
+ function getFloat32ArrayMemory0() {
329
+ if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
330
+ cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
331
+ }
332
+ return cachedFloat32ArrayMemory0;
333
+ }
334
+
270
335
  function getStringFromWasm0(ptr, len) {
271
- ptr = ptr >>> 0;
272
- return decodeText(ptr, len);
336
+ return decodeText(ptr >>> 0, len);
273
337
  }
274
338
 
275
339
  let cachedUint8ArrayMemory0 = null;
@@ -286,7 +350,7 @@ let wasm_bindgen = (function(exports) {
286
350
  try {
287
351
  return f.apply(this, args);
288
352
  } catch (e) {
289
- wasm.__wbindgen_export3(addHeapObject(e));
353
+ wasm.__wbindgen_export(addHeapObject(e));
290
354
  }
291
355
  }
292
356
 
@@ -295,6 +359,10 @@ let wasm_bindgen = (function(exports) {
295
359
 
296
360
  let heap_next = heap.length;
297
361
 
362
+ function isLikeNone(x) {
363
+ return x === undefined || x === null;
364
+ }
365
+
298
366
  function passArray8ToWasm0(arg, malloc) {
299
367
  const ptr = malloc(arg.length * 1, 1) >>> 0;
300
368
  getUint8ArrayMemory0().set(arg, ptr / 1);
@@ -302,6 +370,13 @@ let wasm_bindgen = (function(exports) {
302
370
  return ptr;
303
371
  }
304
372
 
373
+ function passArrayF32ToWasm0(arg, malloc) {
374
+ const ptr = malloc(arg.length * 4, 4) >>> 0;
375
+ getFloat32ArrayMemory0().set(arg, ptr / 4);
376
+ WASM_VECTOR_LEN = arg.length;
377
+ return ptr;
378
+ }
379
+
305
380
  function passStringToWasm0(arg, malloc, realloc) {
306
381
  if (realloc === undefined) {
307
382
  const buf = cachedTextEncoder.encode(arg);
@@ -366,22 +441,28 @@ let wasm_bindgen = (function(exports) {
366
441
 
367
442
  let WASM_VECTOR_LEN = 0;
368
443
 
369
- let wasmModule, wasm;
444
+ let wasmModule, wasmInstance, wasm;
370
445
  function __wbg_finalize_init(instance, module) {
446
+ wasmInstance = instance;
371
447
  wasm = instance.exports;
372
448
  wasmModule = module;
373
449
  cachedDataViewMemory0 = null;
450
+ cachedFloat32ArrayMemory0 = null;
374
451
  cachedUint8ArrayMemory0 = null;
375
452
  return wasm;
376
453
  }
377
454
 
378
455
  async function __wbg_load(module, imports) {
379
456
  if (typeof Response === 'function' && module instanceof Response) {
457
+ if (!module.ok) {
458
+ throw new Error(`failed to fetch Wasm: ${module.status} ${module.statusText} fetching '${module.url}'`);
459
+ }
460
+
380
461
  if (typeof WebAssembly.instantiateStreaming === 'function') {
381
462
  try {
382
463
  return await WebAssembly.instantiateStreaming(module, imports);
383
464
  } catch (e) {
384
- const validResponse = module.ok && expectedResponseType(module.type);
465
+ const validResponse = expectedResponseType(module.type);
385
466
 
386
467
  if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
387
468
  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);