smol-string 0.1.1-beta → 1.0.0

package/dist/smol-string-worker.js

@@ -1,46 +1,46 @@
-const J = "(async()=>{function w(I,C){const A=new TextEncoder().encode(I),g=C.allocUint8(A.length);return new Uint8Array(C.memory.buffer,g,A.length).set(A),{ptr:g,length:A.length}}function e(I){const C=new Array(I.length);for(let A=0;A<I.length;A++)C[A]=String.fromCharCode(I[A]);return C.join("")}function t(I,C){const A=new Uint32Array(I.buffer.slice(C,C+8)),g=A.at(0),Q=A.at(1);return{start:C-g,end:C,capacity:Q}}var h=async(I={},C)=>{let A;if(C.startsWith("data:")){const g=C.replace(/^data:.*?base64,/,"");let Q;if(typeof Buffer=="function"&&typeof Buffer.from=="function")Q=Buffer.from(g,"base64");else if(typeof atob=="function"){const E=atob(g);Q=new Uint8Array(E.length);for(let i=0;i<E.length;i++)Q[i]=E.charCodeAt(i)}else throw new Error("Failed to decode base64-encoded data URL, Buffer and atob are not supported");A=await WebAssembly.instantiate(Q,I)}else{const g=await fetch(C),Q=g.headers.get("Content-Type")||"";if("instantiateStreaming"in WebAssembly&&Q.startsWith("application/wasm"))A=await WebAssembly.instantiateStreaming(g,I);else{const E=await g.arrayBuffer();A=await WebAssembly.instantiate(E,I)}}return A.instance},G=I=>h(I,"data:application/wasm;base64,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");const f=await G(),B=f.exports;function s(I){const{ptr:C,length:A}=w(I,B),g=B.compress(C,A);B.free(C,A);const{start:Q,end:E,capacity:i}=t(B.memory,g),o=new Uint16Array(B.memory.buffer.slice(Q,E)),D=e(o);return B.free(Q,i),D}function n(I){const C=B.allocUint16(I.length),A=new Uint16Array(B.memory.buffer,C,I.length);for(let a=0;a<I.length;a++)A[a]=I.charCodeAt(a);const g=B.decompress(C,I.length);B.free(C,2*I.length);const{start:Q,end:E,capacity:i}=t(B.memory,g),o=new Uint8Array(B.memory.buffer.slice(Q,E)),D=new TextDecoder().decode(o);return B.free(Q,i),D}self.onmessage=function(I){const{command:C,id:A,data:g}=I.data;switch(C){case"decompress":{self.postMessage({id:A,data:n(g)});break}case"compress":{self.postMessage({id:A,data:s(g)});break}}}})();", l = typeof window < "u" && window.Blob && new Blob(["URL.revokeObjectURL(import.meta.url);" + atob(J)], { type: "text/javascript;charset=utf-8" });
-function W(Q) {
+const J = "(async()=>{function k(A,Q){const I=new TextEncoder().encode(A),g=Q.allocUint8(I.length);return new Uint8Array(Q.memory.buffer,g,I.length).set(I),{ptr:g,length:I.length}}function e(A){const Q=new Array(A.length);for(let I=0;I<A.length;I++)Q[I]=String.fromCharCode(A[I]);return Q.join("")}function t(A,Q){const I=new Uint32Array(A.buffer.slice(Q,Q+8)),g=I.at(0),B=I.at(1);return{start:Q-g,end:Q,capacity:B}}var n=async(A={},Q)=>{let I;if(Q.startsWith("data:")){const g=Q.replace(/^data:.*?base64,/,"");let B;if(typeof Buffer=="function"&&typeof Buffer.from=="function")B=Buffer.from(g,"base64");else if(typeof atob=="function"){const E=atob(g);B=new Uint8Array(E.length);for(let i=0;i<E.length;i++)B[i]=E.charCodeAt(i)}else throw new Error("Failed to decode base64-encoded data URL, Buffer and atob are not supported");I=await WebAssembly.instantiate(B,A)}else{const g=await fetch(Q),B=g.headers.get("Content-Type")||"";if("instantiateStreaming"in WebAssembly&&B.startsWith("application/wasm"))I=await WebAssembly.instantiateStreaming(g,A);else{const E=await g.arrayBuffer();I=await WebAssembly.instantiate(E,A)}}return I.instance},y=A=>n(A,"data:application/wasm;base64,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");const f=await y(),C=f.exports;function J(A){const{ptr:Q,length:I}=k(A,C),g=C.compress(Q,I);if(C.free(Q,I),g<0)throw new Error("Error compressing string.");const{start:B,end:E,capacity:i}=t(C.memory,g),D=new Uint16Array(C.memory.buffer.slice(B,E)),a=e(D);return C.free(B,i),a}function r(A){const Q=(A.charCodeAt(A.length-3)<<16)+A.charCodeAt(A.length-4),I=(A.charCodeAt(A.length-1)<<16)+A.charCodeAt(A.length-2),g=A.length-4;let B=C.allocUint16(g),E=new Uint16Array(C.memory.buffer,B,g);for(let o=0;o<g;o++)E[o]=A.charCodeAt(o);const i=C.decompress(B,g,Q,I);if(C.free(B,2*g),i<0)throw new Error("Error decompressing string.");const{start:D,end:a,capacity:w}=t(C.memory,i),s=new Uint8Array(C.memory.buffer.slice(D,a)),F=new TextDecoder().decode(s);return C.free(D,w),F}self.onmessage=function(A){const{command:Q,id:I,data:g}=A.data;switch(Q){case"decompress":{self.postMessage({id:I,data:r(g)});break}case"compress":{self.postMessage({id:I,data:J(g)});break}}}})();", V = typeof window < "u" && window.Blob && new Blob(["URL.revokeObjectURL(import.meta.url);" + atob(J)], { type: "text/javascript;charset=utf-8" });
+function d(F) {
   let U;
   try {
-    if (U = l && (window.URL || window.webkitURL).createObjectURL(l), !U)
+    if (U = V && (window.URL || window.webkitURL).createObjectURL(V), !U)
       throw "";
-    const F = new Worker(U, {
+    const Q = new Worker(U, {
       type: "module",
-      name: Q?.name
+      name: F?.name
     });
-    return F.addEventListener("error", () => {
+    return Q.addEventListener("error", () => {
       (window.URL || window.webkitURL).revokeObjectURL(U);
-    }), F;
+    }), Q;
   } catch {
     return new Worker(
       "data:application/javascript;base64," + J,
       {
         type: "module",
-        name: Q?.name
+        name: F?.name
       }
     );
   }
 }
-const R = new W();
-let d = 0;
+const R = new d();
+let l = 0;
 const B = {};
-R.onmessage = function(Q) {
-  const U = Q.data.id;
-  B[U](Q.data.data), delete B[U];
+R.onmessage = function(F) {
+  const U = F.data.id;
+  B[U](F.data.data), delete B[U];
 };
-async function Z(Q) {
-  const U = d++;
-  return new Promise((F) => {
-    B[U] = F, R.postMessage({ command: "compress", id: U, data: Q });
+async function S(F) {
+  const U = l++;
+  return new Promise((Q) => {
+    B[U] = Q, R.postMessage({ command: "compress", id: U, data: F });
   });
 }
-async function V(Q) {
-  const U = d++;
-  return new Promise((F) => {
-    B[U] = F, R.postMessage({ command: "decompress", id: U, data: Q });
+async function Z(F) {
+  const U = l++;
+  return new Promise((Q) => {
+    B[U] = Q, R.postMessage({ command: "decompress", id: U, data: F });
   });
 }
 export {
-  Z as compress,
-  V as decompress
+  S as compress,
+  Z as decompress
 };

package/dist/smol-string.js

@@ -1,28 +1,81 @@
-import { i as w, c as k, e as G, U as h } from "./wasm-helper-C1VfMvbY.js";
-const F = (I) => w(I, "data:application/wasm;base64,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"), f = await F(), A = f.exports;
-function Y(I) {
-  const { ptr: C, length: Q } = k(I, A), E = A.compress(C, Q);
-  A.free(C, Q);
-  const { start: g, end: i, capacity: D } = G(A.memory, E), o = new Uint16Array(A.memory.buffer.slice(g, i)), a = h(o);
-  return A.free(g, D), a;
-}
-function s(I) {
-  const C = A.allocUint16(I.length), Q = new Uint16Array(
-    A.memory.buffer,
-    C,
+function s(A, Q) {
+  const I = new TextEncoder().encode(A), g = Q.allocUint8(I.length);
+  return new Uint8Array(
+    Q.memory.buffer,
+    g,
     I.length
+  ).set(I), { ptr: g, length: I.length };
+}
+function n(A) {
+  const Q = new Array(A.length);
+  for (let I = 0; I < A.length; I++)
+    Q[I] = String.fromCharCode(A[I]);
+  return Q.join("");
+}
+function w(A, Q) {
+  const I = new Uint32Array(
+    A.buffer.slice(Q, Q + 8)
+  ), g = I.at(0), B = I.at(1);
+  return {
+    start: Q - g,
+    end: Q,
+    capacity: B
+  };
+}
+const y = async (A = {}, Q) => {
+  let I;
+  if (Q.startsWith("data:")) {
+    const g = Q.replace(/^data:.*?base64,/, "");
+    let B;
+    if (typeof Buffer == "function" && typeof Buffer.from == "function")
+      B = Buffer.from(g, "base64");
+    else if (typeof atob == "function") {
+      const E = atob(g);
+      B = new Uint8Array(E.length);
+      for (let i = 0; i < E.length; i++)
+        B[i] = E.charCodeAt(i);
+    } else
+      throw new Error("Failed to decode base64-encoded data URL, Buffer and atob are not supported");
+    I = await WebAssembly.instantiate(B, A);
+  } else {
+    const g = await fetch(Q), B = g.headers.get("Content-Type") || "";
+    if ("instantiateStreaming" in WebAssembly && B.startsWith("application/wasm"))
+      I = await WebAssembly.instantiateStreaming(g, A);
+    else {
+      const E = await g.arrayBuffer();
+      I = await WebAssembly.instantiate(E, A);
+    }
+  }
+  return I.instance;
+}, f = (A) => y(A, "data:application/wasm;base64,AGFzbQEAAAABVg1gBH9/f38Bf2AFf39/f38AYAN/f38AYAJ/fwBgAn9/AX9gBn9/f39/fwF/YAR/f39/AGABfwF/YAF/AGADf39/AX9gAn9/AX5gAn5+AX5gBH9/fn4AAyMiBwIHAwgDBgoAAwQEBAICBgQIAAACAgQJBgMCAAUBCwwDCQQFAXABBAQFAwEAEQYJAX8BQYCAwAALB0QGBm1lbW9yeQIACmFsbG9jVWludDgAAAthbGxvY1VpbnQxNgACBGZyZWUAAwhjb21wcmVzcwAKCmRlY29tcHJlc3MAEgkJAQBBAQsDGxwdCpBFIjwBAX8jAEEQayIBJAAgAUGQgMAAKQMANwMAIAFBCGogASAAEAEgAS8BDEUEQCABKAIIIAFBEGokAA8LAAtMAgF/AX4jAEEQayIDJAAgACACBH4gASkCACIEpyACQQBBACAEQiCIpygCABEAACIBRa1CIIYgAa2EBUL/////Dws3AgAgA0EQaiQAC2MCAn8BfiMAQRBrIgEkACABIABBAEgiAjoADAJAIAINAAJAIABBAXQiAEUEQEF+IQAMAQtBkIDAACkDACIDpyAAQQFBACADQiCIpygCABEAACIARQ0BCyABQRBqJAAgAA8LAAsxAQF+IAEEQEGQgMAAKQIAIgKnIABBqtWq1XogARsgAUEAQQAgAkIgiKcoAggRAQALCwsAIAAgAEEMahAFC1oCAn8BfiAAKAIAIgIEQCACQQxrIgJBCGooAgBBDWxBD2pBfHEiAwRAIAEpAgAiBKcgAkEEIAMbIANBAkEAIARCIIinKAIIEQEACyAAQQA2AgggAEEANgIACwu5AgIIfwF+IwBBEGsiBCQAIAEoAgAhBUGggMAAIQgCQCABKAIERQ0AIAVBCGshCSACIAMQByIMpwJ/IAVFBEBBfwwBCyAFQQRrKAIAIgZBAWsLIgpxIQEgDEI5iKchCwNAIAEgBWosAAAiB0UNASAGRQ0BAkAgB0EATg0AIAsgB0H/AHFHDQAgAiADIAkoAgAgAUEDdGoiBygCACAHKAIEEAhBAXFFDQAgBEEBOgAMIAQgATYCCCAEQQhqIQgMAgsgBkEBayEGIAFBAWogCnEhAQwACwALIAACfiAILQAERQRAQgAhDEIADAELIAQgBUEMaygCACAIKAIAQQJ0aiIBQQJqLQAAQQ9xOgACIAQgAS8BADsBAEKAgICAECEMIAQzAQAgBDEAAkIQhoQLIAyENwIAIARBEGokAAvUCgILfgF/IwBBQGoiDSQAIAGtIQMCfiABQSBNBEAgAUERSQRAIAFBCE8EQCADQgGGQrH/voPNuKWP5QB9IgIgACABakEIaykAACIDIAApAABCsf++g824pY/lAH0iBEIniXx+IgUgBSADQhuJIAJ+IAR8hSACfiIDQi+IhSADhSACfiIDQi+IIAOFIAJ+DAMLIAFBBE8EQCADQgGGQrH/voPNuKWP5QB9IgIgACABakEEazUAACIEIAA1AABCA4YgA3yFfiIDQi+IIASFIAOFIAJ+IgNCL4ggA4UgAn4MAwtCz4DB/LLH2vCafyABRQ0CGiAAIAFqQQFrLQAAQQJ0IAFqrUKn4qy+yYvy0kN+IAAxAAAgACABQQF2ajEAAEIIhoRCz4DB/LLH2vCaf36FIgJCL4ggAoVCz4DB/LLH2vCaf34MAgsgA0IBhkKx/76Dzbilj+UAfSICIAAgAWoiAUEIaykAAH4iAyAAKQAAQvPk4/T7za3JtH9+IgQgACkACCIFQrH/voPNuKWP5QB9Qi6JfHwiByAHIANCIokgBCAFfEIViXwgAUEQaykAAELPgMH8ssfa8Jp/fnyFIAJ+IgNCL4iFIAOFIAJ+IgNCL4ggA4UgAn4MAQsgAUHBAE8EQCAAIAFqIgFBKGspAAAhBiABQThrKQAAIQQgAUEQaykAACEIIA0gAUFAaiADIAFBMGspAAAgA3wgAUEYaykAABAeIgIQHyANKQMIIQUgDSkDACEHIA1BEGogAUEgayAEIAh8IgRCjZuci4Sy0rbLAH0gBhAfQgAgA0IBfUJAg30hCiAAKQAAIAZC8+Tj9PvNrcm0f358IQkgDSkDGCEGIA0pAxAhCANAIAApADAhDCAAKQAoIQsgDUEgaiAAIAVC8+Tj9PvNrcm0f34gACkACCAEIAd8IAl8fEIbiULz5OP0+82tybR/fiAGhSIDIAh8EB8gByALfCELIAQgBXwhBCANKQMoIQUgDSkDICEHIA1BMGogAEEgaiACIAh8Qh+JQvPk4/T7za3JtH9+IgkgBnwgCyAEIAx8QhaJQvPk4/T7za3JtH9+fCIEIAApABB8EB8gAEFAayEAIA0pAzghBiANKQMwIQggAyECIApCQH0iCkIAUg0ACyAHIAgQHiAEQi+IIASFQvPk4/T7za3JtH9+IAJ8fCAFIAYQHiAJfBAeDAELIANCAYZCsf++g824pY/lAH0iAyAAIAFqIgFBEGspAAB+IgQgAUEgaykAACIFfCAAKQAYQgl+IgcgACkAEELPgMH8ssfa8Jp/fnwiBiABQRhrKQAAIgJ8IgggACkACCIJfCAGQhaJIAJ8IgYgCCABQQhrKQAAIgp8fCAEIAcgCiAAKQAAQs+Awfyyx9rwmn9+fCIEIAWFfEIBfCIFfCAJQiKJIAJ8Qgl+IARCFYl8IAV8IAN+IgJCOIYgAkKA/gODQiiGhCACQoCA/AeDQhiGIAJCgICA+A+DQgiGhIQgAkIIiEKAgID4D4MgAkIYiEKAgPwHg4QgAkIoiEKA/gODIAJCOIiEhIR8IAN+IgJCOIYgAkKA/gODQiiGhCACQoCA/AeDQhiGIAJCgICA+A+DQgiGhIQgAkIIiEKAgID4D4MgAkIYiEKAgPwHg4QgAkIoiEKA/gODIAJCOIiEhIR8IAN+IgJCOIYgAkKA/gODQiiGhCACQoCA/AeDQhiGIAJCgICA+A+DQgiGhIQgAkIIiEKAgID4D4MgAkIYiEKAgPwHg4QgAkIoiEKA/gODIAJCOIiEhIR8IAN+fCICQi+IIAKFIAN+IAZ8CyANQUBrJAALlgEBBX8CQCABIANHDQAgAUECdkEBaiEFIAIhAyAAIQQDQCAFQQFrIgUEQCADKAAAIAQoAAAgA0EEaiEDIARBBGohBEYNAQwCCwsgAUEDcSEDIAAgAUF8cSIBaiEEIAEgAmohBQNAIANFIgAhBiAADQEgA0EBayEDIAUtAAAgBC0AACAEQQFqIQQgBUEBaiEFRg0ACwsgBgufAgEDfwJAIAAtABwiAkEUTw0AIAAoAhhBgAJqQX8gAnRBf3NJDQAgACACQQFqIgI6ABwLIAACfyACQf8BcUHAACAALQAdIgNrIgRB/wFxTQRAIAAoAgAgACgCBEEDdGpBCGsiBCAEKQMAIAGtQv//P4NBACACIANqa0E/ca2GhDcDACAALQAcIAAtAB1qDAELIANBwABHBEAgACgCACAAKAIEQQN0akEIayIDIAMpAwAgAUH//z9xIAIgBGt2rYQ3AwAgAC0AHCECCyAAIAAoAgQiA0EBajYCBCAAKAIAIANBA3RqIAGtQv//P4MgBCACa0E/ca2GNwMAIAAtABwgBGsLOgAdIAAgACgCFEEBajYCFCAAIAAoAhhBAWo2AhgL9REDD38DfQF+IwBBsAZrIgIkAAJ/AkACQCABRQRAIAJBCTsBhAYgAkIANwL8BSACQqrVqtUKNwLoBSACQQA2AvAFIAJBkIDAACkDADcC9AUgAkHoBWpBARALQf//A3ENASACKALoBSACKALsBSIAQQN0akIANwMAIAJBMGogAkHwBWopAgA3AwAgAkE4aiACQfgFaikCADcDACACQUBrIAJBgAZqKQIANwMAIAIgAEEBajYC7AUgAiACKQLoBTcDKAwCCyACQdAAakEANgIAIAJCADcDSCACQZCAwAApAwAiFDcCVCACQdQAaiEOA0AgA0GABEcEQCACQdwAaiADakECOwEAIANBAmohAwwBCwsgAiAUNwL0BSACQQA2AvAFIAJCqtWq1Qo3AugFAkAgAkHoBWpBFAJ/AkACQCABs0MAAIA/kiISvCIDQYCAgARIBEBDAADAf0MAAID/IANB/////wdxIgQbIREgA0EASA0CIARFDQIgEkMAAABMlLwhA0HofiEEDAELIBIhESADQf////sHSw0BQYF/IQRDAAAAACERIANBgICA/ANGDQELIANBjfarAmoiA0H///8DcUHzidT5A2q+QwAAgL+SIhEgESARQwAAAD+UlCISk7xBgGBxviITQwCwuD+UIBEgE5MgEpMgESARQwAAAECSlSIRIBIgESARlCIRIBEgEZQiEUPu6ZE+lEOqqio/kpQgESARQyaeeD6UQxPOzD6SlJKSlJIiEUMAsLg/lCARIBOSQ9SaOLmUkpIgBCADQRd2arKSIRELIBFDAACAT10gEUMAAAAAYHEEQCARqQwBC0EACyIDIANBFE8bIAFsQUBrQQZ2QQFqEAxB//8DcQ0AIAIoAvAFIQMgAikC9AUhFCACKALoBSIEIAIoAuwFIgZBA3RqQgA3AwAgAkEJOwH4BCACQgA3AvAEIAIgFDcC6AQgAiADNgLkBCACIAQ2AtwEIAJBADsB/AQgAkEAOgD+BCACIAZBAWo2AuAEIAFBAWohDyAAQQFrIRBBgAIhCUECIQMDQCAAIApqIQQCfwJAAkACQAJAAkAgAkHcBGoCfwNAIAMgCmoiDCABTw0CIAJBgAVqIAJByABqIAQgAxAGAkAgAi0AhAVFBEAgA0ECRw0BIAQtAAAMAwsgAiACLQCCBToA/gQgAiACLwGABTsB/AQgA0EBaiEDDAELCyACLwH8BCACLQD+BEEQdHILEAkgAkHcAGogBC0AAEEBdGoiBiAGLwEAIgYgA0EBa0H//wNxIgUgBSAGSRs7AQAgCUH//z9xQf//P0YEQCACKAJIIgRFDQUgBCAEQQRrKAIAIgQQICACQQA2AkwgAiAErULQAH5C5ACAPgJQDAULIAJByABqIAQgAxANIAIoAlANAyACKAJIIgYEfyAGQQRrNQIAQtAAfiIUIBRC5ACCfULkAHxC0ACApwVBAQshBSACQfAFaiINQQA2AgAgAkIANwPoBSACIAIpAlQ3A4gGIAJBkAZqIAJBiAZqQQhCAUEgIAVna62GpyIFIAVBCE0bIgdBD2oiCCAHQQN0aiILIAdBAnRqQXxxEA4gAikDkAYiFEIgiKciBUH//wNxDQIgFKciBSAHNgIIIAUgBSAIQXxxajYCBCAFIAUgC0F8cWo2AgAgAiAFQQxqIgU2AugFIAUgBQR/IAVBBGsoAgAFQQALECAgAiAHrULQAH5C5ACAPgLwBSACKAJMIgtFDQEgBgR/IAZBBGsoAgAFQQALIQUgBkEMayIIKAIAIQcgCEEEaigCACEIA0AgBUUNAiAGLAAAQQBIBEAgAkHoBWogCCgCACAIQQRqKAIAIAcvAQAgB0ECai0AAEEQdHIQDyACKALsBSALRg0DCyAFQQFrIQUgBkEBaiEGIAhBCGohCCAHQQRqIQcMAAsACyACQdwEagJ/IAEgCkEBak0EQCAELQAADAELIAJBuAVqIAJB2ABqKAIANgIAIAJBsAVqIAJB0ABqKQMANwMAIAIgAikDSDcDqAUgAkHABWogAkGoBWogBCADEAYgAkHcBGoCfwJAIAItAMQFRQRAIANBAkcNASAELQAADAILIAIvAcAFIAItAMIFQRB0cgwCCyACQdgFaiACQdgAaigCADYCACACQdAFaiACQdAAaikDADcDACACIAIpA0g3A8gFIAJB4AVqIAJByAVqIAQgA0EBaxAGIAIvAeAFIAItAOIFQRB0cgsQCSADIARqQQFrLQAACxAJIAJBQGsgAkH0BGopAgA3AwAgAkE4aiACQewEaikCADcDACACQTBqIAJB5ARqKQIANwMAIAIgAikC3AQ3AyggAkHIAGoQBAwICyACQdAAaiIGKAIAIQUgBiANKAIANgIAIA0gBTYCAEEAIQUgAkEANgJMIAIpA0ghFCACIAIpA+gFNwNIIAIgFDcD6AULIAJB6AVqIA4QBSAFQf//A3ENBAsgAkHIAGogBCADIAkQDyAJQQFqDAELQQAhBANAIARBgARHBEAgAkHcAGogBGpBAjsBACAEQQJqIQQMAQsLIAJB3ARqQf//PxAJIAJBADYC9AQgAkEJOgD4BEGAAgshCSAPIAprIANrIgMgAkHcAGogDCAQaiIFLQAAQQF0ai8BACIEIAMgBEkbIQQgDEEBayEKQQIhAwNAIAQgA2siBkEFSQ0BIAJBmAVqIAJB2ABqKAIANgIAIAJBkAVqIAJB0ABqKQMANwMAIAIgAikDSDcDiAUgAkGgBWogAkGIBWogBSAGQQF2IANqIgYQBiAGIAMgAi0ApAUiBxshAyAEIAYgBxshBAwACwALAAsgAkHIAGoQBAtBfwwBCyACQSBqIAJBQGspAwA3AwAgAkEYaiACQThqKQMANwMAIAJBEGogAkEwaikDADcDACACIAIpAyg3AwhBfyACQQhqIAIoAgwiAEECahALQf//A3ENABogAigCCCIDIAIoAgxBA3RqIgQgAjUCHCABrUIghoQ3AwAgBEEIaiAAQQN0QQhqIgCtIAI1AhBCI4aENwMAIAAgA2oLIAJBsAZqJAALHgECfyABIAAoAggiA0sEfyAAIAMgARAQEAwFQQALC64CAgZ/AX4jAEEQayIEJAACQCAAKAIIIgMgAU8NACAAKAIAIQUCQCADRQ0AIAQgAUH/////AUs6AAggAUGAgICAAk8NACAAKQIMIginIAUgA0EDdEEDIAFBA3RBACAIQiCIpygCBBEFAEEBcUUNACAAIAE2AggMAQsgACkCDCEIIAQgAUH/////AUs6AAwCQCABQYCAgIACTw0AAkAgAUEDdCICRQRAQXghAgwBCyAIpyACQQNBACAIQiCIpygCABEAACICRQ0BCyACIAAoAgAgACgCBEEDdBAhIQZBACECIANBA3RBACADGyIHBEAgACkCDCIIpyAFQQggAxsgB0EDQQAgCEIgiKcoAggRAQALIAAgATYCCCAAIAY2AgAMAQtBASECCyAEQRBqJAAgAgvUAQIIfwF+IwBBEGsiBCQAQaCAwAAhBwJAIAAoAgRFDQAgACgCACIFQQhrIQggASACEAciC6cgBQR/IAVBBGsoAgAiBkEBawVBfwsiCXEhACALQjmIpyEKA0AgACAFaiwAACIDRQ0BIAZFDQECQCADQQBODQAgCiADQf8AcUcNACABIAIgCCgCACAAQQN0aiIDKAIAIAMoAgQQCEEBcUUNACAEQQE6AAwgBEEIaiEHDAILIAZBAWshBiAAQQFqIAlxIQAMAAsACyAHLQAEGiAEQRBqJAALTwEBfiACRQRAIABC/P///w83AgAPCyABKQIAIgOnIAJBAkEAIANCIIinKAIAEQAAIgEEQCAAIAE2AgAgAEEAOwEEDwsgAEKAgICAEDcCAAvJAQIEfwF+IAAgASACEA1BfyEEIAEgAhAHIginIAAoAgAiBgRAIAZBBGsoAgBBAWshBAsgBHEhBQNAIAUgBmoiBywAAEEATkUEQCAFQQFqIARxIQUMAQsLIAAgACgCCEEBazYCCCAHIAhCOYinQYABcjoAACAAKAIAQQhrKAIAIAVBA3RqIgQgAjYCBCAEIAE2AgAgACgCAEEMaygCACAFQQJ0aiIBIAM7AQAgAUECaiADQf//P3FBEHY6AAAgACAAKAIEQQFqNgIECyUBAX8DQEF/IABBAXYgAGpBCGoiAiAAIAJLGyIAIAFJDQALIAALXwIDfwF+IwBBEGsiASQAIAEgACkCDDcDCCAAKAIAIQIgACgCCCIAQQN0QQAgABsiAwRAIAFBCGopAgAiBKcgAkEEIAAbIANBAkEAIARCIIinKAIIEQEACyABQRBqJAAL9goCCn8CfiMAQeAAayIEJAAgBEEANgJQIARCqtWq1Qo3AkggBEGQgMAAKQMAIg43AlQCfwJAAn8gAkUEQEGq1arVegwBCyACIQlBqtWq1XogBEHUAGoiAUGq1arVekEAIAIQE0EBcQ0AGiAEQSBqIAEgAhAUIAQvASgNASAEKAIkIQkgBCgCIAshC0EJIQoDQAJAAkACQAJAIAIgBkcEQCAKQf8BcSIBQRRJDQEMBAsgBCAONwM4AkAgBEE4aiALIAkgAhATQQFxBEAgCyEADAELIARByABqIARBOGogAhAUIAQvAVANBiAEKAJIIgAgCyAEKAJMIgJBAnQQIRogBCAONwMgIARBIGogCyAJEBULIAJFBEBBACEFQarVqtV6IQdBACEDDAILIAQgDjcCLCAEQQA2AiggBEKq1arVCjcCICAEQQBB//8/EBAiAUH/////AUs6AEQgAUGAgICAAk8NAiAEIA43AzggBEHIAGogBEE4aiABQQN0EA4gBCkDSCIPQoCAgIDw/z+DQgBSDQIgBCABNgIoIAQgD6ciCzYCIEEAIQEDQCABQfj//wNGRQRAIAEgC2pCADcCACABQQhqIQEMAQsLIARB//8/NgIkIAQgDjcCVEEAIQEgBEEANgJQIARCqtWq1Qo3AkggBEHIAGogA0ECdBAWQf//A3ENAiAEKQJUIQ4gBCgCUCEDIAQoAkgiByAEKAJMIgVqIAAtAAA6AAAgCyAALwEAIABBAmotAABBEHRyQQN0aiIKQQE2AgQgCiAHNgIAIAVBAWohBkGAAiEKQQEhCANAIAYhBQJ/An8CQAJAIAIgCE0NACAAIAhBAnRqIgYvAQAgBkECai0AAEEQdHIiBkH//z9GBEAgCEEBaiIIIAJPDQFBACEBA0AgAUH4//8DRkUEQCABIAtqQgA3AgAgAUEIaiEBDAELCyAAIAhBAnRqIgEvAQAgAUECai0AAEEQdHIiAUGAAk8EQCAEQf//PzYCJAwJCyAFIAdqIAE6AAAgBUEBaiEGQYACDAQLIAZBgAJJDQEgCyAGQQN0aiIGKAIAIglFBEAgBSAHaiABIAdqIgYgBSABayIJECEaIAcgBSAJaiIJaiAGLQAAOgAAIAlBAWoMAwsgBSAHaiAJIAYoAgQiBhAhGiAFIAZqDAILIARB//8/NgIkIARBIGoQEQwFCyAFIAdqIAY6AAAgBUEBagshBiALIApB//8/cUEDdGoiCSAFIAFrQQFqNgIEIAkgASAHajYCACAKQQFqCyEKIAhBAWohCCAFIQEMAAsACyAKIA1BgAJqQX8gAXRBf3NPaiEKDAILIAQgDjcCGCAEIAc2AgwgBCAFNgIQIAQgAzYCFCAFQQhqIgAgA00EfyAFBUF/IARBDGogAyAAEBAQFkH//wNxDQUaIAQoAgwhByAEKAIUIQMgBCgCEAsgB2oiACAFOgAAIABBB2ogA0EYdjoAACAAQQZqIANBEHY6AAAgAEEFaiADQQh2OgAAIABBBGogAzoAACAAQQNqIAVBGHY6AAAgAEECaiAFQRB2OgAAIABBAWogBUEIdjoAACAFIAdqDAQLIARBIGoQEQwCC0EAIQggCiEBA0AgAUH/AXEiDARAIAggACAHIAVB/wFxQcAARiIIaiIHQQN0aikDAEEAIAUgCBsiBUE/ca2GQQAgDEHAACAFa0H/AXEiCCAIIAxLGyIMa0E/ca2IpyABIAxrIgF0ciEIIAUgDGohBQwBCwsgCyAGQQJ0aiIBIAg7AQAgAUECaiAIQf//P3EiAUEQdjoAAEEAIA1BAWogAUH//z9GIgEbIQ1BCSAKIAEbIQogBkEBaiEGDAALAAtBfwsgBEHgAGokAAt9AgJ/AX4jAEEQayIEJAACQCADRQRAIAQgACkCADcDACAEIAEgAhAVQQEhBQwBCyACRQ0AIAQgA0H/////A0s6AAwgA0GAgICABE8NACAAKQIAIganIAEgAkECdEECIANBAnRBACAGQiCIpygCBBEFACEFCyAEQRBqJAAgBQuyAQIBfwF+IwBBMGsiAyQAIAEpAgAhBCADIAJB/////wNLOgAsIAACfwJAAkAgAkGAgICABE8EQEEBIQEMAQsgAyAENwMYIANBIGogA0EYaiACQQJ0EA4gAykDICIEQiCIpyIBQf//A3FFDQELIAMgATsBCCADDAELIAMgAjYCECADIAQ+AgwgA0EAOwEUIANBDGoLIgIpAgA3AgAgAEEIaiACQQhqKAIANgIAIANBMGokAAs2AgF/AX4gAkECdEEAIAIbIgMEQCAAKQIAIgSnIAFBBCACGyADQQJBACAEQiCIpygCCBEBAAsL3QECBX8BfiMAQSBrIgIkAAJAIAAoAggiAyABTw0AIABBDGohBSAAKAIAIQYCQAJAIANFDQAgBSkCACIHpyAGIANBACABQQAgB0IgiKcoAgQRBQBBAXFFDQAgACABNgIIDAELIAIgBSkCADcDECACQRhqIAJBEGogARABIAIvARwiBA0BIAIoAhggACgCACAAKAIEECEhBCADBEAgBSkCACIHpyAGQarVqtV6IAMbIANBAEEAIAdCIIinKAIIEQEACyAAIAE2AgggACAENgIAC0EAIQQLIAJBIGokACAEC7gCAg1/AX4jAEEQayIFJAAgACgCBCEHIAAoAgAhCCACQf8BcSEJA0ACQAJAIAQgB0YEQEF/IQMMAQsgCCAEQQR0aiICQQhqKQMAIhBCAFkEQCACKQMAeyAQe3ynIAFJDQILIARBB3QiA0GAAWohCgNAIAMgCk8NAiADIAApAgAiEEIZiKdBgH9xIgIgAiADSRsiCyADayEMIBCnQQggEEIgiKcbIQ0gA0EQdGghDkEAIQICQANAIAIgDEYEQCALIQYMAgtB/wEgAiADaiIGQQdxIg9BB3N2QQEgD3RxIA0gBkEDdmotAABxRQ0BIAJBAWoiAiABSQ0AIAkgDksNAAsgBSAQNwMIIAVBCGogAyABQQAQGAwCCyAGQQFqIQMMAAsACyAFQRBqJAAgAw8LIARBAWohBAwACwALUQEBfyADQQFxIQMDQCACBEAgAUEDdiAAKAIAQQggACgCBBtqIgQgBC0AAEF+IAFBB3EiBHdxIAMgBHRyOgAAIAFBAWohASACQQFrIQIMAQsLC5wBAQJ/IwBBEGsiAiQAIABBgBBJBEBBmIDAACAAQYAQIAEgAUGAEE8bIABrEBoLIAFBgBBLBEBBrIDAACgCAEUEQEGsgMAAQYAgNgIAQaiAwAAgAUEBayIBQRB0IgM2AgAgA0GAgAQQIAsgAkGogMAAKQMANwMIIAJBCGpBgBAgACAAQYAQTRsiAEGAEGsgASAAaxAaCyACQRBqJAALKwEBfyMAQRBrIgMkACADIAApAgA3AwggA0EIaiABIAJBARAYIANBEGokAAuZAQACf0EAIAFBgYB8Tw0AGgJAQZiAwAAgAUH//wNqQRB2IgEgAhAXIgBBf0cNAEGogMAAIAEgAhAXIgBBf0cEQCAAQYAQaiEADAELQQAgAUEBIAJ0IgI/ACIBQRB0IgNqQQFrQQAgAmtxIANrIgJBEHYiA2pAAEEATA0BGiABIANqIQAgAkGAgARJDQAgASAAEBkLIABBEHQLC0kAAkAgAkH//wNqIgBBgIB8cSAETyICRQ0AIARB//8DakEQdiIDIABBEHYiAEYNACADIAFB//8DakEQdiIBaiAAIAFqEBkLIAILHQAgAUH//wNqQRB2IgAgACACQf//A2pBEHZqEBkLPgAgACABhULp2uDZjsH6751/fiIAQi+IIAGFIACFQuna4NmOwfrvnX9+IgBCL4ggAIVC6drg2Y7B+u+df34LQgECfiAAIAEpABAgASkAACACfCICIAEpAAh8fCIEIAEpABgiBXw3AwAgACAEQhSJIAJ8IAUgAiADfHxCK4l8NwMICyEAIAEEQANAIABBADoAACAAQQFqIQAgAUEBayIBDQALCwtDAQF/AkAgAkUNACACQQFrIQIgACEDA0AgAyABLQAAOgAAIAJFDQEgAkEBayECIAFBAWohASADQQFqIQMMAAsACyAACwstAwBBgIDAAAsJAQAAAAIAAAADAEGWgMAACwcQADAAEAAQAEGogMAACwSqqqqq"), J = await f(), C = J.exports;
+function G(A) {
+  const { ptr: Q, length: I } = s(A, C), g = C.compress(Q, I);
+  if (C.free(Q, I), g < 0)
+    throw new Error("Error compressing string.");
+  const { start: B, end: E, capacity: i } = w(C.memory, g), D = new Uint16Array(C.memory.buffer.slice(B, E)), a = n(D);
+  return C.free(B, i), a;
+}
+function e(A) {
+  const Q = (A.charCodeAt(A.length - 3) << 16) + A.charCodeAt(A.length - 4), I = (A.charCodeAt(A.length - 1) << 16) + A.charCodeAt(A.length - 2), g = A.length - 4;
+  let B = C.allocUint16(g), E = new Uint16Array(
+    C.memory.buffer,
+    B,
+    g
   );
-  for (let B = 0; B < I.length; B++)
-    Q[B] = I.charCodeAt(B);
-  const E = A.decompress(
-    C,
-    I.length
+  for (let o = 0; o < g; o++)
+    E[o] = A.charCodeAt(o);
+  const i = C.decompress(
+    B,
+    g,
+    Q,
+    I
   );
-  A.free(C, 2 * I.length);
-  const { start: g, end: i, capacity: D } = G(A.memory, E), o = new Uint8Array(A.memory.buffer.slice(g, i)), a = new TextDecoder().decode(o);
-  return A.free(g, D), a;
+  if (C.free(B, 2 * g), i < 0)
+    throw new Error("Error decompressing string.");
+  const { start: D, end: a, capacity: t } = w(C.memory, i), F = new Uint8Array(C.memory.buffer.slice(D, a)), k = new TextDecoder().decode(F);
+  return C.free(D, t), k;
 }
 export {
-  Y as compress,
-  s as decompress
+  G as compress,
+  e as decompress
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "smol-string",
-	"version": "0.1.1-beta",
+	"version": "1.0.0",
 	"description": "Compression for browser localStorage",
 	"author": "Senryoku <maretverdant@gmail.com>",
 	"repository": {
@@ -37,22 +37,15 @@
 			"types": "./dist/smol-string.d.ts",
 			"import": "./dist/smol-string.js"
 		},
-		"./packed": {
-			"types": "./dist/smol-string-packed.d.ts",
-			"import": "./dist/smol-string-packed.js"
-		},
 		"./worker": {
 			"types": "./dist/smol-string-worker.d.ts",
 			"import": "./dist/smol-string-worker.js"
-		},
-		"./worker/packed": {
-			"types": "./dist/smol-string-worker-packed.d.ts",
-			"import": "./dist/smol-string-worker-packed.js"
 		}
 	},
 	"devDependencies": {
 		"@vitest/browser": "^0.34.6",
-		"smol-string": "^0.1.0-beta",
+		"binaryen": "^116.0.0",
+		"smol-string": "^0.1.1-beta",
 		"typescript": "^5.2.2",
 		"vite": "^5.0.0",
 		"vite-plugin-dts": "^3.6.2",

package/browser.vitest.config.ts

@@ -1,18 +0,0 @@
-import { defineConfig, mergeConfig } from "vitest/config";
-import viteConfig from "./vite.config";
-
-// Config for tests ran only in browsers.
-// Currently use to tests that interacts with localStorage.
-
-export default mergeConfig(
-	viteConfig,
-	defineConfig({
-		test: {
-			browser: {
-				enabled: true,
-				name: "chrome",
-			},
-			include: ["test/*.test.ts", "test/*.test.browser.ts"],
-		},
-	})
-);

package/dist/smol-string-packed.d.ts

@@ -1,2 +0,0 @@
-export declare function compressPacked(str: string): string;
-export declare function decompressPacked(compressedStr: string): string;

package/dist/smol-string-packed.js

@@ -1,30 +0,0 @@
-import { i as G, c as J, e as k, U as h } from "./wasm-helper-C1VfMvbY.js";
-const F = (A) => G(A, "data:application/wasm;base64,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"), N = await F(), I = N.exports;
-function L(A) {
-  const { ptr: C, length: g } = J(A, I), D = I.compressPacked(C, g);
-  I.free(C, g);
-  const { start: Q, end: B, capacity: i } = k(I.memory, D), w = new Uint16Array(I.memory.buffer.slice(Q, B)), o = h(w);
-  return I.free(Q, i), o;
-}
-function f(A) {
-  const C = (A.charCodeAt(A.length - 1) << 16) + A.charCodeAt(A.length - 2);
-  let g = I.allocUint16(A.length - 2), D = new Uint16Array(
-    I.memory.buffer,
-    g,
-    A.length - 2
-  );
-  for (let E = 0; E < A.length - 2; E++)
-    D[E] = A.charCodeAt(E);
-  const Q = I.decompressPacked(
-    g,
-    A.length - 2,
-    C
-  );
-  I.free(g, 2 * (A.length - 2));
-  const { start: B, end: i, capacity: w } = k(I.memory, Q), o = new Uint8Array(I.memory.buffer.slice(B, i)), a = new TextDecoder().decode(o);
-  return I.free(B, w), a;
-}
-export {
-  L as compressPacked,
-  f as decompressPacked
-};

package/dist/smol-string-worker-packed.d.ts

@@ -1,2 +0,0 @@
-export declare function compressPacked(data: string): Promise<string>;
-export declare function decompressPacked(data: string): Promise<string>;

package/dist/smol-string-worker-packed.js

@@ -1,46 +0,0 @@
-const J = "(async()=>{function k(A,g){const I=new TextEncoder().encode(A),C=g.allocUint8(I.length);return new Uint8Array(g.memory.buffer,C,I.length).set(I),{ptr:C,length:I.length}}function h(A){const g=new Array(A.length);for(let I=0;I<A.length;I++)g[I]=String.fromCharCode(A[I]);return g.join("")}function a(A,g){const I=new Uint32Array(A.buffer.slice(g,g+8)),C=I.at(0),Q=I.at(1);return{start:g-C,end:g,capacity:Q}}var G=async(A={},g)=>{let I;if(g.startsWith("data:")){const C=g.replace(/^data:.*?base64,/,"");let Q;if(typeof Buffer=="function"&&typeof Buffer.from=="function")Q=Buffer.from(C,"base64");else if(typeof atob=="function"){const E=atob(C);Q=new Uint8Array(E.length);for(let i=0;i<E.length;i++)Q[i]=E.charCodeAt(i)}else throw new Error("Failed to decode base64-encoded data URL, Buffer and atob are not supported");I=await WebAssembly.instantiate(Q,A)}else{const C=await fetch(g),Q=C.headers.get("Content-Type")||"";if("instantiateStreaming"in WebAssembly&&Q.startsWith("application/wasm"))I=await WebAssembly.instantiateStreaming(C,A);else{const E=await C.arrayBuffer();I=await WebAssembly.instantiate(E,A)}}return I.instance},f=A=>G(A,"data:application/wasm;base64,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");const J=await f(),B=J.exports;function s(A){const{ptr:g,length:I}=k(A,B),C=B.compressPacked(g,I);B.free(g,I);const{start:Q,end:E,capacity:i}=a(B.memory,C),o=new Uint16Array(B.memory.buffer.slice(Q,E)),w=h(o);return B.free(Q,i),w}function e(A){const g=(A.charCodeAt(A.length-1)<<16)+A.charCodeAt(A.length-2);let I=B.allocUint16(A.length-2),C=new Uint16Array(B.memory.buffer,I,A.length-2);for(let D=0;D<A.length-2;D++)C[D]=A.charCodeAt(D);const Q=B.decompressPacked(I,A.length-2,g);B.free(I,2*(A.length-2));const{start:E,end:i,capacity:o}=a(B.memory,Q),w=new Uint8Array(B.memory.buffer.slice(E,i)),t=new TextDecoder().decode(w);return B.free(E,o),t}self.onmessage=function(A){const{command:g,id:I,data:C}=A.data;switch(g){case"decompress":{self.postMessage({id:I,data:e(C)});break}case"compress":{self.postMessage({id:I,data:s(C)});break}}}})();", l = typeof window < "u" && window.Blob && new Blob(["URL.revokeObjectURL(import.meta.url);" + atob(J)], { type: "text/javascript;charset=utf-8" });
-function V(Q) {
-  let U;
-  try {
-    if (U = l && (window.URL || window.webkitURL).createObjectURL(l), !U)
-      throw "";
-    const F = new Worker(U, {
-      type: "module",
-      name: Q?.name
-    });
-    return F.addEventListener("error", () => {
-      (window.URL || window.webkitURL).revokeObjectURL(U);
-    }), F;
-  } catch {
-    return new Worker(
-      "data:application/javascript;base64," + J,
-      {
-        type: "module",
-        name: Q?.name
-      }
-    );
-  }
-}
-const R = new V();
-let d = 0;
-const B = {};
-R.onmessage = function(Q) {
-  const U = Q.data.id;
-  B[U](Q.data.data), delete B[U];
-};
-async function Z(Q) {
-  const U = d++;
-  return new Promise((F) => {
-    B[U] = F, R.postMessage({ command: "compress", id: U, data: Q });
-  });
-}
-async function W(Q) {
-  const U = d++;
-  return new Promise((F) => {
-    B[U] = F, R.postMessage({ command: "decompress", id: U, data: Q });
-  });
-}
-export {
-  Z as compressPacked,
-  W as decompressPacked
-};

package/dist/wasm-helper-C1VfMvbY.js

@@ -1,56 +0,0 @@
-function o(n, e) {
-  const t = new TextEncoder().encode(n), a = e.allocUint8(t.length);
-  return new Uint8Array(
-    e.memory.buffer,
-    a,
-    t.length
-  ).set(t), { ptr: a, length: t.length };
-}
-function f(n) {
-  const e = new Array(n.length);
-  for (let t = 0; t < n.length; t++)
-    e[t] = String.fromCharCode(n[t]);
-  return e.join("");
-}
-function c(n, e) {
-  const t = new Uint32Array(
-    n.buffer.slice(e, e + 8)
-  ), a = t.at(0), r = t.at(1);
-  return {
-    start: e - a,
-    end: e,
-    capacity: r
-  };
-}
-const l = async (n = {}, e) => {
-  let t;
-  if (e.startsWith("data:")) {
-    const a = e.replace(/^data:.*?base64,/, "");
-    let r;
-    if (typeof Buffer == "function" && typeof Buffer.from == "function")
-      r = Buffer.from(a, "base64");
-    else if (typeof atob == "function") {
-      const s = atob(a);
-      r = new Uint8Array(s.length);
-      for (let i = 0; i < s.length; i++)
-        r[i] = s.charCodeAt(i);
-    } else
-      throw new Error("Failed to decode base64-encoded data URL, Buffer and atob are not supported");
-    t = await WebAssembly.instantiate(r, n);
-  } else {
-    const a = await fetch(e), r = a.headers.get("Content-Type") || "";
-    if ("instantiateStreaming" in WebAssembly && r.startsWith("application/wasm"))
-      t = await WebAssembly.instantiateStreaming(a, n);
-    else {
-      const s = await a.arrayBuffer();
-      t = await WebAssembly.instantiate(s, n);
-    }
-  }
-  return t.instance;
-};
-export {
-  f as U,
-  o as c,
-  c as e,
-  l as i
-};

package/dist/worker-packed.d.ts

@@ -1,5 +0,0 @@
-export type Message = {
-    command: string;
-    id: number;
-    data: string;
-};

package/src/common.ts

@@ -1,39 +0,0 @@
-export function copyToWasmBuffer(
-	str: string,
-	exports: { allocUint8: (size: number) => number; memory: any }
-) {
-	// There's also an 'encodeInto' method to avoid a copy, but by encoding first, we can allocate only exactly what we need.
-	const utf8Str = new TextEncoder().encode(str);
-	const ptrToStr = exports.allocUint8(utf8Str.length);
-	const inBuffer = new Uint8Array(
-		exports.memory.buffer,
-		ptrToStr,
-		utf8Str.length
-	);
-	inBuffer.set(utf8Str); // Copy to WASM buffer.
-
-	return { ptr: ptrToStr, length: utf8Str.length };
-}
-
-// Horrible. Surely we can do better...
-export function Uint16ArraytoString(buf: Uint16Array) {
-	const strBuilder = new Array(buf.length);
-	for (let i = 0; i < buf.length; i++)
-		strBuilder[i] = String.fromCharCode(buf[i]);
-	return strBuilder.join("");
-}
-
-export function extractFooter(memory: WebAssembly.Memory, ptrToFooter: number) {
-	const footer = new Uint32Array(
-		memory.buffer.slice(ptrToFooter, ptrToFooter + 8)
-	);
-	const streamLength = footer.at(0)!;
-	const capacity = footer.at(1)!;
-	const start = ptrToFooter - streamLength;
-
-	return {
-		start,
-		end: ptrToFooter,
-		capacity,
-	};
-}

package/src/smol-string-packed.ts

@@ -1,77 +0,0 @@
-import {
-	Uint16ArraytoString,
-	copyToWasmBuffer,
-	extractFooter,
-} from "./common.js";
-import init from "./module-packed.wasm?init";
-
-type exportsType = {
-	allocUint8: (size: number) => number;
-	allocUint16: (size: number) => number;
-	compressPacked: (ptr: number, length: number) => number;
-	decompressPacked: (
-		ptr: number,
-		length: number,
-		tokenCount: number
-	) => number;
-	free: (ptr: number, length: number) => void;
-	memory: WebAssembly.Memory;
-};
-
-const instance = await init();
-const exports = instance.exports as exportsType;
-
-export function compressPacked(str: string) {
-	const { ptr, length } = copyToWasmBuffer(str, exports);
-
-	const ptrToFooter = exports.compressPacked(ptr, length);
-
-	exports.free(ptr, length);
-
-	//console.log(ptrToFooter);
-
-	const { start, end, capacity } = extractFooter(exports.memory, ptrToFooter);
-
-	//console.log(start, end, capacity / (1024 * 1024));
-
-	// Includes the tokenCount at the end of the stream (2 * u16).
-	const compressed = new Uint16Array(exports.memory.buffer.slice(start, end));
-
-	const r = Uint16ArraytoString(compressed);
-
-	exports.free(start, capacity);
-
-	return r;
-}
-
-export function decompressPacked(compressedStr: string) {
-	const tokenCount =
-		(compressedStr.charCodeAt(compressedStr.length - 1)! << 16) +
-		compressedStr.charCodeAt(compressedStr.length - 2);
-
-	let ptrToCompressed = exports.allocUint16(compressedStr.length - 2);
-	let compressed_buffer = new Uint16Array(
-		exports.memory.buffer,
-		ptrToCompressed,
-		compressedStr.length - 2
-	);
-
-	for (let i = 0; i < compressedStr.length - 2; i++)
-		compressed_buffer[i] = compressedStr.charCodeAt(i);
-
-	const ptrToFooter = exports.decompressPacked(
-		ptrToCompressed,
-		compressedStr.length - 2,
-		tokenCount
-	);
-
-	exports.free(ptrToCompressed, 2 * (compressedStr.length - 2));
-
-	const { start, end, capacity } = extractFooter(exports.memory, ptrToFooter);
-	const content = new Uint8Array(exports.memory.buffer.slice(start, end));
-	const r = new TextDecoder().decode(content);
-
-	exports.free(start, capacity);
-
-	return r;
-}

package/src/smol-string-worker-packed.ts

@@ -1,29 +0,0 @@
-// @ts-expect-error
-import Worker from "./worker-packed.js?worker&inline";
-
-const worker = new Worker();
-
-let nextID = 0;
-const resolver: Record<number, (str: string) => void> = {};
-
-worker.onmessage = function (e: { data: { id: number; data: string } }) {
-	const id = e.data.id;
-	resolver[id](e.data.data);
-	delete resolver[id];
-};
-
-export async function compressPacked(data: string) {
-	const id = nextID++;
-	return new Promise<string>((resolve) => {
-		resolver[id] = resolve;
-		worker.postMessage({ command: "compress", id, data });
-	});
-}
-
-export async function decompressPacked(data: string) {
-	const id = nextID++;
-	return new Promise<string>((resolve) => {
-		resolver[id] = resolve;
-		worker.postMessage({ command: "decompress", id, data });
-	});
-}

package/src/smol-string-worker.ts

@@ -1,29 +0,0 @@
-// @ts-expect-error
-import Worker from "./worker.js?worker&inline";
-
-const worker = new Worker();
-
-let nextID = 0;
-const resolver: Record<number, (str: string) => void> = {};
-
-worker.onmessage = function (e: { data: { id: number; data: string } }) {
-	const id = e.data.id;
-	resolver[id](e.data.data);
-	delete resolver[id];
-};
-
-export async function compress(data: string) {
-	const id = nextID++;
-	return new Promise<string>((resolve) => {
-		resolver[id] = resolve;
-		worker.postMessage({ command: "compress", id, data });
-	});
-}
-
-export async function decompress(data: string) {
-	const id = nextID++;
-	return new Promise<string>((resolve) => {
-		resolver[id] = resolve;
-		worker.postMessage({ command: "decompress", id, data });
-	});
-}

package/src/smol-string.ts

@@ -1,61 +0,0 @@
-import {
-	Uint16ArraytoString,
-	copyToWasmBuffer,
-	extractFooter,
-} from "./common.js";
-import init from "./module.wasm?init";
-
-type exportsType = {
-	allocUint8: (size: number) => number;
-	allocUint16: (size: number) => number;
-	compress: (ptr: number, length: number) => number;
-	decompress: (ptr: number, length: number) => number;
-	free: (ptr: number, length: number) => void;
-	memory: WebAssembly.Memory;
-};
-
-const instance = await init();
-const exports = instance.exports as exportsType;
-
-export function compress(str: string) {
-	const { ptr, length } = copyToWasmBuffer(str, exports);
-
-	const ptrToFooter = exports.compress(ptr, length);
-
-	exports.free(ptr, length);
-
-	const { start, end, capacity } = extractFooter(exports.memory, ptrToFooter);
-
-	const content = new Uint16Array(exports.memory.buffer.slice(start, end));
-	const r = Uint16ArraytoString(content);
-
-	exports.free(start, capacity);
-
-	return r;
-}
-
-export function decompress(compressedStr: string) {
-	const ptrToCompressed = exports.allocUint16(compressedStr.length);
-	const compressed_buffer = new Uint16Array(
-		exports.memory.buffer,
-		ptrToCompressed,
-		compressedStr.length
-	);
-	for (let i = 0; i < compressedStr.length; i++)
-		compressed_buffer[i] = compressedStr.charCodeAt(i);
-
-	const ptrToFooter = exports.decompress(
-		ptrToCompressed,
-		compressedStr.length
-	);
-
-	exports.free(ptrToCompressed, 2 * compressedStr.length);
-
-	const { start, end, capacity } = extractFooter(exports.memory, ptrToFooter);
-	const content = new Uint8Array(exports.memory.buffer.slice(start, end));
-	const r = new TextDecoder().decode(content);
-
-	exports.free(start, capacity);
-
-	return r;
-}

package/src/wasm.d.ts

@@ -1,6 +0,0 @@
-declare module "*.wasm?init" {
-	const initWasm: (
-		options?: WebAssembly.Imports
-	) => Promise<WebAssembly.Instance>;
-	export default initWasm;
-}

package/src/worker-packed.ts

@@ -1,21 +0,0 @@
-import { compressPacked, decompressPacked } from "./smol-string-packed.js";
-
-export type Message = {
-	command: string;
-	id: number;
-	data: string;
-};
-
-self.onmessage = function (e: { data: Message }) {
-	const { command, id, data } = e.data;
-	switch (command) {
-		case "decompress": {
-			self.postMessage({ id, data: decompressPacked(data) });
-			break;
-		}
-		case "compress": {
-			self.postMessage({ id, data: compressPacked(data) });
-			break;
-		}
-	}
-};

package/src/worker.ts

@@ -1,21 +0,0 @@
-import { compress, decompress } from "./smol-string.js";
-
-export type Message = {
-	command: string;
-	id: number;
-	data: string;
-};
-
-self.onmessage = function (e: { data: Message }) {
-	const { command, id, data } = e.data;
-	switch (command) {
-		case "decompress": {
-			self.postMessage({ id, data: decompress(data) });
-			break;
-		}
-		case "compress": {
-			self.postMessage({ id, data: compress(data) });
-			break;
-		}
-	}
-};

package/tsconfig.json

@@ -1,23 +0,0 @@
-{
-	"compilerOptions": {
-		"target": "ES2020",
-		"useDefineForClassFields": true,
-		"module": "ESNext",
-		"lib": ["ESNext", "DOM", "DOM.Iterable"],
-		"skipLibCheck": true,
-
-		/* Bundler mode */
-		"moduleResolution": "bundler",
-		"allowImportingTsExtensions": true,
-		"resolveJsonModule": true,
-		"isolatedModules": true,
-		"noEmit": true,
-
-		/* Linting */
-		"strict": true,
-		"noUnusedLocals": true,
-		"noUnusedParameters": true,
-		"noFallthroughCasesInSwitch": true
-	},
-	"include": ["src"]
-}

package/vite.config.ts

@@ -1,45 +0,0 @@
-/// <reference types="vitest" />
-import { defineConfig } from "vite";
-import dts from "vite-plugin-dts";
-import pkg from "./package.json" assert { type: "json" };
-
-import topLevelAwait from "vite-plugin-top-level-await";
-
-export default defineConfig({
-	build: {
-		lib: {
-			entry: {
-				"smol-string": "./src/smol-string.ts",
-				"smol-string-packed": "./src/smol-string-packed.ts",
-				"smol-string-worker": "./src/smol-string-worker.ts",
-				"smol-string-worker-packed":
-					"./src/smol-string-worker-packed.ts",
-			},
-			formats: ["es"],
-		},
-		rollupOptions: {
-			external: [
-				...Object.keys(pkg["dependencies"] ?? {}), // don't bundle dependencies
-				/^node:.*/, // don't bundle built-in Node.js modules (use protocol imports!)
-			],
-		},
-		target: "esnext",
-	},
-	worker: {
-		format: "es",
-		plugins() {
-			return [
-				topLevelAwait({
-					// The export name of top-level await promise for each chunk module
-					promiseExportName: "__tla",
-					// The function to generate import names of top-level await promise in each chunk module
-					promiseImportName: (i) => `__tla_${i}`,
-				}),
-			];
-		},
-	},
-	plugins: [
-		dts(), // emit TS declaration files
-	],
-	test: {},
-});