Upload 23 files

assets/barq_vweb-DnpKI3q0.js

@@ -0,0 +1,369 @@
+class R {
+  __destroy_into_raw() {
+    const e = this.__wbg_ptr;
+    return this.__wbg_ptr = 0, x.unregister(this), e;
+  }
+  free() {
+    const e = this.__destroy_into_raw();
+    c.__wbg_barqvweb_free(e, 0);
+  }
+  backend_info() {
+    let e, t;
+    try {
+      const r = c.barqvweb_backend_info(this.__wbg_ptr);
+      return e = r[0], t = r[1], A(r[0], r[1]);
+    } finally {
+      c.__wbindgen_free(e, t, 1);
+    }
+  }
+  clear() {
+    return c.barqvweb_clear(this.__wbg_ptr);
+  }
+  count() {
+    return c.barqvweb_count(this.__wbg_ptr) >>> 0;
+  }
+  delete(e) {
+    return c.barqvweb_delete(this.__wbg_ptr, e);
+  }
+  insert_texts(e, t) {
+    return c.barqvweb_insert_texts(this.__wbg_ptr, e, t);
+  }
+  insert_vectors(e, t, r) {
+    return c.barqvweb_insert_vectors(this.__wbg_ptr, e, t, r);
+  }
+  load() {
+    return c.barqvweb_load(this.__wbg_ptr);
+  }
+  constructor(e, t) {
+    const r = m(e, c.__wbindgen_malloc, c.__wbindgen_realloc), _ = l;
+    var i = b(t) ? 0 : m(t, c.__wbindgen_malloc, c.__wbindgen_realloc), o = l;
+    const s = c.barqvweb_new(r, _, i, o);
+    return this.__wbg_ptr = s >>> 0, x.register(this, this.__wbg_ptr, this), this;
+  }
+  save() {
+    return c.barqvweb_save(this.__wbg_ptr);
+  }
+  search(e, t, r) {
+    const _ = m(e, c.__wbindgen_malloc, c.__wbindgen_realloc), i = l;
+    return c.barqvweb_search(this.__wbg_ptr, _, i, t, r);
+  }
+  search_vector(e, t) {
+    return c.barqvweb_search_vector(this.__wbg_ptr, e, t);
+  }
+}
+Symbol.dispose && (R.prototype[Symbol.dispose] = R.prototype.free);
+function S() {
+  return { __proto__: null, "./barq_vweb_bg.js": { __proto__: null, __wbg___wbindgen_is_function_3c846841762788c1: function(e) {
+    return typeof e == "function";
+  }, __wbg___wbindgen_is_object_781bc9f159099513: function(e) {
+    const t = e;
+    return typeof t == "object" && t !== null;
+  }, __wbg___wbindgen_is_string_7ef6b97b02428fae: function(e) {
+    return typeof e == "string";
+  }, __wbg___wbindgen_is_undefined_52709e72fb9f179c: function(e) {
+    return e === void 0;
+  }, __wbg___wbindgen_number_get_34bb9d9dcfa21373: function(e, t) {
+    const r = t, _ = typeof r == "number" ? r : void 0;
+    d().setFloat64(e + 8, b(_) ? 0 : _, true), d().setInt32(e + 0, !b(_), true);
+  }, __wbg___wbindgen_string_get_395e606bd0ee4427: function(e, t) {
+    const r = t, _ = typeof r == "string" ? r : void 0;
+    var i = b(_) ? 0 : m(_, c.__wbindgen_malloc, c.__wbindgen_realloc), o = l;
+    d().setInt32(e + 4, o, true), d().setInt32(e + 0, i, true);
+  }, __wbg___wbindgen_throw_6ddd609b62940d55: function(e, t) {
+    throw new Error(A(e, t));
+  }, __wbg__wbg_cb_unref_6b5b6b8576d35cb1: function(e) {
+    e._wbg_cb_unref();
+  }, __wbg_apply_d7728efbea08f95e: function() {
+    return u(function(e, t, r) {
+      return Reflect.apply(e, t, r);
+    }, arguments);
+  }, __wbg_call_2d781c1f4d5c0ef8: function() {
+    return u(function(e, t, r) {
+      return e.call(t, r);
+    }, arguments);
+  }, __wbg_call_dcc2662fa17a72cf: function() {
+    return u(function(e, t, r, _) {
+      return e.call(t, r, _);
+    }, arguments);
+  }, __wbg_crypto_38df2bab126b63dc: function(e) {
+    return e.crypto;
+  }, __wbg_error_a6fa202b58aa1cd3: function(e, t) {
+    let r, _;
+    try {
+      r = e, _ = t, console.error(A(e, t));
+    } finally {
+      c.__wbindgen_free(r, _, 1);
+    }
+  }, __wbg_getRandomValues_c44a50d8cfdaebeb: function() {
+    return u(function(e, t) {
+      e.getRandomValues(t);
+    }, arguments);
+  }, __wbg_get_3ef1eba1850ade27: function() {
+    return u(function(e, t) {
+      return Reflect.get(e, t);
+    }, arguments);
+  }, __wbg_get_a8ee5c45dabc1b3b: function(e, t) {
+    return e[t >>> 0];
+  }, __wbg_length_259ee9d041e381ad: function(e) {
+    return e.length;
+  }, __wbg_length_27280eca2d70010e: function(e) {
+    return e.length;
+  }, __wbg_length_b3416cf66a5452c8: function(e) {
+    return e.length;
+  }, __wbg_length_ea16607d7b61445b: function(e) {
+    return e.length;
+  }, __wbg_msCrypto_bd5a034af96bcba6: function(e) {
+    return e.msCrypto;
+  }, __wbg_new_227d7c05414eb861: function() {
+    return new Error();
+  }, __wbg_new_5f486cdf45a04d78: function(e) {
+    return new Uint8Array(e);
+  }, __wbg_new_a70fbab9066b301f: function() {
+    return new Array();
+  }, __wbg_new_ab79df5bd7c26067: function() {
+    return new Object();
+  }, __wbg_new_from_slice_ff2c15e8e05ffdfc: function(e, t) {
+    return new Float32Array(W(e, t));
+  }, __wbg_new_typed_aaaeaf29cf802876: function(e, t) {
+    try {
+      var r = { a: e, b: t }, _ = (o, s) => {
+        const a = r.a;
+        r.a = 0;
+        try {
+          return U(a, r.b, o, s);
+        } finally {
+          r.a = a;
+        }
+      };
+      return new Promise(_);
+    } finally {
+      r.a = r.b = 0;
+    }
+  }, __wbg_new_with_length_825018a1616e9e55: function(e) {
+    return new Uint8Array(e >>> 0);
+  }, __wbg_node_84ea875411254db1: function(e) {
+    return e.node;
+  }, __wbg_process_44c7a14e11e9f69e: function(e) {
+    return e.process;
+  }, __wbg_prototypesetcall_247ac4333d4d3cb4: function(e, t, r) {
+    Float32Array.prototype.set.call(W(e, t), r);
+  }, __wbg_prototypesetcall_d62e5099504357e6: function(e, t, r) {
+    Uint8Array.prototype.set.call(k(e, t), r);
+  }, __wbg_prototypesetcall_f04613188bde902d: function(e, t, r) {
+    Uint32Array.prototype.set.call(E(e, t), r);
+  }, __wbg_push_e87b0e732085a946: function(e, t) {
+    return e.push(t);
+  }, __wbg_queueMicrotask_0c399741342fb10f: function(e) {
+    return e.queueMicrotask;
+  }, __wbg_queueMicrotask_a082d78ce798393e: function(e) {
+    queueMicrotask(e);
+  }, __wbg_randomFillSync_6c25eac9869eb53c: function() {
+    return u(function(e, t) {
+      e.randomFillSync(t);
+    }, arguments);
+  }, __wbg_require_b4edbdcf3e2a1ef0: function() {
+    return u(function() {
+      return module.require;
+    }, arguments);
+  }, __wbg_resolve_ae8d83246e5bcc12: function(e) {
+    return Promise.resolve(e);
+  }, __wbg_set_282384002438957f: function(e, t, r) {
+    e[t >>> 0] = r;
+  }, __wbg_set_6be42768c690e380: function(e, t, r) {
+    e[t] = r;
+  }, __wbg_set_7eaa4f96924fd6b3: function() {
+    return u(function(e, t, r) {
+      return Reflect.set(e, t, r);
+    }, arguments);
+  }, __wbg_stack_3b0d974bbf31e44f: function(e, t) {
+    const r = t.stack, _ = m(r, c.__wbindgen_malloc, c.__wbindgen_realloc), i = l;
+    d().setInt32(e + 4, i, true), d().setInt32(e + 0, _, true);
+  }, __wbg_static_accessor_GLOBAL_8adb955bd33fac2f: function() {
+    const e = typeof global > "u" ? null : global;
+    return b(e) ? 0 : w(e);
+  }, __wbg_static_accessor_GLOBAL_THIS_ad356e0db91c7913: function() {
+    const e = typeof globalThis > "u" ? null : globalThis;
+    return b(e) ? 0 : w(e);
+  }, __wbg_static_accessor_SELF_f207c857566db248: function() {
+    const e = typeof self > "u" ? null : self;
+    return b(e) ? 0 : w(e);
+  }, __wbg_static_accessor_WINDOW_bb9f1ba69d61b386: function() {
+    const e = typeof window > "u" ? null : window;
+    return b(e) ? 0 : w(e);
+  }, __wbg_subarray_a068d24e39478a8a: function(e, t, r) {
+    return e.subarray(t >>> 0, r >>> 0);
+  }, __wbg_then_098abe61755d12f6: function(e, t) {
+    return e.then(t);
+  }, __wbg_then_9e335f6dd892bc11: function(e, t, r) {
+    return e.then(t, r);
+  }, __wbg_versions_276b2795b1c6a219: function(e) {
+    return e.versions;
+  }, __wbindgen_cast_0000000000000001: function(e, t) {
+    return j(e, t, c.wasm_bindgen__closure__destroy__h5fc7b39f71c2d967, O);
+  }, __wbindgen_cast_0000000000000002: function(e) {
+    return e;
+  }, __wbindgen_cast_0000000000000003: function(e, t) {
+    return k(e, t);
+  }, __wbindgen_cast_0000000000000004: function(e, t) {
+    return A(e, t);
+  }, __wbindgen_init_externref_table: function() {
+    const e = c.__wbindgen_externrefs, t = e.grow(4);
+    e.set(0, void 0), e.set(t + 0, void 0), e.set(t + 1, null), e.set(t + 2, true), e.set(t + 3, false);
+  } } };
+}
+function O(n, e, t) {
+  const r = c.wasm_bindgen__convert__closures_____invoke__h85e564a221c428e3(n, e, t);
+  if (r[1]) throw D(r[0]);
+}
+function U(n, e, t, r) {
+  c.wasm_bindgen__convert__closures_____invoke__h14d9ba7aff402d3a(n, e, t, r);
+}
+const x = typeof FinalizationRegistry > "u" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((n) => c.__wbg_barqvweb_free(n >>> 0, 1));
+function w(n) {
+  const e = c.__externref_table_alloc();
+  return c.__wbindgen_externrefs.set(e, n), e;
+}
+const M = typeof FinalizationRegistry > "u" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((n) => n.dtor(n.a, n.b));
+function W(n, e) {
+  return n = n >>> 0, I().subarray(n / 4, n / 4 + e);
+}
+function E(n, e) {
+  return n = n >>> 0, L().subarray(n / 4, n / 4 + e);
+}
+function k(n, e) {
+  return n = n >>> 0, h().subarray(n / 1, n / 1 + e);
+}
+let f = null;
+function d() {
+  return (f === null || f.buffer.detached === true || f.buffer.detached === void 0 && f.buffer !== c.memory.buffer) && (f = new DataView(c.memory.buffer)), f;
+}
+let g = null;
+function I() {
+  return (g === null || g.byteLength === 0) && (g = new Float32Array(c.memory.buffer)), g;
+}
+function A(n, e) {
+  return n = n >>> 0, C(n, e);
+}
+let y = null;
+function L() {
+  return (y === null || y.byteLength === 0) && (y = new Uint32Array(c.memory.buffer)), y;
+}
+let p = null;
+function h() {
+  return (p === null || p.byteLength === 0) && (p = new Uint8Array(c.memory.buffer)), p;
+}
+function u(n, e) {
+  try {
+    return n.apply(this, e);
+  } catch (t) {
+    const r = w(t);
+    c.__wbindgen_exn_store(r);
+  }
+}
+function b(n) {
+  return n == null;
+}
+function j(n, e, t, r) {
+  const _ = { a: n, b: e, cnt: 1, dtor: t }, i = (...o) => {
+    _.cnt++;
+    const s = _.a;
+    _.a = 0;
+    try {
+      return r(s, _.b, ...o);
+    } finally {
+      _.a = s, i._wbg_cb_unref();
+    }
+  };
+  return i._wbg_cb_unref = () => {
+    --_.cnt === 0 && (_.dtor(_.a, _.b), _.a = 0, M.unregister(_));
+  }, M.register(i, _, _), i;
+}
+function m(n, e, t) {
+  if (t === void 0) {
+    const s = v.encode(n), a = e(s.length, 1) >>> 0;
+    return h().subarray(a, a + s.length).set(s), l = s.length, a;
+  }
+  let r = n.length, _ = e(r, 1) >>> 0;
+  const i = h();
+  let o = 0;
+  for (; o < r; o++) {
+    const s = n.charCodeAt(o);
+    if (s > 127) break;
+    i[_ + o] = s;
+  }
+  if (o !== r) {
+    o !== 0 && (n = n.slice(o)), _ = t(_, r, r = o + n.length * 3, 1) >>> 0;
+    const s = h().subarray(_ + o, _ + r), a = v.encodeInto(n, s);
+    o += a.written, _ = t(_, r, o, 1) >>> 0;
+  }
+  return l = o, _;
+}
+function D(n) {
+  const e = c.__wbindgen_externrefs.get(n);
+  return c.__externref_table_dealloc(n), e;
+}
+let q = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+q.decode();
+const B = 2146435072;
+let F = 0;
+function C(n, e) {
+  return F += e, F >= B && (q = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true }), q.decode(), F = e), q.decode(h().subarray(n, n + e));
+}
+const v = new TextEncoder();
+"encodeInto" in v || (v.encodeInto = function(n, e) {
+  const t = v.encode(n);
+  return e.set(t), { read: n.length, written: t.length };
+});
+let l = 0, c;
+function T(n, e) {
+  return c = n.exports, f = null, g = null, y = null, p = null, c.__wbindgen_start(), c;
+}
+async function V(n, e) {
+  if (typeof Response == "function" && n instanceof Response) {
+    if (typeof WebAssembly.instantiateStreaming == "function") try {
+      return await WebAssembly.instantiateStreaming(n, e);
+    } catch (_) {
+      if (n.ok && t(n.type) && n.headers.get("Content-Type") !== "application/wasm") 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", _);
+      else throw _;
+    }
+    const r = await n.arrayBuffer();
+    return await WebAssembly.instantiate(r, e);
+  } else {
+    const r = await WebAssembly.instantiate(n, e);
+    return r instanceof WebAssembly.Instance ? { instance: r, module: n } : r;
+  }
+  function t(r) {
+    switch (r) {
+      case "basic":
+      case "cors":
+      case "default":
+        return true;
+    }
+    return false;
+  }
+}
+function z(n) {
+  if (c !== void 0) return c;
+  n !== void 0 && (Object.getPrototypeOf(n) === Object.prototype ? { module: n } = n : console.warn("using deprecated parameters for `initSync()`; pass a single object instead"));
+  const e = S();
+  n instanceof WebAssembly.Module || (n = new WebAssembly.Module(n));
+  const t = new WebAssembly.Instance(n, e);
+  return T(t);
+}
+async function P(n) {
+  if (c !== void 0) return c;
+  n !== void 0 && (Object.getPrototypeOf(n) === Object.prototype ? { module_or_path: n } = n : console.warn("using deprecated parameters for the initialization function; pass a single object instead")), n === void 0 && (n = new URL("/barq-vweb-pkg/barq_vweb_bg.wasm", import.meta.url));
+  const e = S();
+  (typeof n == "string" || typeof Request == "function" && n instanceof Request || typeof URL == "function" && n instanceof URL) && (n = fetch(n));
+  const { instance: t, module: r } = await V(await n, e);
+  return T(t);
+}
+export {
+  R as BarqVWeb,
+  P as default,
+  z as initSync
+};

assets/barq_wasm-CGVSSFYy.js

@@ -0,0 +1,313 @@
+function M(n) {
+  const e = l(n, t.__wbindgen_malloc), r = s;
+  return t.argmax(e, r) >>> 0;
+}
+function R(n) {
+  const e = l(n, t.__wbindgen_malloc), r = s;
+  return t.argmin(e, r) >>> 0;
+}
+function F(n, e, r, c) {
+  const o = l(n, t.__wbindgen_malloc), i = s, _ = t.avg_pooling_2d(o, i, e, r, c);
+  var a = u(_[0], _[1]).slice();
+  return t.__wbindgen_free(_[0], _[1] * 4, 4), a;
+}
+function O(n, e, r, c) {
+  const o = l(n, t.__wbindgen_malloc), i = s, _ = t.batch_normalize(o, i, e, r, c);
+  var a = u(_[0], _[1]).slice();
+  return t.__wbindgen_free(_[0], _[1] * 4, 4), a;
+}
+function j(n, e, r, c, o) {
+  const i = l(n, t.__wbindgen_malloc), _ = s, a = l(e, t.__wbindgen_malloc), d = s, m = t.conv2d_optimized(i, _, a, d, r, c, o);
+  var w = u(m[0], m[1]).slice();
+  return t.__wbindgen_free(m[0], m[1] * 4, 4), w;
+}
+function I(n, e, r, c, o) {
+  const i = l(n, t.__wbindgen_malloc), _ = s, a = l(e, t.__wbindgen_malloc), d = s, m = t.conv2d_scalar(i, _, a, d, r, c, o);
+  var w = u(m[0], m[1]).slice();
+  return t.__wbindgen_free(m[0], m[1] * 4, 4), w;
+}
+function L(n, e) {
+  const r = l(n, t.__wbindgen_malloc), c = s, o = l(e, t.__wbindgen_malloc), i = s;
+  return t.cosine_similarity_scalar(r, c, o, i);
+}
+function U(n, e) {
+  const r = l(n, t.__wbindgen_malloc), c = s, o = l(e, t.__wbindgen_malloc), i = s;
+  return t.cosine_similarity_simd(r, c, o, i);
+}
+function S(n, e) {
+  const r = p(n, t.__wbindgen_malloc), c = s, o = t.dequantize_int8(r, c, e);
+  var i = u(o[0], o[1]).slice();
+  return t.__wbindgen_free(o[0], o[1] * 4, 4), i;
+}
+function k(n, e) {
+  const r = l(n, t.__wbindgen_malloc), c = s, o = l(e, t.__wbindgen_malloc), i = s;
+  return t.dot_product_scalar(r, c, o, i);
+}
+function T(n, e) {
+  const r = l(n, t.__wbindgen_malloc), c = s, o = l(e, t.__wbindgen_malloc), i = s;
+  return t.dot_product_simd(r, c, o, i);
+}
+function E(n, e) {
+  const r = l(n, t.__wbindgen_malloc), c = s, o = l(e, t.__wbindgen_malloc), i = s;
+  return t.euclidean_distance(r, c, o, i);
+}
+function C(n, e) {
+  const r = l(n, t.__wbindgen_malloc), c = s, o = t.leaky_relu(r, c, e);
+  var i = u(o[0], o[1]).slice();
+  return t.__wbindgen_free(o[0], o[1] * 4, 4), i;
+}
+function P(n) {
+  const e = p(n, t.__wbindgen_malloc), r = s, c = t.lz4_compress_optimized(e, r);
+  var o = A(c[0], c[1]).slice();
+  return t.__wbindgen_free(c[0], c[1] * 1, 1), o;
+}
+function B(n) {
+  const e = p(n, t.__wbindgen_malloc), r = s, c = t.lz4_compress_scalar(e, r);
+  var o = A(c[0], c[1]).slice();
+  return t.__wbindgen_free(c[0], c[1] * 1, 1), o;
+}
+function N(n, e) {
+  const r = l(n, t.__wbindgen_malloc), c = s, o = l(e, t.__wbindgen_malloc), i = s;
+  return t.manhattan_distance(r, c, o, i);
+}
+function V(n, e) {
+  const r = l(n, t.__wbindgen_malloc), c = s, o = l(e, t.__wbindgen_malloc), i = s, _ = t.matrix_add(r, c, o, i);
+  var a = u(_[0], _[1]).slice();
+  return t.__wbindgen_free(_[0], _[1] * 4, 4), a;
+}
+function D(n, e, r) {
+  const c = l(n, t.__wbindgen_malloc), o = s, i = l(e, t.__wbindgen_malloc), _ = s, a = t.matrix_multiply_scalar(c, o, i, _, r);
+  var d = u(a[0], a[1]).slice();
+  return t.__wbindgen_free(a[0], a[1] * 4, 4), d;
+}
+function G(n, e, r) {
+  const c = l(n, t.__wbindgen_malloc), o = s, i = l(e, t.__wbindgen_malloc), _ = s, a = t.matrix_multiply_tiled(c, o, i, _, r);
+  var d = u(a[0], a[1]).slice();
+  return t.__wbindgen_free(a[0], a[1] * 4, 4), d;
+}
+function H(n, e) {
+  const r = l(n, t.__wbindgen_malloc), c = s, o = t.matrix_scalar_multiply(r, c, e);
+  var i = u(o[0], o[1]).slice();
+  return t.__wbindgen_free(o[0], o[1] * 4, 4), i;
+}
+function J(n, e, r) {
+  const c = l(n, t.__wbindgen_malloc), o = s, i = t.matrix_transpose(c, o, e, r);
+  var _ = u(i[0], i[1]).slice();
+  return t.__wbindgen_free(i[0], i[1] * 4, 4), _;
+}
+function K(n, e, r, c) {
+  const o = l(n, t.__wbindgen_malloc), i = s, _ = t.max_pooling_2d(o, i, e, r, c);
+  var a = u(_[0], _[1]).slice();
+  return t.__wbindgen_free(_[0], _[1] * 4, 4), a;
+}
+function Q(n) {
+  const e = l(n, t.__wbindgen_malloc), r = s;
+  return t.mean(e, r);
+}
+function X(n, e) {
+  const r = l(n, t.__wbindgen_malloc), c = s, o = t.quantize_int8_scalar(r, c, e);
+  var i = y(o[0], o[1]).slice();
+  return t.__wbindgen_free(o[0], o[1] * 1, 1), i;
+}
+function Y(n, e) {
+  const r = l(n, t.__wbindgen_malloc), c = s, o = t.quantize_int8_simd(r, c, e);
+  var i = y(o[0], o[1]).slice();
+  return t.__wbindgen_free(o[0], o[1] * 1, 1), i;
+}
+function Z(n) {
+  const e = l(n, t.__wbindgen_malloc), r = s, c = t.relu(e, r);
+  var o = u(c[0], c[1]).slice();
+  return t.__wbindgen_free(c[0], c[1] * 4, 4), o;
+}
+function $(n) {
+  const e = l(n, t.__wbindgen_malloc), r = s, c = t.sigmoid(e, r);
+  var o = u(c[0], c[1]).slice();
+  return t.__wbindgen_free(c[0], c[1] * 4, 4), o;
+}
+function nn(n) {
+  const e = l(n, t.__wbindgen_malloc), r = s, c = t.softmax(e, r);
+  var o = u(c[0], c[1]).slice();
+  return t.__wbindgen_free(c[0], c[1] * 4, 4), o;
+}
+function tn(n) {
+  const e = l(n, t.__wbindgen_malloc), r = s;
+  return t.std_dev(e, r);
+}
+function en(n) {
+  const e = l(n, t.__wbindgen_malloc), r = s;
+  return t.variance(e, r);
+}
+function rn(n, e) {
+  const r = l(n, t.__wbindgen_malloc), c = s, o = l(e, t.__wbindgen_malloc), i = s, _ = t.vector_add(r, c, o, i);
+  var a = u(_[0], _[1]).slice();
+  return t.__wbindgen_free(_[0], _[1] * 4, 4), a;
+}
+function cn(n, e, r) {
+  const c = l(n, t.__wbindgen_malloc), o = s, i = t.vector_clamp(c, o, e, r);
+  var _ = u(i[0], i[1]).slice();
+  return t.__wbindgen_free(i[0], i[1] * 4, 4), _;
+}
+function on(n, e) {
+  const r = l(n, t.__wbindgen_malloc), c = s, o = l(e, t.__wbindgen_malloc), i = s, _ = t.vector_elementwise_multiply(r, c, o, i);
+  var a = u(_[0], _[1]).slice();
+  return t.__wbindgen_free(_[0], _[1] * 4, 4), a;
+}
+function sn(n) {
+  const e = l(n, t.__wbindgen_malloc), r = s;
+  return t.vector_max(e, r);
+}
+function _n(n) {
+  const e = l(n, t.__wbindgen_malloc), r = s;
+  return t.vector_min(e, r);
+}
+function ln(n) {
+  const e = l(n, t.__wbindgen_malloc), r = s;
+  return t.vector_norm_scalar(e, r);
+}
+function an(n) {
+  const e = l(n, t.__wbindgen_malloc), r = s;
+  return t.vector_norm_simd(e, r);
+}
+function un(n) {
+  const e = l(n, t.__wbindgen_malloc), r = s, c = t.vector_normalize(e, r);
+  var o = u(c[0], c[1]).slice();
+  return t.__wbindgen_free(c[0], c[1] * 4, 4), o;
+}
+function mn(n, e) {
+  const r = l(n, t.__wbindgen_malloc), c = s, o = t.vector_scale(r, c, e);
+  var i = u(o[0], o[1]).slice();
+  return t.__wbindgen_free(o[0], o[1] * 4, 4), i;
+}
+function dn(n, e) {
+  const r = l(n, t.__wbindgen_malloc), c = s, o = l(e, t.__wbindgen_malloc), i = s, _ = t.vector_subtract(r, c, o, i);
+  var a = u(_[0], _[1]).slice();
+  return t.__wbindgen_free(_[0], _[1] * 4, 4), a;
+}
+function fn(n) {
+  const e = l(n, t.__wbindgen_malloc), r = s;
+  return t.vector_sum(e, r);
+}
+function v() {
+  return { __proto__: null, "./barq_wasm_bg.js": { __proto__: null, __wbindgen_init_externref_table: function() {
+    const e = t.__wbindgen_externrefs, r = e.grow(4);
+    e.set(0, void 0), e.set(r + 0, void 0), e.set(r + 1, null), e.set(r + 2, true), e.set(r + 3, false);
+  } } };
+}
+function u(n, e) {
+  return n = n >>> 0, x().subarray(n / 4, n / 4 + e);
+}
+function y(n, e) {
+  return n = n >>> 0, h().subarray(n / 1, n / 1 + e);
+}
+function A(n, e) {
+  return n = n >>> 0, z().subarray(n / 1, n / 1 + e);
+}
+let f = null;
+function x() {
+  return (f === null || f.byteLength === 0) && (f = new Float32Array(t.memory.buffer)), f;
+}
+let b = null;
+function h() {
+  return (b === null || b.byteLength === 0) && (b = new Int8Array(t.memory.buffer)), b;
+}
+let g = null;
+function z() {
+  return (g === null || g.byteLength === 0) && (g = new Uint8Array(t.memory.buffer)), g;
+}
+function p(n, e) {
+  const r = e(n.length * 1, 1) >>> 0;
+  return z().set(n, r / 1), s = n.length, r;
+}
+function l(n, e) {
+  const r = e(n.length * 4, 4) >>> 0;
+  return x().set(n, r / 4), s = n.length, r;
+}
+let s = 0, t;
+function W(n, e) {
+  return t = n.exports, f = null, b = null, g = null, t.__wbindgen_start(), t;
+}
+async function q(n, e) {
+  if (typeof Response == "function" && n instanceof Response) {
+    if (typeof WebAssembly.instantiateStreaming == "function") try {
+      return await WebAssembly.instantiateStreaming(n, e);
+    } catch (o) {
+      if (n.ok && r(n.type) && n.headers.get("Content-Type") !== "application/wasm") 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", o);
+      else throw o;
+    }
+    const c = await n.arrayBuffer();
+    return await WebAssembly.instantiate(c, e);
+  } else {
+    const c = await WebAssembly.instantiate(n, e);
+    return c instanceof WebAssembly.Instance ? { instance: c, module: n } : c;
+  }
+  function r(c) {
+    switch (c) {
+      case "basic":
+      case "cors":
+      case "default":
+        return true;
+    }
+    return false;
+  }
+}
+function bn(n) {
+  if (t !== void 0) return t;
+  n !== void 0 && (Object.getPrototypeOf(n) === Object.prototype ? { module: n } = n : console.warn("using deprecated parameters for `initSync()`; pass a single object instead"));
+  const e = v();
+  n instanceof WebAssembly.Module || (n = new WebAssembly.Module(n));
+  const r = new WebAssembly.Instance(n, e);
+  return W(r);
+}
+async function gn(n) {
+  if (t !== void 0) return t;
+  n !== void 0 && (Object.getPrototypeOf(n) === Object.prototype ? { module_or_path: n } = n : console.warn("using deprecated parameters for the initialization function; pass a single object instead")), n === void 0 && (n = new URL("/barq-wasm-pkg/barq_wasm_bg.wasm", import.meta.url));
+  const e = v();
+  (typeof n == "string" || typeof Request == "function" && n instanceof Request || typeof URL == "function" && n instanceof URL) && (n = fetch(n));
+  const { instance: r, module: c } = await q(await n, e);
+  return W(r);
+}
+export {
+  M as argmax,
+  R as argmin,
+  F as avg_pooling_2d,
+  O as batch_normalize,
+  j as conv2d_optimized,
+  I as conv2d_scalar,
+  L as cosine_similarity_scalar,
+  U as cosine_similarity_simd,
+  gn as default,
+  S as dequantize_int8,
+  k as dot_product_scalar,
+  T as dot_product_simd,
+  E as euclidean_distance,
+  bn as initSync,
+  C as leaky_relu,
+  P as lz4_compress_optimized,
+  B as lz4_compress_scalar,
+  N as manhattan_distance,
+  V as matrix_add,
+  D as matrix_multiply_scalar,
+  G as matrix_multiply_tiled,
+  H as matrix_scalar_multiply,
+  J as matrix_transpose,
+  K as max_pooling_2d,
+  Q as mean,
+  X as quantize_int8_scalar,
+  Y as quantize_int8_simd,
+  Z as relu,
+  $ as sigmoid,
+  nn as softmax,
+  tn as std_dev,
+  en as variance,
+  rn as vector_add,
+  cn as vector_clamp,
+  on as vector_elementwise_multiply,
+  sn as vector_max,
+  _n as vector_min,
+  ln as vector_norm_scalar,
+  an as vector_norm_simd,
+  un as vector_normalize,
+  mn as vector_scale,
+  dn as vector_subtract,
+  fn as vector_sum
+};

assets/index-CAjvEqqe.css

@@ -0,0 +1,10 @@
+:root{--bg-base: #f9fafb;--bg-surface: #ffffff;--bg-card: #ffffff;--bg-card-hover: #f3f4f6;--border: #e5e7eb;--border-active: #8b5cf6;--accent: #6d28d9;--accent-light: #8b5cf6;--accent-2: #4f46e5;--accent-glow: rgba(109, 40, 217, .15);--text-primary: #111827;--text-secondary: #4b5563;--text-muted: #6b7280;--green: #059669;--red: #dc2626;--amber: #d97706;--radius-sm: .375rem;--radius-md: .5rem;--radius-lg: .75rem;--radius-xl: 1rem;--shadow-glow: 0 4px 14px 0 rgba(109, 40, 217, .39);--shadow-card: 0 1px 3px 0 rgba(0, 0, 0, .1), 0 1px 2px -1px rgba(0, 0, 0, .1)}*,*:before,*:after{box-sizing:border-box;margin:0;padding:0}html,body,#root{height:100%;width:100%}body{font-family:Inter,-apple-system,BlinkMacSystemFont,system-ui,sans-serif;background:var(--bg-base);color:var(--text-primary);line-height:1.6;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}::-webkit-scrollbar{width:5px;height:5px}::-webkit-scrollbar-track{background:transparent}::-webkit-scrollbar-thumb{background:#00000026;border-radius:4px}::-webkit-scrollbar-thumb:hover{background:#00000040}h1,h2,h3{font-weight:700;letter-spacing:-.02em}h1{font-size:clamp(1.6rem,4vw,2.4rem)}h2{font-size:1.2rem}h3{font-size:1rem}p,span,label{font-size:.9rem}small{font-size:.78rem}code{font-family:SF Mono,Fira Code,Cascadia Code,monospace;font-size:.85em}.gradient-text{background:linear-gradient(135deg,var(--accent-light),var(--accent-2));-webkit-background-clip:text;-webkit-text-fill-color:transparent;background-clip:text}.glass-card{background:var(--bg-card);border:1px solid var(--border);border-radius:var(--radius-lg);box-shadow:var(--shadow-card)}.btn{display:inline-flex;align-items:center;gap:.5rem;padding:.55rem 1.1rem;border-radius:var(--radius-md);font-size:.875rem;font-weight:600;cursor:pointer;border:none;outline:none;transition:all .18s ease;text-decoration:none;white-space:nowrap}.btn:disabled{opacity:.4;cursor:not-allowed;transform:none!important}.btn-primary{background:linear-gradient(135deg,var(--accent),var(--accent-2));color:#fff;box-shadow:0 0 20px var(--accent-glow)}.btn-primary:hover:not(:disabled){opacity:.9;transform:translateY(-1px);box-shadow:0 0 28px var(--accent-glow)}.btn-primary:active:not(:disabled){transform:translateY(0)}.btn-ghost{background:transparent;color:var(--text-secondary);border:1px solid var(--border)}.btn-ghost:hover:not(:disabled){background:var(--bg-card-hover);color:var(--text-primary);border-color:#d1d5db}.btn-danger{background:#ef44441a;color:var(--red);border:1px solid rgba(239,68,68,.25)}.btn-danger:hover:not(:disabled){background:#ef444433}.btn-sm{padding:.35rem .75rem;font-size:.8rem}.btn-icon{padding:.5rem;border-radius:var(--radius-sm)}.input{width:100%;background:var(--bg-base);border:1px solid var(--border);border-radius:var(--radius-md);padding:.65rem 1rem;color:var(--text-primary);font-size:.9rem;font-family:inherit;outline:none;transition:border-color .18s,box-shadow .18s;resize:none}.input::placeholder{color:var(--text-muted)}.input:focus{border-color:var(--border-active);box-shadow:0 0 0 3px #7c3aed1f}.badge{display:inline-flex;align-items:center;gap:.3rem;padding:.2rem .6rem;border-radius:9999px;font-size:.7rem;font-weight:600;letter-spacing:.04em;text-transform:uppercase}.badge-purple{background:#7c3aed26;color:var(--accent-light);border:1px solid rgba(124,58,237,.3)}.badge-green{background:#10b9811f;color:var(--green);border:1px solid rgba(16,185,129,.25)}.badge-amber{background:#f59e0b1f;color:var(--amber);border:1px solid rgba(245,158,11,.25)}.badge-red{background:#ef44441f;color:var(--red);border:1px solid rgba(239,68,68,.25)}.progress-track{height:4px;background:#e5e7eb;border-radius:9999px;overflow:hidden}.progress-fill{height:100%;background:linear-gradient(90deg,var(--accent),var(--accent-2));border-radius:9999px;transition:width .3s ease}.dot-pulse{display:inline-block;width:8px;height:8px;border-radius:50%;animation:dotPulse 2s ease-in-out infinite}.dot-green{background:var(--green)}.dot-amber{background:var(--amber)}.dot-purple{background:var(--accent-light)}.dot-red{background:var(--red)}@keyframes dotPulse{0%,to{opacity:1}50%{opacity:.35}}.cursor-blink:after{content:"▋";animation:blink 1s step-end infinite;color:var(--accent-light);margin-left:1px}@keyframes blink{0%,to{opacity:1}50%{opacity:0}}@keyframes fadeUp{0%{opacity:0;transform:translateY(12px)}to{opacity:1;transform:translateY(0)}}@keyframes fadeIn{0%{opacity:0}to{opacity:1}}@keyframes slideInLeft{0%{opacity:0;transform:translate(-16px)}to{opacity:1;transform:translate(0)}}@keyframes spin{to{transform:rotate(360deg)}}.animate-fade-up{animation:fadeUp .4s ease forwards}.animate-fade-in{animation:fadeIn .3s ease forwards}.animate-slide-left{animation:slideInLeft .35s ease forwards}.animate-spin{animation:spin .7s linear infinite}.flex{display:flex}.flex-col{flex-direction:column}.items-center{align-items:center}.justify-center{justify-content:center}.justify-between{justify-content:space-between}.gap-1{gap:.25rem}.gap-2{gap:.5rem}.gap-3{gap:.75rem}.gap-4{gap:1rem}.gap-6{gap:1.5rem}.w-full{width:100%}.h-full{height:100%}.min-h-0{min-height:0}.flex-1{flex:1}.truncate{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.text-center{text-align:center}.overflow-y-auto{overflow-y:auto}.overflow-hidden{overflow:hidden}.relative{position:relative}.absolute{position:absolute}.divider{height:1px;background:var(--border);border:none;margin:0}.msg-content{line-height:1.7}.msg-content h1,.msg-content h2,.msg-content h3,.msg-content h4{margin:.9em 0 .3em;font-weight:700;color:var(--text-primary);line-height:1.3}.msg-content h1{font-size:1.2em}.msg-content h2{font-size:1.1em}.msg-content h3{font-size:1em}.msg-content p{margin:.45em 0}.msg-content p:first-child{margin-top:0}.msg-content p:last-child{margin-bottom:0}.msg-content ul,.msg-content ol{padding-left:1.4em;margin:.4em 0}.msg-content li{margin:.2em 0}.msg-content blockquote{border-left:3px solid var(--accent);margin:.6em 0;padding:.25em .8em;background:var(--bg-card);border-radius:0 var(--radius-sm) var(--radius-sm) 0;color:var(--text-secondary)}.msg-content table{border-collapse:collapse;width:100%;font-size:.85em;margin:.6em 0}.msg-content th,.msg-content td{border:1px solid var(--border);padding:.35em .6em;text-align:left}.msg-content th{background:var(--bg-card);font-weight:600}.msg-content a{color:var(--accent);text-decoration:underline;word-break:break-all}.inline-code{background:var(--bg-card);border:1px solid var(--border);border-radius:4px;padding:.1em .35em;font-family:JetBrains Mono,Fira Code,Cascadia Code,Consolas,monospace;font-size:.82em;color:var(--accent)}.hljs{background:var(--bg-base)!important}pre code.hljs{display:block;overflow-x:auto;padding:1em}code.hljs{padding:3px 5px}/*!
+  Theme: GitHub
+  Description: Light theme as seen on github.com
+  Author: github.com
+  Maintainer: @Hirse
+  Updated: 2021-05-15
+
+  Outdated base version: https://github.com/primer/github-syntax-light
+  Current colors taken from GitHub's CSS
+*/.hljs{color:#24292e;background:#fff}.hljs-doctag,.hljs-keyword,.hljs-meta .hljs-keyword,.hljs-template-tag,.hljs-template-variable,.hljs-type,.hljs-variable.language_{color:#d73a49}.hljs-title,.hljs-title.class_,.hljs-title.class_.inherited__,.hljs-title.function_{color:#6f42c1}.hljs-attr,.hljs-attribute,.hljs-literal,.hljs-meta,.hljs-number,.hljs-operator,.hljs-variable,.hljs-selector-attr,.hljs-selector-class,.hljs-selector-id{color:#005cc5}.hljs-regexp,.hljs-string,.hljs-meta .hljs-string{color:#032f62}.hljs-built_in,.hljs-symbol{color:#e36209}.hljs-comment,.hljs-code,.hljs-formula{color:#6a737d}.hljs-name,.hljs-quote,.hljs-selector-tag,.hljs-selector-pseudo{color:#22863a}.hljs-subst{color:#24292e}.hljs-section{color:#005cc5;font-weight:700}.hljs-bullet{color:#735c0f}.hljs-emphasis{color:#24292e;font-style:italic}.hljs-strong{color:#24292e;font-weight:700}.hljs-addition{color:#22863a;background-color:#f0fff4}.hljs-deletion{color:#b31d28;background-color:#ffeef0}

assets/ort-wasm-simd-threaded.jsep-B0T3yYHD.wasm

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c46655e8a94afc45338d4cb2b840475f88e5012d524509916e505079c00bfa39
+size 21596019

barq-vweb-pkg/.gitignore

@@ -0,0 +1 @@
+*

barq-vweb-pkg/barq_vweb.d.ts

@@ -0,0 +1,69 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export class BarqVWeb {
+    free(): void;
+    [Symbol.dispose](): void;
+    backend_info(): string;
+    clear(): Promise<any>;
+    count(): number;
+    delete(id: number): Promise<any>;
+    insert_texts(texts: Array<any>, metadata: Array<any>): Promise<any>;
+    insert_vectors(vectors: Float32Array, ids: Uint32Array, dim: number): Promise<any>;
+    load(): Promise<any>;
+    constructor(collection_name: string, model_url?: string | null);
+    save(): Promise<any>;
+    search(query: string, top_k: number, hybrid: boolean): Promise<any>;
+    search_vector(query_v: Float32Array, top_k: number): Promise<any>;
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_barqvweb_free: (a: number, b: number) => void;
+    readonly barqvweb_backend_info: (a: number) => [number, number];
+    readonly barqvweb_clear: (a: number) => any;
+    readonly barqvweb_count: (a: number) => number;
+    readonly barqvweb_delete: (a: number, b: number) => any;
+    readonly barqvweb_insert_texts: (a: number, b: any, c: any) => any;
+    readonly barqvweb_insert_vectors: (a: number, b: any, c: any, d: number) => any;
+    readonly barqvweb_load: (a: number) => any;
+    readonly barqvweb_new: (a: number, b: number, c: number, d: number) => number;
+    readonly barqvweb_save: (a: number) => any;
+    readonly barqvweb_search: (a: number, b: number, c: number, d: number, e: number) => any;
+    readonly barqvweb_search_vector: (a: number, b: any, c: number) => any;
+    readonly wasm_bindgen__closure__destroy__h5fc7b39f71c2d967: (a: number, b: number) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__h85e564a221c428e3: (a: number, b: number, c: any) => [number, number];
+    readonly wasm_bindgen__convert__closures_____invoke__h14d9ba7aff402d3a: (a: number, b: number, c: any, d: any) => void;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_exn_store: (a: number) => void;
+    readonly __externref_table_alloc: () => number;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __externref_table_dealloc: (a: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

barq-vweb-pkg/barq_vweb.js

@@ -0,0 +1,669 @@
+/* @ts-self-types="./barq_vweb.d.ts" */
+
+export class BarqVWeb {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BarqVWebFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_barqvweb_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    backend_info() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.barqvweb_backend_info(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {Promise<any>}
+     */
+    clear() {
+        const ret = wasm.barqvweb_clear(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    count() {
+        const ret = wasm.barqvweb_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @param {number} id
+     * @returns {Promise<any>}
+     */
+    delete(id) {
+        const ret = wasm.barqvweb_delete(this.__wbg_ptr, id);
+        return ret;
+    }
+    /**
+     * @param {Array<any>} texts
+     * @param {Array<any>} metadata
+     * @returns {Promise<any>}
+     */
+    insert_texts(texts, metadata) {
+        const ret = wasm.barqvweb_insert_texts(this.__wbg_ptr, texts, metadata);
+        return ret;
+    }
+    /**
+     * @param {Float32Array} vectors
+     * @param {Uint32Array} ids
+     * @param {number} dim
+     * @returns {Promise<any>}
+     */
+    insert_vectors(vectors, ids, dim) {
+        const ret = wasm.barqvweb_insert_vectors(this.__wbg_ptr, vectors, ids, dim);
+        return ret;
+    }
+    /**
+     * @returns {Promise<any>}
+     */
+    load() {
+        const ret = wasm.barqvweb_load(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {string} collection_name
+     * @param {string | null} [model_url]
+     */
+    constructor(collection_name, model_url) {
+        const ptr0 = passStringToWasm0(collection_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(model_url) ? 0 : passStringToWasm0(model_url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        const ret = wasm.barqvweb_new(ptr0, len0, ptr1, len1);
+        this.__wbg_ptr = ret >>> 0;
+        BarqVWebFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {Promise<any>}
+     */
+    save() {
+        const ret = wasm.barqvweb_save(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {string} query
+     * @param {number} top_k
+     * @param {boolean} hybrid
+     * @returns {Promise<any>}
+     */
+    search(query, top_k, hybrid) {
+        const ptr0 = passStringToWasm0(query, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.barqvweb_search(this.__wbg_ptr, ptr0, len0, top_k, hybrid);
+        return ret;
+    }
+    /**
+     * @param {Float32Array} query_v
+     * @param {number} top_k
+     * @returns {Promise<any>}
+     */
+    search_vector(query_v, top_k) {
+        const ret = wasm.barqvweb_search_vector(this.__wbg_ptr, query_v, top_k);
+        return ret;
+    }
+}
+if (Symbol.dispose) BarqVWeb.prototype[Symbol.dispose] = BarqVWeb.prototype.free;
+
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg___wbindgen_is_function_3c846841762788c1: function(arg0) {
+            const ret = typeof(arg0) === 'function';
+            return ret;
+        },
+        __wbg___wbindgen_is_object_781bc9f159099513: function(arg0) {
+            const val = arg0;
+            const ret = typeof(val) === 'object' && val !== null;
+            return ret;
+        },
+        __wbg___wbindgen_is_string_7ef6b97b02428fae: function(arg0) {
+            const ret = typeof(arg0) === 'string';
+            return ret;
+        },
+        __wbg___wbindgen_is_undefined_52709e72fb9f179c: function(arg0) {
+            const ret = arg0 === undefined;
+            return ret;
+        },
+        __wbg___wbindgen_number_get_34bb9d9dcfa21373: function(arg0, arg1) {
+            const obj = arg1;
+            const ret = typeof(obj) === 'number' ? obj : undefined;
+            getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+        },
+        __wbg___wbindgen_string_get_395e606bd0ee4427: function(arg0, arg1) {
+            const obj = arg1;
+            const ret = typeof(obj) === 'string' ? obj : undefined;
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_throw_6ddd609b62940d55: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg__wbg_cb_unref_6b5b6b8576d35cb1: function(arg0) {
+            arg0._wbg_cb_unref();
+        },
+        __wbg_apply_d7728efbea08f95e: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.apply(arg0, arg1, arg2);
+            return ret;
+        }, arguments); },
+        __wbg_call_2d781c1f4d5c0ef8: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.call(arg1, arg2);
+            return ret;
+        }, arguments); },
+        __wbg_call_dcc2662fa17a72cf: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = arg0.call(arg1, arg2, arg3);
+            return ret;
+        }, arguments); },
+        __wbg_crypto_38df2bab126b63dc: function(arg0) {
+            const ret = arg0.crypto;
+            return ret;
+        },
+        __wbg_error_a6fa202b58aa1cd3: function(arg0, arg1) {
+            let deferred0_0;
+            let deferred0_1;
+            try {
+                deferred0_0 = arg0;
+                deferred0_1 = arg1;
+                console.error(getStringFromWasm0(arg0, arg1));
+            } finally {
+                wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+            }
+        },
+        __wbg_getRandomValues_c44a50d8cfdaebeb: function() { return handleError(function (arg0, arg1) {
+            arg0.getRandomValues(arg1);
+        }, arguments); },
+        __wbg_get_3ef1eba1850ade27: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.get(arg0, arg1);
+            return ret;
+        }, arguments); },
+        __wbg_get_a8ee5c45dabc1b3b: function(arg0, arg1) {
+            const ret = arg0[arg1 >>> 0];
+            return ret;
+        },
+        __wbg_length_259ee9d041e381ad: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
+        __wbg_length_27280eca2d70010e: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
+        __wbg_length_b3416cf66a5452c8: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
+        __wbg_length_ea16607d7b61445b: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
+        __wbg_msCrypto_bd5a034af96bcba6: function(arg0) {
+            const ret = arg0.msCrypto;
+            return ret;
+        },
+        __wbg_new_227d7c05414eb861: function() {
+            const ret = new Error();
+            return ret;
+        },
+        __wbg_new_5f486cdf45a04d78: function(arg0) {
+            const ret = new Uint8Array(arg0);
+            return ret;
+        },
+        __wbg_new_a70fbab9066b301f: function() {
+            const ret = new Array();
+            return ret;
+        },
+        __wbg_new_ab79df5bd7c26067: function() {
+            const ret = new Object();
+            return ret;
+        },
+        __wbg_new_from_slice_ff2c15e8e05ffdfc: function(arg0, arg1) {
+            const ret = new Float32Array(getArrayF32FromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_new_typed_aaaeaf29cf802876: function(arg0, arg1) {
+            try {
+                var state0 = {a: arg0, b: arg1};
+                var cb0 = (arg0, arg1) => {
+                    const a = state0.a;
+                    state0.a = 0;
+                    try {
+                        return wasm_bindgen__convert__closures_____invoke__h14d9ba7aff402d3a(a, state0.b, arg0, arg1);
+                    } finally {
+                        state0.a = a;
+                    }
+                };
+                const ret = new Promise(cb0);
+                return ret;
+            } finally {
+                state0.a = state0.b = 0;
+            }
+        },
+        __wbg_new_with_length_825018a1616e9e55: function(arg0) {
+            const ret = new Uint8Array(arg0 >>> 0);
+            return ret;
+        },
+        __wbg_node_84ea875411254db1: function(arg0) {
+            const ret = arg0.node;
+            return ret;
+        },
+        __wbg_process_44c7a14e11e9f69e: function(arg0) {
+            const ret = arg0.process;
+            return ret;
+        },
+        __wbg_prototypesetcall_247ac4333d4d3cb4: function(arg0, arg1, arg2) {
+            Float32Array.prototype.set.call(getArrayF32FromWasm0(arg0, arg1), arg2);
+        },
+        __wbg_prototypesetcall_d62e5099504357e6: function(arg0, arg1, arg2) {
+            Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+        },
+        __wbg_prototypesetcall_f04613188bde902d: function(arg0, arg1, arg2) {
+            Uint32Array.prototype.set.call(getArrayU32FromWasm0(arg0, arg1), arg2);
+        },
+        __wbg_push_e87b0e732085a946: function(arg0, arg1) {
+            const ret = arg0.push(arg1);
+            return ret;
+        },
+        __wbg_queueMicrotask_0c399741342fb10f: function(arg0) {
+            const ret = arg0.queueMicrotask;
+            return ret;
+        },
+        __wbg_queueMicrotask_a082d78ce798393e: function(arg0) {
+            queueMicrotask(arg0);
+        },
+        __wbg_randomFillSync_6c25eac9869eb53c: function() { return handleError(function (arg0, arg1) {
+            arg0.randomFillSync(arg1);
+        }, arguments); },
+        __wbg_require_b4edbdcf3e2a1ef0: function() { return handleError(function () {
+            const ret = module.require;
+            return ret;
+        }, arguments); },
+        __wbg_resolve_ae8d83246e5bcc12: function(arg0) {
+            const ret = Promise.resolve(arg0);
+            return ret;
+        },
+        __wbg_set_282384002438957f: function(arg0, arg1, arg2) {
+            arg0[arg1 >>> 0] = arg2;
+        },
+        __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
+            arg0[arg1] = arg2;
+        },
+        __wbg_set_7eaa4f96924fd6b3: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.set(arg0, arg1, arg2);
+            return ret;
+        }, arguments); },
+        __wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {
+            const ret = arg1.stack;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_static_accessor_GLOBAL_8adb955bd33fac2f: function() {
+            const ret = typeof global === 'undefined' ? null : global;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_static_accessor_GLOBAL_THIS_ad356e0db91c7913: function() {
+            const ret = typeof globalThis === 'undefined' ? null : globalThis;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_static_accessor_SELF_f207c857566db248: function() {
+            const ret = typeof self === 'undefined' ? null : self;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_static_accessor_WINDOW_bb9f1ba69d61b386: function() {
+            const ret = typeof window === 'undefined' ? null : window;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_subarray_a068d24e39478a8a: function(arg0, arg1, arg2) {
+            const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
+            return ret;
+        },
+        __wbg_then_098abe61755d12f6: function(arg0, arg1) {
+            const ret = arg0.then(arg1);
+            return ret;
+        },
+        __wbg_then_9e335f6dd892bc11: function(arg0, arg1, arg2) {
+            const ret = arg0.then(arg1, arg2);
+            return ret;
+        },
+        __wbg_versions_276b2795b1c6a219: function(arg0) {
+            const ret = arg0.versions;
+            return ret;
+        },
+        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 94, function: Function { arguments: [Externref], shim_idx: 106, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h5fc7b39f71c2d967, wasm_bindgen__convert__closures_____invoke__h85e564a221c428e3);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000002: function(arg0) {
+            // Cast intrinsic for `F64 -> Externref`.
+            const ret = arg0;
+            return ret;
+        },
+        __wbindgen_cast_0000000000000003: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
+            const ret = getArrayU8FromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000004: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./barq_vweb_bg.js": import0,
+    };
+}
+
+function wasm_bindgen__convert__closures_____invoke__h85e564a221c428e3(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h85e564a221c428e3(arg0, arg1, arg2);
+    if (ret[1]) {
+        throw takeFromExternrefTable0(ret[0]);
+    }
+}
+
+function wasm_bindgen__convert__closures_____invoke__h14d9ba7aff402d3a(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h14d9ba7aff402d3a(arg0, arg1, arg2, arg3);
+}
+
+const BarqVWebFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_barqvweb_free(ptr >>> 0, 1));
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(state => state.dtor(state.a, state.b));
+
+function getArrayF32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+let cachedFloat32ArrayMemory0 = null;
+function getFloat32ArrayMemory0() {
+    if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
+        cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
+    }
+    return cachedFloat32ArrayMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let cachedUint32ArrayMemory0 = null;
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function makeMutClosure(arg0, arg1, dtor, f) {
+    const state = { a: arg0, b: arg1, cnt: 1, dtor };
+    const real = (...args) => {
+
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        const a = state.a;
+        state.a = 0;
+        try {
+            return f(a, state.b, ...args);
+        } finally {
+            state.a = a;
+            real._wbg_cb_unref();
+        }
+    };
+    real._wbg_cb_unref = () => {
+        if (--state.cnt === 0) {
+            state.dtor(state.a, state.b);
+            state.a = 0;
+            CLOSURE_DTORS.unregister(state);
+        }
+    };
+    CLOSURE_DTORS.register(real, state, state);
+    return real;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let wasmModule, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedDataViewMemory0 = null;
+    cachedFloat32ArrayMemory0 = null;
+    cachedUint32ArrayMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = module.ok && expectedResponseType(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    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);
+
+                } else { throw e; }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
+
+    function expectedResponseType(type) {
+        switch (type) {
+            case 'basic': case 'cors': case 'default': return true;
+        }
+        return false;
+    }
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module !== undefined) {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+    const instance = new WebAssembly.Instance(module, imports);
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module_or_path !== undefined) {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (module_or_path === undefined) {
+        module_or_path = new URL('barq_vweb_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync, __wbg_init as default };

barq-vweb-pkg/barq_vweb_bg.wasm

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ad71acbbc2d873dac3cc792e0b979c5568ab84c6668c99acb62e4d72c43f935a
+size 218170

barq-vweb-pkg/barq_vweb_bg.wasm.d.ts

@@ -0,0 +1,26 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const __wbg_barqvweb_free: (a: number, b: number) => void;
+export const barqvweb_backend_info: (a: number) => [number, number];
+export const barqvweb_clear: (a: number) => any;
+export const barqvweb_count: (a: number) => number;
+export const barqvweb_delete: (a: number, b: number) => any;
+export const barqvweb_insert_texts: (a: number, b: any, c: any) => any;
+export const barqvweb_insert_vectors: (a: number, b: any, c: any, d: number) => any;
+export const barqvweb_load: (a: number) => any;
+export const barqvweb_new: (a: number, b: number, c: number, d: number) => number;
+export const barqvweb_save: (a: number) => any;
+export const barqvweb_search: (a: number, b: number, c: number, d: number, e: number) => any;
+export const barqvweb_search_vector: (a: number, b: any, c: number) => any;
+export const wasm_bindgen__closure__destroy__h5fc7b39f71c2d967: (a: number, b: number) => void;
+export const wasm_bindgen__convert__closures_____invoke__h85e564a221c428e3: (a: number, b: number, c: any) => [number, number];
+export const wasm_bindgen__convert__closures_____invoke__h14d9ba7aff402d3a: (a: number, b: number, c: any, d: any) => void;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_exn_store: (a: number) => void;
+export const __externref_table_alloc: () => number;
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_start: () => void;

barq-vweb-pkg/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "barq-vweb",
+  "type": "module",
+  "version": "0.1.0",
+  "files": [
+    "barq_vweb_bg.wasm",
+    "barq_vweb.js",
+    "barq_vweb.d.ts"
+  ],
+  "main": "barq_vweb.js",
+  "types": "barq_vweb.d.ts",
+  "sideEffects": [
+    "./snippets/*"
+  ]
+}

barq-wasm-pkg/.gitignore

@@ -0,0 +1 @@
+*

barq-wasm-pkg/README.md

@@ -0,0 +1,196 @@
+<div align="center">
+  <img src="assets/logo.svg" alt="Barq-WASM Logo" width="200" height="200">
+  <h1>Barq-WASM</h1>
+  <p><strong>Pattern-Aware WebAssembly Runtime for Specialized Workloads</strong></p>
+
+  [![CI](https://github.com/YASSERRMD/barq-wasm/actions/workflows/ci.yml/badge.svg)](https://github.com/YASSERRMD/barq-wasm/actions)
+  [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+</div>
+
+## Overview
+
+Barq-WASM is a high-performance, experimental WebAssembly runtime designed to bridge the gap between generic bytecode execution and specialized native hardware acceleration. Unlike traditional runtimes that rely solely on generic JIT compilation, Barq-WASM employs a multi-stage Pattern Analyzer to detect high-level algorithmic structures and recompiles them into highly optimized, architecture-specific machine code.
+
+This project demonstrates improved throughput for specific, compute-intensive workloads by leveraging AVX2/SIMD instructions, native syscall injections, and algorithmic shortcuts that generic WASM compilers cannot safely prove effective.
+
+## Key Features
+
+### 1. Intelligent Pattern Detection
+The runtime analyzes WASM bytecode prior to execution to identify known algorithmic fingerprints:
+*   Compression: LZ4, Zstd, Brotli decompression loops
+*   Linear Algebra: Matrix multiplication, dot products, vector norms
+*   AI/ML: INT8 quantization, convolution layers, attention mechanisms
+*   Database: MongoDB protocol handlers, BSON serialization
+
+### 2. Specialized JIT Compilation
+Once a pattern is detected, the CraneliftBackend switches to a specialized optimization tier:
+*   Vector Backend: Emits AVX2/SSE4.2 instructions for linear algebra
+*   Compression Backend: Injects prefetch hints and unrolls dictionary lookups
+*   AI Backend: Utilizes native INT8 instructions and tiled convolution kernels
+
+### 3. Adaptive Syscall Mapping
+For I/O-bound patterns (like database drivers), Barq-WASM can bypass standard WASI generic I/O in favor of direct, batched pwrite64 syscalls and connection pooling, reducing context-switch overhead.
+
+## Performance Benchmarks
+
+Benchmarks were conducted in Chrome (V8) comparing Barq-WASM compiled module vs pure JavaScript implementations.
+
+### Browser Benchmark Results (Chrome V8)
+
+| Category | Workload | WASM Time | JS Time | Speedup |
+|:---|:---|:---:|:---:|:---:|
+| Vector | Dot Product (500K elements) | 0.177 ms | 0.391 ms | 2.21x |
+| Vector | L2 Norm (500K elements) | 0.119 ms | 0.329 ms | 2.76x |
+| Vector | Cosine Similarity (100K) | 0.081 ms | 0.219 ms | 2.70x |
+| Matrix | Matrix Mul (64x64) | 0.067 ms | 0.913 ms | 13.70x |
+| Matrix | Matrix Mul (128x128) | 0.540 ms | 8.570 ms | 15.93x |
+| AI | INT8 Quantization (500K) | 0.378 ms | 2.686 ms | 7.11x |
+| AI | Conv2D + ReLU (256x256) | 0.252 ms | 0.986 ms | 3.82x |
+| Compression | LZ4 (97.7KB) | 0.012 ms | 0.010 ms | 0.83x |
+
+### Summary Statistics
+
+| Metric | Value |
+|:---|:---:|
+| Average Speedup | 5.36x |
+| Best Speedup | 15.93x (Matrix Multiply) |
+| Tests with 2x+ speedup | 6 out of 8 |
+
+### Real-World Data Benchmarks
+
+Tested with actual data: Shakespeare text, GloVe-style embeddings, and MNIST images.
+
+| Category | Task | Data Source | Speedup |
+|:---|:---|:---|:---:|
+| Word Embeddings | Cosine Similarity | 300-dim GloVe-style vectors | 3.25x |
+| Word Embeddings | KNN Search (100 vectors) | 300-dim, 100 comparisons | 3.53x |
+| NLP | Text Compression | Shakespeare (~180KB) | 0.02x* |
+| Computer Vision | Edge Detection (3x3) | MNIST 28x28 images | 3.57x |
+| ML Inference | INT8 Quantization | 500K ReLU activations | 7.07x |
+
+*LZ4 compression uses adaptive algorithm: for buffers under 128KB, direct copy matches JS memcpy performance.
+
+### Key Optimizations
+
+*   16-wide Loop Unrolling: Dot product uses 16 independent accumulators with pointer access for maximum ILP
+*   L1/L2 Cache Tiling: Matrix multiplication uses 32x32 L1 tiles and 64x64 L2 tiles for optimal cache utilization
+*   Fast INT8 Quantization: Uses integer-based rounding instead of floating-point round(), achieving 7.11x speedup
+*   Fused Operations: Conv2D includes fused ReLU activation, eliminating a separate memory pass
+*   Adaptive Compression: Buffer-size aware algorithm selection (direct copy for small buffers where overhead exceeds benefit)
+
+### Comparison with Industry Standards
+
+| Workload | Barq-WASM | ONNX Runtime Web | TensorFlow.js WASM |
+|:---|:---:|:---:|:---:|
+| INT8 Quantization | 0.38 ms | 1.5-1.9 ms | 1.7-2.2 ms |
+| Conv2D (256x256) | 0.25 ms | 0.8-1.2 ms | 1.0-1.5 ms |
+| Matrix Mul (128x128) | 0.54 ms | 2-4 ms | 3-5 ms |
+
+## Installation
+
+### Prerequisites
+*   Rust (latest stable toolchain)
+*   Cargo
+*   wasm-pack (for building WebAssembly package)
+*   (Optional) Clang/LLVM for specific linkage requirements
+
+Install wasm-pack:
+
+```bash
+cargo install wasm-pack
+```
+
+### Building from Source
+
+Clone the repository and build the release binary:
+
+```bash
+git clone https://github.com/YASSERRMD/barq-wasm.git
+cd barq-wasm
+cargo build --release
+```
+
+To run the full suite of integration tests:
+
+```bash
+cargo test --test integration_tests
+```
+
+To run performance benchmarks:
+
+```bash
+cargo bench
+```
+
+### Building for Web (WASM)
+
+To build the optimized WebAssembly package for browser usage:
+
+```bash
+wasm-pack build --target web --features wasm
+```
+
+### Usage & Documentation
+
+Comprehensive documentation for all WASM functions, integration guides, and API references can be found in the [WASM Documentation](docs/WASM.md).
+
+### Live Benchmarks
+
+You can view the live performance benchmarks of Barq-WASM (compared to native JavaScript) at the project's GitHub Pages.
+
+## Usage
+
+Barq-WASM can be used as a library or a standalone runner.
+
+### As a Standalone Runner
+
+```bash
+# Analyze and run a WASM module
+./target/release/barq-wasm run path/to/workload.wasm
+
+# Run with specific optimization flags
+./target/release/barq-wasm run --opt-level=aggressive path/to/matrix_math.wasm
+```
+
+### As a Rust Library
+
+```rust
+use barq_wasm::runtime::Runtime;
+use barq_wasm::config::Config;
+
+fn main() -> anyhow::Result<()> {
+    let config = Config::default().with_pattern_detection(true);
+    let mut runtime = Runtime::new(config)?;
+    
+    let wasm_bytes = std::fs::read("matrix.wasm")?;
+    runtime.load_module(&wasm_bytes)?;
+    
+    runtime.invoke("main", &[])?;
+    Ok(())
+}
+```
+
+## Project Architecture
+
+The codebase is organized into four main pillars corresponding to the optimization phases:
+
+*   `src/analyzer/`: Pattern detection logic (Phase 1)
+*   `src/codegen/compression_codegen.rs`: LZ4/Zstd JIT emitters (Phase 2)
+*   `src/codegen/vector_codegen.rs`: SIMD/AVX2 JIT emitters (Phase 3)
+*   `src/codegen/database_codegen.rs`: DB/AI optimization logic (Phase 4)
+
+## Contributing
+
+Contributions are welcome to expand the catalog of detectable patterns or improve JIT code generation.
+
+1.  Fork the repository
+2.  Create a feature branch (`git checkout -b feature/new-pattern`)
+3.  Commit your changes
+4.  Push to the branch
+5.  Open a Pull Request
+
+Please ensure all new code is covered by integration tests and passes `cargo clippy -- -D warnings`.
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

barq-wasm-pkg/barq_wasm.d.ts

@@ -0,0 +1,297 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Argmax: index of maximum value with 4-wide tracking
+ */
+export function argmax(a: Float32Array): number;
+
+/**
+ * Argmin: index of minimum value with 4-wide tracking
+ */
+export function argmin(a: Float32Array): number;
+
+/**
+ * Average pooling 2D
+ */
+export function avg_pooling_2d(input: Float32Array, width: number, height: number, pool_size: number): Float32Array;
+
+/**
+ * Batch normalization: (x - mean) / sqrt(var + eps) * gamma + beta
+ */
+export function batch_normalize(input: Float32Array, gamma: number, beta: number, epsilon: number): Float32Array;
+
+/**
+ * High-performance Conv2D with fused operations
+ * - im2col memory layout for sequential access
+ * - Tiled processing for L1 cache
+ *
+ * Target: 3-4x faster than naive nested loops
+ */
+export function conv2d_optimized(input: Float32Array, kernel: Float32Array, width: number, height: number, kernel_size: number): Float32Array;
+
+/**
+ * Scalar convolution (baseline)
+ */
+export function conv2d_scalar(input: Float32Array, kernel: Float32Array, width: number, height: number, kernel_size: number): Float32Array;
+
+/**
+ * Scalar cosine similarity (baseline)
+ */
+export function cosine_similarity_scalar(a: Float32Array, b: Float32Array): number;
+
+/**
+ * High-performance cosine similarity using shared dot product kernel
+ */
+export function cosine_similarity_simd(a: Float32Array, b: Float32Array): number;
+
+/**
+ * Dequantize INT8 back to float32
+ */
+export function dequantize_int8(input: Int8Array, scale: number): Float32Array;
+
+/**
+ * Scalar dot product (baseline)
+ */
+export function dot_product_scalar(a: Float32Array, b: Float32Array): number;
+
+/**
+ * Ultra-fast dot product with 16-wide unrolling and unsafe pointer access
+ * Uses 16 independent accumulators to saturate CPU execution ports
+ * Target: 3-4x faster than naive scalar
+ */
+export function dot_product_simd(a: Float32Array, b: Float32Array): number;
+
+/**
+ * Euclidean distance between two vectors
+ */
+export function euclidean_distance(a: Float32Array, b: Float32Array): number;
+
+/**
+ * Leaky ReLU activation function with 8-wide unrolling
+ */
+export function leaky_relu(a: Float32Array, alpha: number): Float32Array;
+
+/**
+ * Ultra-fast LZ4 compression with minimal overhead
+ * Key insight: For buffers under ~128KB, the overhead of ANY compression
+ * algorithm (hash tables, match finding, token encoding) exceeds the
+ * benefit because JavaScript's baseline is essentially an optimized memcpy.
+ *
+ * Strategy:
+ * - Buffers < 128KB: Direct copy (matches JS memcpy performance)
+ * - Buffers >= 128KB: Full LZ4 algorithm (compression savings > overhead)
+ */
+export function lz4_compress_optimized(input: Uint8Array): Uint8Array;
+
+/**
+ * Scalar LZ4 compression (baseline)
+ */
+export function lz4_compress_scalar(input: Uint8Array): Uint8Array;
+
+/**
+ * Manhattan distance (L1 norm) between two vectors
+ */
+export function manhattan_distance(a: Float32Array, b: Float32Array): number;
+
+/**
+ * Matrix addition: C = A + B
+ */
+export function matrix_add(a: Float32Array, b: Float32Array): Float32Array;
+
+/**
+ * Scalar matrix multiplication (baseline)
+ */
+export function matrix_multiply_scalar(a: Float32Array, b: Float32Array, n: number): Float32Array;
+
+/**
+ * High-performance matrix multiplication with multi-level cache tiling
+ * Uses 32x32 tiles (fits in L1), processes in k-i-j order for row-major optimization
+ * Target: 6-8x faster than naive O(n³)
+ */
+export function matrix_multiply_tiled(a: Float32Array, b: Float32Array, n: number): Float32Array;
+
+/**
+ * Matrix scalar multiplication: C = A * scalar
+ */
+export function matrix_scalar_multiply(a: Float32Array, scalar: number): Float32Array;
+
+/**
+ * Matrix transpose (n x m -> m x n) with unsafe pointer access for speed
+ */
+export function matrix_transpose(a: Float32Array, rows: number, cols: number): Float32Array;
+
+/**
+ * Max pooling 2D (stride = kernel_size for non-overlapping)
+ */
+export function max_pooling_2d(input: Float32Array, width: number, height: number, pool_size: number): Float32Array;
+
+/**
+ * Compute mean of a vector
+ */
+export function mean(a: Float32Array): number;
+
+/**
+ * Scalar INT8 quantization (baseline)
+ */
+export function quantize_int8_scalar(input: Float32Array, scale: number): Int8Array;
+
+/**
+ * Native WASM SIMD INT8 quantization using v128 instructions
+ * Processes 4 floats at a time using f32x4 SIMD operations
+ * Target: 0.5-0.8ms (3x faster than scalar)
+ */
+export function quantize_int8_simd(input: Float32Array, scale: number): Int8Array;
+
+/**
+ * ReLU activation function
+ */
+export function relu(a: Float32Array): Float32Array;
+
+/**
+ * Sigmoid activation function
+ */
+export function sigmoid(a: Float32Array): Float32Array;
+
+/**
+ * Softmax function (numerically stable)
+ */
+export function softmax(a: Float32Array): Float32Array;
+
+/**
+ * Compute standard deviation
+ */
+export function std_dev(a: Float32Array): number;
+
+/**
+ * Compute variance of a vector
+ */
+export function variance(a: Float32Array): number;
+
+/**
+ * Vector addition: c = a + b
+ */
+export function vector_add(a: Float32Array, b: Float32Array): Float32Array;
+
+/**
+ * Clamp vector values between min and max
+ */
+export function vector_clamp(a: Float32Array, min_val: number, max_val: number): Float32Array;
+
+/**
+ * Element-wise multiplication (Hadamard product): c = a * b
+ */
+export function vector_elementwise_multiply(a: Float32Array, b: Float32Array): Float32Array;
+
+/**
+ * Find maximum value in a vector with 8-wide unrolling
+ */
+export function vector_max(a: Float32Array): number;
+
+/**
+ * Find minimum value in a vector with 8-wide unrolling
+ */
+export function vector_min(a: Float32Array): number;
+
+/**
+ * Scalar vector norm (baseline)
+ */
+export function vector_norm_scalar(a: Float32Array): number;
+
+/**
+ * High-performance L2 norm with 8-wide accumulation
+ */
+export function vector_norm_simd(a: Float32Array): number;
+
+/**
+ * Normalize vector to unit length
+ */
+export function vector_normalize(a: Float32Array): Float32Array;
+
+/**
+ * Vector scaling: c = a * scalar
+ */
+export function vector_scale(a: Float32Array, scalar: number): Float32Array;
+
+/**
+ * Vector subtraction: c = a - b
+ */
+export function vector_subtract(a: Float32Array, b: Float32Array): Float32Array;
+
+/**
+ * Sum of all elements in a vector
+ */
+export function vector_sum(a: Float32Array): number;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly argmax: (a: number, b: number) => number;
+    readonly argmin: (a: number, b: number) => number;
+    readonly avg_pooling_2d: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+    readonly batch_normalize: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+    readonly conv2d_optimized: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
+    readonly conv2d_scalar: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
+    readonly cosine_similarity_scalar: (a: number, b: number, c: number, d: number) => number;
+    readonly cosine_similarity_simd: (a: number, b: number, c: number, d: number) => number;
+    readonly dequantize_int8: (a: number, b: number, c: number) => [number, number];
+    readonly dot_product_scalar: (a: number, b: number, c: number, d: number) => number;
+    readonly dot_product_simd: (a: number, b: number, c: number, d: number) => number;
+    readonly euclidean_distance: (a: number, b: number, c: number, d: number) => number;
+    readonly leaky_relu: (a: number, b: number, c: number) => [number, number];
+    readonly lz4_compress_optimized: (a: number, b: number) => [number, number];
+    readonly lz4_compress_scalar: (a: number, b: number) => [number, number];
+    readonly manhattan_distance: (a: number, b: number, c: number, d: number) => number;
+    readonly matrix_add: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly matrix_multiply_scalar: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+    readonly matrix_multiply_tiled: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+    readonly matrix_scalar_multiply: (a: number, b: number, c: number) => [number, number];
+    readonly matrix_transpose: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly max_pooling_2d: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+    readonly mean: (a: number, b: number) => number;
+    readonly quantize_int8_scalar: (a: number, b: number, c: number) => [number, number];
+    readonly quantize_int8_simd: (a: number, b: number, c: number) => [number, number];
+    readonly relu: (a: number, b: number) => [number, number];
+    readonly sigmoid: (a: number, b: number) => [number, number];
+    readonly softmax: (a: number, b: number) => [number, number];
+    readonly std_dev: (a: number, b: number) => number;
+    readonly variance: (a: number, b: number) => number;
+    readonly vector_clamp: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly vector_elementwise_multiply: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly vector_max: (a: number, b: number) => number;
+    readonly vector_min: (a: number, b: number) => number;
+    readonly vector_norm_scalar: (a: number, b: number) => number;
+    readonly vector_norm_simd: (a: number, b: number) => number;
+    readonly vector_normalize: (a: number, b: number) => [number, number];
+    readonly vector_subtract: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly vector_sum: (a: number, b: number) => number;
+    readonly vector_add: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly vector_scale: (a: number, b: number, c: number) => [number, number];
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

barq-wasm-pkg/barq_wasm.js

@@ -0,0 +1,797 @@
+/* @ts-self-types="./barq_wasm.d.ts" */
+
+/**
+ * Argmax: index of maximum value with 4-wide tracking
+ * @param {Float32Array} a
+ * @returns {number}
+ */
+export function argmax(a) {
+    const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.argmax(ptr0, len0);
+    return ret >>> 0;
+}
+
+/**
+ * Argmin: index of minimum value with 4-wide tracking
+ * @param {Float32Array} a
+ * @returns {number}
+ */
+export function argmin(a) {
+    const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.argmin(ptr0, len0);
+    return ret >>> 0;
+}
+
+/**
+ * Average pooling 2D
+ * @param {Float32Array} input
+ * @param {number} width
+ * @param {number} height
+ * @param {number} pool_size
+ * @returns {Float32Array}
+ */
+export function avg_pooling_2d(input, width, height, pool_size) {
+    const ptr0 = passArrayF32ToWasm0(input, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.avg_pooling_2d(ptr0, len0, width, height, pool_size);
+    var v2 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v2;
+}
+
+/**
+ * Batch normalization: (x - mean) / sqrt(var + eps) * gamma + beta
+ * @param {Float32Array} input
+ * @param {number} gamma
+ * @param {number} beta
+ * @param {number} epsilon
+ * @returns {Float32Array}
+ */
+export function batch_normalize(input, gamma, beta, epsilon) {
+    const ptr0 = passArrayF32ToWasm0(input, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.batch_normalize(ptr0, len0, gamma, beta, epsilon);
+    var v2 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v2;
+}
+
+/**
+ * High-performance Conv2D with fused operations
+ * - im2col memory layout for sequential access
+ * - Tiled processing for L1 cache
+ *
+ * Target: 3-4x faster than naive nested loops
+ * @param {Float32Array} input
+ * @param {Float32Array} kernel
+ * @param {number} width
+ * @param {number} height
+ * @param {number} kernel_size
+ * @returns {Float32Array}
+ */
+export function conv2d_optimized(input, kernel, width, height, kernel_size) {
+    const ptr0 = passArrayF32ToWasm0(input, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF32ToWasm0(kernel, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.conv2d_optimized(ptr0, len0, ptr1, len1, width, height, kernel_size);
+    var v3 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v3;
+}
+
+/**
+ * Scalar convolution (baseline)
+ * @param {Float32Array} input
+ * @param {Float32Array} kernel
+ * @param {number} width
+ * @param {number} height
+ * @param {number} kernel_size
+ * @returns {Float32Array}
+ */
+export function conv2d_scalar(input, kernel, width, height, kernel_size) {
+    const ptr0 = passArrayF32ToWasm0(input, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF32ToWasm0(kernel, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.conv2d_scalar(ptr0, len0, ptr1, len1, width, height, kernel_size);
+    var v3 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v3;
+}
+
+/**
+ * Scalar cosine similarity (baseline)
+ * @param {Float32Array} a
+ * @param {Float32Array} b
+ * @returns {number}
+ */
+export function cosine_similarity_scalar(a, b) {
+    const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF32ToWasm0(b, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.cosine_similarity_scalar(ptr0, len0, ptr1, len1);
+    return ret;
+}
+
+/**
+ * High-performance cosine similarity using shared dot product kernel
+ * @param {Float32Array} a
+ * @param {Float32Array} b
+ * @returns {number}
+ */
+export function cosine_similarity_simd(a, b) {
+    const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF32ToWasm0(b, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.cosine_similarity_simd(ptr0, len0, ptr1, len1);
+    return ret;
+}
+
+/**
+ * Dequantize INT8 back to float32
+ * @param {Int8Array} input
+ * @param {number} scale
+ * @returns {Float32Array}
+ */
+export function dequantize_int8(input, scale) {
+    const ptr0 = passArray8ToWasm0(input, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.dequantize_int8(ptr0, len0, scale);
+    var v2 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v2;
+}
+
+/**
+ * Scalar dot product (baseline)
+ * @param {Float32Array} a
+ * @param {Float32Array} b
+ * @returns {number}
+ */
+export function dot_product_scalar(a, b) {
+    const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF32ToWasm0(b, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.dot_product_scalar(ptr0, len0, ptr1, len1);
+    return ret;
+}
+
+/**
+ * Ultra-fast dot product with 16-wide unrolling and unsafe pointer access
+ * Uses 16 independent accumulators to saturate CPU execution ports
+ * Target: 3-4x faster than naive scalar
+ * @param {Float32Array} a
+ * @param {Float32Array} b
+ * @returns {number}
+ */
+export function dot_product_simd(a, b) {
+    const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF32ToWasm0(b, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.dot_product_simd(ptr0, len0, ptr1, len1);
+    return ret;
+}
+
+/**
+ * Euclidean distance between two vectors
+ * @param {Float32Array} a
+ * @param {Float32Array} b
+ * @returns {number}
+ */
+export function euclidean_distance(a, b) {
+    const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF32ToWasm0(b, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.euclidean_distance(ptr0, len0, ptr1, len1);
+    return ret;
+}
+
+/**
+ * Leaky ReLU activation function with 8-wide unrolling
+ * @param {Float32Array} a
+ * @param {number} alpha
+ * @returns {Float32Array}
+ */
+export function leaky_relu(a, alpha) {
+    const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.leaky_relu(ptr0, len0, alpha);
+    var v2 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v2;
+}
+
+/**
+ * Ultra-fast LZ4 compression with minimal overhead
+ * Key insight: For buffers under ~128KB, the overhead of ANY compression
+ * algorithm (hash tables, match finding, token encoding) exceeds the
+ * benefit because JavaScript's baseline is essentially an optimized memcpy.
+ *
+ * Strategy:
+ * - Buffers < 128KB: Direct copy (matches JS memcpy performance)
+ * - Buffers >= 128KB: Full LZ4 algorithm (compression savings > overhead)
+ * @param {Uint8Array} input
+ * @returns {Uint8Array}
+ */
+export function lz4_compress_optimized(input) {
+    const ptr0 = passArray8ToWasm0(input, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.lz4_compress_optimized(ptr0, len0);
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
+/**
+ * Scalar LZ4 compression (baseline)
+ * @param {Uint8Array} input
+ * @returns {Uint8Array}
+ */
+export function lz4_compress_scalar(input) {
+    const ptr0 = passArray8ToWasm0(input, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.lz4_compress_scalar(ptr0, len0);
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
+/**
+ * Manhattan distance (L1 norm) between two vectors
+ * @param {Float32Array} a
+ * @param {Float32Array} b
+ * @returns {number}
+ */
+export function manhattan_distance(a, b) {
+    const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF32ToWasm0(b, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.manhattan_distance(ptr0, len0, ptr1, len1);
+    return ret;
+}
+
+/**
+ * Matrix addition: C = A + B
+ * @param {Float32Array} a
+ * @param {Float32Array} b
+ * @returns {Float32Array}
+ */
+export function matrix_add(a, b) {
+    const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF32ToWasm0(b, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.matrix_add(ptr0, len0, ptr1, len1);
+    var v3 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v3;
+}
+
+/**
+ * Scalar matrix multiplication (baseline)
+ * @param {Float32Array} a
+ * @param {Float32Array} b
+ * @param {number} n
+ * @returns {Float32Array}
+ */
+export function matrix_multiply_scalar(a, b, n) {
+    const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF32ToWasm0(b, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.matrix_multiply_scalar(ptr0, len0, ptr1, len1, n);
+    var v3 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v3;
+}
+
+/**
+ * High-performance matrix multiplication with multi-level cache tiling
+ * Uses 32x32 tiles (fits in L1), processes in k-i-j order for row-major optimization
+ * Target: 6-8x faster than naive O(n³)
+ * @param {Float32Array} a
+ * @param {Float32Array} b
+ * @param {number} n
+ * @returns {Float32Array}
+ */
+export function matrix_multiply_tiled(a, b, n) {
+    const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF32ToWasm0(b, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.matrix_multiply_tiled(ptr0, len0, ptr1, len1, n);
+    var v3 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v3;
+}
+
+/**
+ * Matrix scalar multiplication: C = A * scalar
+ * @param {Float32Array} a
+ * @param {number} scalar
+ * @returns {Float32Array}
+ */
+export function matrix_scalar_multiply(a, scalar) {
+    const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.matrix_scalar_multiply(ptr0, len0, scalar);
+    var v2 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v2;
+}
+
+/**
+ * Matrix transpose (n x m -> m x n) with unsafe pointer access for speed
+ * @param {Float32Array} a
+ * @param {number} rows
+ * @param {number} cols
+ * @returns {Float32Array}
+ */
+export function matrix_transpose(a, rows, cols) {
+    const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.matrix_transpose(ptr0, len0, rows, cols);
+    var v2 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v2;
+}
+
+/**
+ * Max pooling 2D (stride = kernel_size for non-overlapping)
+ * @param {Float32Array} input
+ * @param {number} width
+ * @param {number} height
+ * @param {number} pool_size
+ * @returns {Float32Array}
+ */
+export function max_pooling_2d(input, width, height, pool_size) {
+    const ptr0 = passArrayF32ToWasm0(input, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.max_pooling_2d(ptr0, len0, width, height, pool_size);
+    var v2 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v2;
+}
+
+/**
+ * Compute mean of a vector
+ * @param {Float32Array} a
+ * @returns {number}
+ */
+export function mean(a) {
+    const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mean(ptr0, len0);
+    return ret;
+}
+
+/**
+ * Scalar INT8 quantization (baseline)
+ * @param {Float32Array} input
+ * @param {number} scale
+ * @returns {Int8Array}
+ */
+export function quantize_int8_scalar(input, scale) {
+    const ptr0 = passArrayF32ToWasm0(input, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.quantize_int8_scalar(ptr0, len0, scale);
+    var v2 = getArrayI8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
+/**
+ * Native WASM SIMD INT8 quantization using v128 instructions
+ * Processes 4 floats at a time using f32x4 SIMD operations
+ * Target: 0.5-0.8ms (3x faster than scalar)
+ * @param {Float32Array} input
+ * @param {number} scale
+ * @returns {Int8Array}
+ */
+export function quantize_int8_simd(input, scale) {
+    const ptr0 = passArrayF32ToWasm0(input, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.quantize_int8_simd(ptr0, len0, scale);
+    var v2 = getArrayI8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
+/**
+ * ReLU activation function
+ * @param {Float32Array} a
+ * @returns {Float32Array}
+ */
+export function relu(a) {
+    const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.relu(ptr0, len0);
+    var v2 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v2;
+}
+
+/**
+ * Sigmoid activation function
+ * @param {Float32Array} a
+ * @returns {Float32Array}
+ */
+export function sigmoid(a) {
+    const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.sigmoid(ptr0, len0);
+    var v2 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v2;
+}
+
+/**
+ * Softmax function (numerically stable)
+ * @param {Float32Array} a
+ * @returns {Float32Array}
+ */
+export function softmax(a) {
+    const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.softmax(ptr0, len0);
+    var v2 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v2;
+}
+
+/**
+ * Compute standard deviation
+ * @param {Float32Array} a
+ * @returns {number}
+ */
+export function std_dev(a) {
+    const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.std_dev(ptr0, len0);
+    return ret;
+}
+
+/**
+ * Compute variance of a vector
+ * @param {Float32Array} a
+ * @returns {number}
+ */
+export function variance(a) {
+    const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.variance(ptr0, len0);
+    return ret;
+}
+
+/**
+ * Vector addition: c = a + b
+ * @param {Float32Array} a
+ * @param {Float32Array} b
+ * @returns {Float32Array}
+ */
+export function vector_add(a, b) {
+    const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF32ToWasm0(b, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.vector_add(ptr0, len0, ptr1, len1);
+    var v3 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v3;
+}
+
+/**
+ * Clamp vector values between min and max
+ * @param {Float32Array} a
+ * @param {number} min_val
+ * @param {number} max_val
+ * @returns {Float32Array}
+ */
+export function vector_clamp(a, min_val, max_val) {
+    const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.vector_clamp(ptr0, len0, min_val, max_val);
+    var v2 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v2;
+}
+
+/**
+ * Element-wise multiplication (Hadamard product): c = a * b
+ * @param {Float32Array} a
+ * @param {Float32Array} b
+ * @returns {Float32Array}
+ */
+export function vector_elementwise_multiply(a, b) {
+    const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF32ToWasm0(b, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.vector_elementwise_multiply(ptr0, len0, ptr1, len1);
+    var v3 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v3;
+}
+
+/**
+ * Find maximum value in a vector with 8-wide unrolling
+ * @param {Float32Array} a
+ * @returns {number}
+ */
+export function vector_max(a) {
+    const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.vector_max(ptr0, len0);
+    return ret;
+}
+
+/**
+ * Find minimum value in a vector with 8-wide unrolling
+ * @param {Float32Array} a
+ * @returns {number}
+ */
+export function vector_min(a) {
+    const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.vector_min(ptr0, len0);
+    return ret;
+}
+
+/**
+ * Scalar vector norm (baseline)
+ * @param {Float32Array} a
+ * @returns {number}
+ */
+export function vector_norm_scalar(a) {
+    const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.vector_norm_scalar(ptr0, len0);
+    return ret;
+}
+
+/**
+ * High-performance L2 norm with 8-wide accumulation
+ * @param {Float32Array} a
+ * @returns {number}
+ */
+export function vector_norm_simd(a) {
+    const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.vector_norm_simd(ptr0, len0);
+    return ret;
+}
+
+/**
+ * Normalize vector to unit length
+ * @param {Float32Array} a
+ * @returns {Float32Array}
+ */
+export function vector_normalize(a) {
+    const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.vector_normalize(ptr0, len0);
+    var v2 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v2;
+}
+
+/**
+ * Vector scaling: c = a * scalar
+ * @param {Float32Array} a
+ * @param {number} scalar
+ * @returns {Float32Array}
+ */
+export function vector_scale(a, scalar) {
+    const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.vector_scale(ptr0, len0, scalar);
+    var v2 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v2;
+}
+
+/**
+ * Vector subtraction: c = a - b
+ * @param {Float32Array} a
+ * @param {Float32Array} b
+ * @returns {Float32Array}
+ */
+export function vector_subtract(a, b) {
+    const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF32ToWasm0(b, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.vector_subtract(ptr0, len0, ptr1, len1);
+    var v3 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v3;
+}
+
+/**
+ * Sum of all elements in a vector
+ * @param {Float32Array} a
+ * @returns {number}
+ */
+export function vector_sum(a) {
+    const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.vector_sum(ptr0, len0);
+    return ret;
+}
+
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./barq_wasm_bg.js": import0,
+    };
+}
+
+function getArrayF32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+function getArrayI8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getInt8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let cachedFloat32ArrayMemory0 = null;
+function getFloat32ArrayMemory0() {
+    if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
+        cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
+    }
+    return cachedFloat32ArrayMemory0;
+}
+
+let cachedInt8ArrayMemory0 = null;
+function getInt8ArrayMemory0() {
+    if (cachedInt8ArrayMemory0 === null || cachedInt8ArrayMemory0.byteLength === 0) {
+        cachedInt8ArrayMemory0 = new Int8Array(wasm.memory.buffer);
+    }
+    return cachedInt8ArrayMemory0;
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passArrayF32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4, 4) >>> 0;
+    getFloat32ArrayMemory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let wasmModule, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedFloat32ArrayMemory0 = null;
+    cachedInt8ArrayMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = module.ok && expectedResponseType(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    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);
+
+                } else { throw e; }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
+
+    function expectedResponseType(type) {
+        switch (type) {
+            case 'basic': case 'cors': case 'default': return true;
+        }
+        return false;
+    }
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module !== undefined) {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+    const instance = new WebAssembly.Instance(module, imports);
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module_or_path !== undefined) {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (module_or_path === undefined) {
+        module_or_path = new URL('barq_wasm_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync, __wbg_init as default };

barq-wasm-pkg/barq_wasm_bg.wasm

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:58b1cfda22a4a874ebf1cf481bc5df14875ea93dd0085c7cf1791a2943f3e3c8
+size 78495

barq-wasm-pkg/barq_wasm_bg.wasm.d.ts

@@ -0,0 +1,48 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const argmax: (a: number, b: number) => number;
+export const argmin: (a: number, b: number) => number;
+export const avg_pooling_2d: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+export const batch_normalize: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+export const conv2d_optimized: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
+export const conv2d_scalar: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
+export const cosine_similarity_scalar: (a: number, b: number, c: number, d: number) => number;
+export const cosine_similarity_simd: (a: number, b: number, c: number, d: number) => number;
+export const dequantize_int8: (a: number, b: number, c: number) => [number, number];
+export const dot_product_scalar: (a: number, b: number, c: number, d: number) => number;
+export const dot_product_simd: (a: number, b: number, c: number, d: number) => number;
+export const euclidean_distance: (a: number, b: number, c: number, d: number) => number;
+export const leaky_relu: (a: number, b: number, c: number) => [number, number];
+export const lz4_compress_optimized: (a: number, b: number) => [number, number];
+export const lz4_compress_scalar: (a: number, b: number) => [number, number];
+export const manhattan_distance: (a: number, b: number, c: number, d: number) => number;
+export const matrix_add: (a: number, b: number, c: number, d: number) => [number, number];
+export const matrix_multiply_scalar: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+export const matrix_multiply_tiled: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+export const matrix_scalar_multiply: (a: number, b: number, c: number) => [number, number];
+export const matrix_transpose: (a: number, b: number, c: number, d: number) => [number, number];
+export const max_pooling_2d: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+export const mean: (a: number, b: number) => number;
+export const quantize_int8_scalar: (a: number, b: number, c: number) => [number, number];
+export const quantize_int8_simd: (a: number, b: number, c: number) => [number, number];
+export const relu: (a: number, b: number) => [number, number];
+export const sigmoid: (a: number, b: number) => [number, number];
+export const softmax: (a: number, b: number) => [number, number];
+export const std_dev: (a: number, b: number) => number;
+export const variance: (a: number, b: number) => number;
+export const vector_clamp: (a: number, b: number, c: number, d: number) => [number, number];
+export const vector_elementwise_multiply: (a: number, b: number, c: number, d: number) => [number, number];
+export const vector_max: (a: number, b: number) => number;
+export const vector_min: (a: number, b: number) => number;
+export const vector_norm_scalar: (a: number, b: number) => number;
+export const vector_norm_simd: (a: number, b: number) => number;
+export const vector_normalize: (a: number, b: number) => [number, number];
+export const vector_subtract: (a: number, b: number, c: number, d: number) => [number, number];
+export const vector_sum: (a: number, b: number) => number;
+export const vector_add: (a: number, b: number, c: number, d: number) => [number, number];
+export const vector_scale: (a: number, b: number, c: number) => [number, number];
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __wbindgen_start: () => void;

barq-wasm-pkg/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "barq-wasm",
+  "type": "module",
+  "version": "0.1.0",
+  "files": [
+    "barq_wasm_bg.wasm",
+    "barq_wasm.js",
+    "barq_wasm.d.ts"
+  ],
+  "main": "barq_wasm.js",
+  "types": "barq_wasm.d.ts",
+  "sideEffects": [
+    "./snippets/*"
+  ]
+}

index.html

@@ -1,19 +1,18 @@
 <!doctype html>
-<html>
-	<head>
-		<meta charset="utf-8" />
-		<meta name="viewport" content="width=device-width" />
-		<title>My static Space</title>
-		<link rel="stylesheet" href="style.css" />
-	</head>
-	<body>
-		<div class="card">
-			<h1>Welcome to your static Space!</h1>
-			<p>You can modify this app directly by editing <i>index.html</i> in the Files and versions tab.</p>
-			<p>
-				Also don't forget to check the
-				<a href="https://huggingface.co/docs/hub/spaces" target="_blank">Spaces documentation</a>.
-			</p>
-		</div>
-	</body>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="description" content="Browser-native RAG chat — upload documents and chat with them using LiquidAI LFM2.5 and barq-vweb, all running locally in your browser." />
+    <title>Barq RAG — Chat with your Documents</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap" rel="stylesheet" />
+    <script type="module" crossorigin src="/assets/index-XZR_pWkl.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-CAjvEqqe.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
 </html>