smol-string 0.0.0

package/browser.vitest.config.ts

@@ -0,0 +1,18 @@
+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/common.d.ts

@@ -0,0 +1,8 @@
+export declare function copyToWasmBuffer(str: string, exports: {
+    allocUint8: (size: number) => number;
+    memory: any;
+}): {
+    ptr: number;
+    length: number;
+};
+export declare function Uint16ArraytoString(buf: Uint16Array): string;

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

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

package/dist/smol-string-packed.js

@@ -0,0 +1,42 @@
+import { i as w, c as k, U as h } from "./wasm-helper-6790be72.js";
+const a = (I) => w(I, "data:application/wasm;base64,AGFzbQEAAAABUQxgBH9/f38Bf2AFf39/f38AYAZ/f39/f38Bf2ABfwF/YAN/f38AYAJ/fwBgAn9/AX9gAX8AYAR/f39/AGACf38BfmADf39/AX9gBX9+fn5+AAMnJgMEAwQEBQQGAwYGBwUICQAGBwQHBAoABAQGAAQKCAUEAAIBCwoKBAUBcAEEBAUDAQARBg4CfwFBgIDAAAt/AEEACwdQBgZtZW1vcnkCAAphbGxvY1VpbnQ4AAALYWxsb2NVaW50MTYAAgRmcmVlAAUOY29tcHJlc3NQYWNrZWQAEBBkZWNvbXByZXNzUGFja2VkABUJCQEAQQELAyAhIgq2SCZeAQF/I4CAgIAAQRBrIgEkgICAgAAgASOBgICAAEGYgMCAAGopAwA3AwAgAUEIaiABIAAQgYCAgAACQCABLwEMDQAgASgCCCEAIAFBEGokgICAgAAgAA8LA38ADAALC3ECAX8BfiOAgICAAEEQayIDJICAgIAAQoCAgIAQIQQCQEEBRQ0AAkAgAg0AQv////8PIQQMAQsgASgCACACQQBBACABKAIEKAIAEYCAgIAAACICRa1CIIYgAq2EIQQLIAAgBDcCACADQRBqJICAgIAAC1QBAX8jgICAgABBEGsiASSAgICAACABQQRqI4GAgIAAQZiAwIAAaiAAEIOAgIAAAkAgAS8BDA0AIAEoAgQhACABQRBqJICAgIAAIAAPCwN/AAwACwuVAQEBfyOAgICAAEEwayIDJICAgIAAIAMgASkCADcDCCADQRBqIANBCGogAhCEgICAAAJAAkAgAy8BFCIBRQ0AIAMgATsBICADQRhqIQIMAQsgA0EAOwEsIAMgAjYCKCADIAMoAhA2AiQgA0EkaiECCyAAIAIpAgA3AgAgAEEIaiACQQhqKAIANgIAIANBMGokgICAgAALhwECAX8BfiOAgICAAEEQayIDJICAgIAAIAMgAkEASDoADAJAAkAgAkF/Sg0AQoCAgIAQIQQMAQsCQCACQQF0IgINAEL+////DyEEDAELIAEoAgAgAkEBQQAgASgCBCgCABGAgICAAAAiAkWtQiCGIAKthCEECyAAIAQ3AgAgA0EQaiSAgICAAAsZACOBgICAAEGYgMCAAGogACABEIaAgIAACzgBAX8CQCACQQAgAhsiA0UNACAAKAIAIAFBqtWq1XogAhsgA0EAQQAgACgCBCgCCBGBgICAAAALC8ACAQR/AkAgAC0AHCICQRRPDQAgACgCGEGAAmogAhCIgICAAEF/akkNACAAIAJBAWoiAjoAHAsCQAJAA0AgAkH/AXEiA0UNASAAKAIEIQQCQAJAIAAtAB0iBUEQRg0AIAQNAQsCQCAAKAIIIgUgBEsNACAAIAUgBEEBahCJgICAABCKgICAACIEQf//A3ENBCAAKAIEIQQLIAAgBEEBajYCBEEAIQUgACgCACAEQQF0akEAOwEAIABBADoAHSAAKAIEIQQLIARBAXQgACgCAGpBfmoiBCAELwEAIAFBFCACa0H/AXF0Qf//P3EgBUEEanZyOwEAIAAgAC0AHSADQRAgBWtB/wFxIgQgAyAESRsiBGo6AB0gAiAEayECDAALCyAAIAAoAhRBAWo2AhQgACAAKAIYQQFqNgIYQQAhBAsgBAvLAQIEfwF+I4CAgIAAQRBrIgEkgICAgAACQAJAIAANAEEBIQIMAQtBASEDQQIhBANAAkACQCAAQQJJDQAgAEEBcUUNAUEAIQIgASADrSAErX4iBUIgiKciA0EARzoABCADDQMgBachAwwBCyABIAOtIAStfiIFQiCIpyIAQQBHOgAMQQAgBacgABshAgwCC0EAIQIgASAErSIFIAV+IgVCIIinIgRBAEc6AAggBA0BIAWnIQQgAEEBdiEADAALCyABQRBqJICAgIAAIAILJQEBfwNAQX8gAEEBdiAAakEIaiICIAIgAEkbIgAgAUkNAAsgAAvtAQEFfyOAgICAAEEQayICJICAgIAAQQAhAwJAIAAoAggiBCABTw0AIAAoAgAhBQJAAkAgBEUNACACIAFBAEg6AAggAUF/TA0AIAAoAgwgBSAEQQF0QQEgAUEBdEEAIABBEGooAgAoAgQRgoCAgAAAQQFxRQ0AIAAgATYCCAwBCyACIABBDGoiBikCADcDACACQQhqIAIgARCEgICAACACLwEMIgMNASACKAIIIAAoAgAgACgCBEEBdBClgICAACEDIAYgBSAEEJKAgIAAIAAgATYCCCAAIAM2AgALQQAhAwsgAkEQaiSAgICAACADCw8AIAAgAEEMahCMgICAAAtlAQN/AkAgACgCACICRQ0AAkAgAkF0aiIDQQhqKAIAQQ1sQQ9qQXxxIgJBACACGyIERQ0AIAEoAgAgA0EEIAIbIARBAkEAIAEoAgQoAggRgYCAgAAACyAAQQA2AgggAEEANgIACwuBAwQEfwF+BH8BfiOAgICAAEEQayIEJICAgIAAI4GAgIAAIQUgASgCACEGAkACQCABKAIEDQAgBUGAgMCAAGohBwwBCyACIAMQjoCAgAAhCAJAAkAgBg0AQQAhBUF/IQkMAQsgBkF8aigCACIFQX9qIQkLIAZBeGohCiAJIAincSEBIAhCOYinIQsDQCOBgICAAEGAgMCAAGohByAGIAFqLAAAIgxFDQEgBUUNAQJAIAxBf0oNACALIAxB/wBxRw0AIAIgAyAKKAIAIAFBA3RqIgwoAgAgDCgCBBCPgICAAEEBcUUNACAEQQE6AAwgBCABNgIIIARBCGohBwwCCyAFQX9qIQUgAUEBaiAJcSEBDAALCwJAAkAgBy0ABA0AQgAhCEIAIQ0MAQsgBCAGQXRqKAIAIAcoAgBBAnRqIgFBAmotAABBD3E6AAIgBCABLwEAOwEAIAQzAQAgBDEAAkIQhoQhCEKAgICAECENCyAAIA0gCIQ3AgAgBEEQaiSAgICAAAvsBQUCfwF+AX8CfgJ/I4CAgIAAQeAAayICJICAgIAAAkACQAJAAkACQCABQRBLDQAgAUEDTQ0BIAA1AABCIIYgACABQQF2Qfz///8HcSIDajUAAIQhBCAAIAFBfGoiBWo1AABCIIYgACAFIANrajUAAIQhBkKsmuLTo9Lw+h8hBwwEC0EAIQNCrJri06PS8PofIQdBACEFIAFBMEkNAkEAIQVCrJri06PS8PofIQdCrJri06PS8PofIQRCrJri06PS8PofIQYDQCAFQTBqIgggAU8NAiACQcAAaiAAIAVqIgUpAAggBoVCACAFKQAAQtvR0IWa2t+BZ4VCABCjgICAACACQTBqIAVBGGopAAAgBIVCACAFQRBqKQAAQuONo+SJ3prejn+FQgAQo4CAgAAgAkEgaiAFQShqKQAAIAeFQgAgBUEgaikAAELDmd2px7nZzNgAhUIAEKOAgIAAIAJBwABqQQhqKQMAIAIpA0CFIQYgAkEgakEIaikDACACKQMghSEHIAJBMGpBCGopAwAgAikDMIUhBCAIIQUMAAsLQgAhBkKsmuLTo9Lw+h8hBwJAIAENAEIAIQQMAwsgACABQQF2ajEAAEIIhiAAMQAAQhCGhCABIABqQX9qMQAAhCEEDAILIAQgB4UgBoUhBwsgACAFaiEJIAEgBWshCAJAA0AgA0EQaiIFIAhPDQEgAkHQAGogCSADaiIDQQhqKQAAIAeFQgAgAykAAELb0dCFmtrfgWeFQgAQo4CAgAAgAkHQAGpBCGopAwAgAikDUIUhByAFIQMMAAsLIAEgAGoiA0F4aikAACEGIANBcGopAAAhBAsgAkEQaiAEQtvR0IWa2t+BZ4VCACAGIAeFQgAQo4CAgAAgAiACQRBqQQhqKQMAQtvR0IWa2t+BZ4VCACABrSACKQMQhUKvyPXFx6yHu6B/hUIAEKOAgIAAIAJBCGopAwAhByACKQMAIQQgAkHgAGokgICAgAAgByAEhQtYAQJ/QQAhBAJAIAEgA0cNAAJAIAAgAkcNAEEBDwsDQCABRSEEIAFFDQEgAUF/aiEBIAItAAAhAyAALQAAIQUgAEEBaiEAIAJBAWohAiAFIANGDQALCyAEC8cUBAJ/AX4efwF+I4CAgIAAQfABayICJICAgIAAIAJBMGpBCGoiA0EANgIAIAJCADcDMCACI4GAgIAAQZiAwIAAaikDACIENwI8IAIgBDcCxAEgAkEANgLAASACQqrVqtUKNwK4AQJAAkACQAJAIAJBuAFqIAEQioCAgABB//8DcQ0AIAJBMGpBDGohBSACQcgAakEQaiACQbgBakEQaigCADYCACACQcgAakEIaiACQbgBakEIaiIGKQIANwMAIAIgAikCuAE3A0ggAkEJOwFkIAJCADcCXCAEQiCIpyEHIASnIQhBgAIhCUEAIQoDQCAAIApqIQtBACEMAkACQAJAAkACQAJAAkACQAJAA0ACQAJAIAxBAmoiDSAKaiABTw0AIAJB6ABqIAJBMGogCyANEI2AgIAAIAItAGwNASACKAIwIQ4gAigCOA0GAkACQCAODQBBASEPDAELIA5BfGooAgCtQtAAfiIEIARC5ACCfULkAHxC0ACApyEPC0EAIRAgBkEANgIAIAJCADcDuAFBAA0FAkACQEIBQSAgD2drrUL//wODhqciD0EIIA9BCEsbIhFBD2oiEiARQQN0aiITIBFBAnRqQXxxIg8NAEF8IQ8MAQtBACEQIAggD0ECQQAgBygCABGAgICAAAAiD0UNBgsgD0EIaiIUIBE2AgAgDyAPIBJBfHFqNgIEIA8gDyATQXxxajYCACACIA9BDGoiDzYCuAEgD0EAIBEQpICAgAAhECACIBGtQtAAfkLkAICnIhU2AsABIAIoAjQiFkUNBEEAIRdBACEYAkAgDkUNACAOQXxqKAIAIRgLIBBBdGohGSAQQXhqIRogDkF0aiIPKAIAIRsgD0EEaigCACEcQQAhHQNAIB0gGEYNBAJAIA4gHWosAABBAE4NACAbIB1BAnRqIg9BAmotAABBEHQhHiAPLwEAIR8gHCAdQQN0aiIPKAIEISAgDygCACEhAkAgF0UNACAhICAQjoCAgAAhBCAUKAIAIhFBf2oiEyAEp3EhDyAEQjmIpyEiA0AgECAPaiwAACISRQ0BIBFFDQECQCASQX9KDQAgIiASQf8AcUcNACAhICAgGigCACAPQQN0aiISKAIAIBIoAgQQj4CAgABBAXFFDQAgAkEBOgDsAQwCCyARQX9qIREgD0EBaiATcSEPDAALCyAfIB5yIRMgISAgEI6AgIAAIQQgFCgCAEF/aiISIASncSEPAkADQCAQIA9qIhEsAABBf0oNASAPQQFqIBJxIQ8MAAsLIBEgBEI5iKdBgAFyOgAAIBooAgAgD0EDdGoiESAgNgIEIBEgITYCACAZKAIAIA9BAnRqIg8gEzsBACAPQQJqIBNBgIA8cUEQdjoAACAVQX9qIRUgF0EBaiIXIBZHDQAgFiEXDAULIB1BAWohHQwACwsCQAJAIApBAWogAUkNACACQcgAaiALLQAAEIeAgIAAQf//A3ENDgwBCyACQfgAakEQaiACQTBqQRBqKAIANgIAIAJB+ABqQQhqIAJBMGpBCGopAwA3AwAgAiACKQMwNwN4IAJBkAFqIAJB+ABqIAsgDEECahCNgICAAAJAIAItAJQBDQACQAJAIAwNACALLQAAIQ0MAQsgAkGYAWpBEGogAkEwakEQaigCADYCACACQZgBakEIaiACQTBqQQhqKQMANwMAIAIgAikDMDcDmAEgAkGwAWogAkGYAWogCyAMQQFqEI2AgIAAIAIvAbABIAItALIBQRB0ciENCyACQcgAaiANEIeAgIAAQf//A3ENDiACQcgAaiALIAxqQQFqLQAAEIeAgIAAQf//A3FFDQEMDgsgAkHIAGogAi8BkAEgAi0AkgFBEHRyEIeAgIAAQf//A3ENDQsgAkEwahCLgICAACACQRhqIAJByABqQRhqKQMANwMAIAJBEGogAkHIAGpBEGopAwA3AwAgAkEIaiACQcgAakEIaikDADcDACACIAIpA0g3AwAgAkEkaiOBgICAAEGYgMCAAGogAigCBCIMQQRqEIOAgIAAAkAgAi8BLA0AIAIoAiQiECACKAIoQRB4NgEAIBAgAigCFEEQeDYBBCAQQQhqIQ0gAigCACEPAkADQCAMRQ0BIA0gDy8BADsBACAMQX9qIQwgDUECaiENIA9BAmohDwwACwsgAhCRgICAAAwQCyACEJGAgIAADA4LIAxBAWohDAwACwsgAiAVNgLAASACIBc2ArwBCyADKAIAIQ8gAyAGKAIANgIAIAYgDzYCACACQQA2AjQgAikDMCEEIAIgAikDuAEiIzcDMCACIAQ3A7gBICOnIQ5BASEQCyACQbgBaiAFEIyAgIAAIBANACOBgICAACEPIAIoAjQNASAPQYCAwIAAaiESDAMLIAsgDRCOgICAACEEAkACQCAODQAgBKchD0EAIRJBfyEdDAELIA5BfGooAgAiEkF/aiIdIASncSEPCyAOQXhqISAgDkF8aiEhIARCOYinISIgEiEQA0AgDiAPaiITLAAAIhFFDQIgEEEARg0CAkACQCARQX9KDQAgIiARQf8AcUcNACALIA0gICgCACAPQQN0aiIRKAIAIBEoAgQQj4CAgABBAXFFDQEMBgsgEiAhKAIARw0AIA8gEiARQQFGGyESCyAQQX9qIRAgD0EBaiAdcSEPDAALCyALIA0QjoCAgAAhBAJAAkAgDg0AQQAhEEF/IRMMAQsgDkF8aigCACIQQX9qIRMLIA5BeGohIiATIASncSEPIARCOYinIR0DQCOBgICAAEGAgMCAAGohEiAOIA9qLAAAIhFFDQIgEEUNAgJAIBFBf0oNACAdIBFB/wBxRw0AIAsgDSAiKAIAIA9BA3RqIhEoAgAgESgCBBCPgICAAEEBcUUNACACQQE6ANABIAIgDzYCzAEgAkHMAWohEgwDCyAQQX9qIRAgD0EBaiATcSEPDAALCyAhKAIAIRAgAiACKAI4QX9qNgI4IA4gEmogEyASIBBJIhAbICJBgAFyOgAAIA5BdGooAgAhESAgKAIAIRMgAiACKAI0QQFqNgI0IBMgEiAPIBAbIg9BA3RqIhAgDTYCBCAQIAs2AgAgESAPQQJ0aiENDAILIBItAARFDQQgEigCACEPCyAOQXRqKAIAIA9BAnRqIQ0LIA0gCTsBACANQQJqIAlBgIA8cUEQdjoAAAJAAkAgDA0AIAstAAAhDQwBCyACQfAAaiACQTBqIAsgDEEBahCNgICAACACLwFwIAItAHJBEHRyIQ0LIAJByABqIA0Qh4CAgABB//8DcQ0BIAogDGpBAWohCiAJQQFqIglB//8/cUH//z9HDQAgDkEAIA5BfGooAgAiDBCkgICAABogAkEANgI0IAIgDK1C0AB+QuQAgD4COCACQcgAakH//z8Qh4CAgABB//8DcQ0BIAJBADYCYCACQQk6AGRBgAIhCQwACwsgAkEwahCLgICAAAwBCyACQTBqEIuAgIAAC0EAIRALIAJB8AFqJICAgIAAIBALPwEBfyOAgICAAEEQayIBJICAgIAAIAEgACkCDDcDCCABQQhqIAAoAgAgACgCCBCSgICAACABQRBqJICAgIAACzcBAX8CQCACQQF0QQAgAhsiA0UNACAAKAIAIAFBAiACGyADQQFBACAAKAIEKAIIEYGAgIAAAAsLPwEBfyOAgICAAEEQayIBJICAgIAAIAEgACkCDDcDCCABQQhqIAAoAgAgACgCCBCUgICAACABQRBqJICAgIAACzcBAX8CQCACQQN0QQAgAhsiA0UNACAAKAIAIAFBBCACGyADQQJBACAAKAIEKAIIEYGAgIAAAAsL3wsDAX8Bfgt/I4CAgIAAQdAAayIDJICAgIAAIANBADYCPCADQqrVqtUKNwI0IAMjgYCAgABBmIDAgABqKQMAIgQ3AkACQAJAAkACQCACDQBBqtWq1XohBUEAIQYMAQtBqtWq1XohBSACIQYgA0HAAGoiB0Gq1arVekEAIAIQloCAgABBAXENACADQSBqIAcgAhCXgICAACADLwEoDQEgAygCJCEGIAMoAiAhBQtBCSEIQQAhCUEAIQpBACELQQAhDANAAkACQAJAAkAgDCACRg0AIAhB/wFxIgdBFEkNAQwDCyADIAQ3A0gCQAJAIANByABqIAUgBiACEJaAgIAAQQFxRQ0AIAUhCAwBCyADQTRqIANByABqIAIQl4CAgAAgAy8BPA0FIAMoAjQiCCAFIAMoAjgiAkECdBClgICAABogAyAENwMgIANBIGogBSAGEJiAgIAACyADQQA2AiggA0Kq1arVCjcCICADIAQ3AiwgA0EAQf//PxCJgICAACIHQf////8BSzoANCAHQYCAgIACTw0BAkACQCAHQQN0Ig0NAEF8IQ0MAQsgBKcgDUECQQAgBEIgiKcoAgARgICAgAAAIg1FDQILIAMgBzYCKCADIA02AiBBACEHAkADQCAHQfj//wNGDQEgDSAHakIANwIAIAdBCGohBwwACwsgA0H//z82AiQgAyAENwJAQQAhByADQQA2AjwgA0Kq1arVCjcCNCADQTRqIAJBFGwQmYCAgABB//8DcQ0BIAMpAkAhBCADKAI8IQsgAygCNCIAIAMoAjgiCWogCC0AADoAACANIAgvAQAgCEECai0AAEEQdHJBA3RqIg5BATYCBCAOIAA2AgAgCUEBaiEPQYACIQpBASEJA0AgDyEOAkACQAJAAkAgCSACTw0AAkAgCCAJQQJ0aiIPLwEAIA9BAmotAABBEHRyIg9B//8/Rw0AIAlBAWoiCSACTw0BQQAhBwJAA0AgB0H4//8DRg0BIA0gB2pCADcCACAHQQhqIQcMAAsLAkAgCCAJQQJ0aiIHLwEAIAdBAmotAABBEHRyIgdBgAJJDQAgA0H//z82AiQMCAsgACAOaiAHOgAAIA5BAWohD0GAAiEKDAQLIA9BgAJJDQECQCANIA9BA3RqIg8oAgAiDA0AIAAgDmogACAHaiIPIA4gB2siDBClgICAABogACAMIA5qIgxqIA8tAAA6AAAgDEEBaiEPDAMLIAAgDmogDCAPKAIEIg8QpYCAgAAaIA8gDmohDwwCCyADQf//PzYCJCADQSBqEJOAgIAAIAMgBDcCGCADIAs2AhQgAyAANgIMIAMgDjYCEEEAIQcgA0EMaiAOQQFqEJmAgIAAQf//A3ENCSADKAIMIg0gAygCECIHakEAOgAAIAMoAhQhCSADIAMpAhgiBDcDSAJAIANByABqIA0gCSAHQQFqIgcQmoCAgABBAXFFDQAgDSEHDAoLIANBNGogA0HIAGogBxCbgICAACADLwE8DQggAygCNCIHIA0gAygCOBClgICAABogAyAENwMgIANBIGogDSAJEIaAgIAADAkLIAAgDmogDzoAACAOQQFqIQ8LIA0gCkH//z9xQQN0aiIMIA4gB2tBAWo2AgQgDCAAIAdqNgIAIApBAWohCgsgCUEBaiEJIA4hBwwACwsgCCALQYACaiAHEIiAgIAAQX9qT2ohCAwBCyADQSBqEJOAgIAADAILQQAhDiAIIQcCQANAIAdB/wFxIg1FDQEgACAKIAlB/wFxQRBGIg9qIgpBAXRqLwEAQQAgCSAPGyIJQQ9xdEH//wNxQQAgDUEQIAlrQf8BcSIPIA0gD0kbIg1rQQ9xdiAHIA1rIgd0IA5yIQ4gDSAJaiEJDAALCyAFIAxBAnRqIgcgDjsBACAHQQJqIA5B//8/cSIHQRB2OgAAQQAgC0EBaiAHQf//P0YiBxshC0EJIAggBxshCCAMQQFqIQwMAAsLQQAhBwsgA0HQAGokgICAgAAgBwuQAQECfyOAgICAAEEQayIEJICAgIAAAkACQCADDQAgBCAAKQIANwMAIAQgASACEJiAgIAAQQEhBQwBC0EAIQUgAkUNACAEIANB/////wNLOgAMIANBgICAgARPDQAgACgCACABIAJBAnRBAiADQQJ0QQAgACgCBCgCBBGCgICAAAAhBQsgBEEQaiSAgICAACAFC8EBAgF/AX4jgICAgABBIGsiAySAgICAACABKQIAIQQgAyACQf////8DSzoAHAJAAkAgAkGAgICABE8NAAJAAkAgAkECdCIBDQBBfCEBDAELIASnIAFBAkEAIARCIIinKAIAEYCAgIAAACIBRQ0BCyADIAI2AhQgAyABNgIQIANBADsBGCADQRBqIQIMAQsgA0EBOwEMIANBBGohAgsgACACKQIANwIAIABBCGogAkEIaigCADYCACADQSBqJICAgIAACzcBAX8CQCACQQJ0QQAgAhsiA0UNACAAKAIAIAFBBCACGyADQQJBACAAKAIEKAIIEYGAgIAAAAsLqQEBBX8jgICAgABBEGsiAiSAgICAAEEAIQMCQCAAKAIIIgQgAU8NAAJAIABBDGoiBSAAKAIAIgYgBCABEJqAgIAAQQFxDQAgAkEEaiAFIAEQm4CAgAAgAi8BDCIDDQEgAigCCCEBIAIoAgQgACgCACAAKAIEEKWAgIAAIQMgBSAGIAQQhoCAgAAgACADNgIACyAAIAE2AghBACEDCyACQRBqJICAgIAAIAMLdQECfyOAgICAAEEQayIEJICAgIAAAkACQCADDQAgBCAAKQIANwMAIAQgASACEIaAgIAAQQEhBQwBC0EAIQUgAkUNAEEADQAgACgCACABIAJBACADQQAgACgCBCgCBBGCgICAAAAhBQsgBEEQaiSAgICAACAFC5UBAQF/I4CAgIAAQTBrIgMkgICAgAAgAyABKQIANwMIIANBEGogA0EIaiACEIGAgIAAAkACQCADLwEUIgFFDQAgAyABOwEgIANBGGohAgwBCyADQQA7ASwgAyACNgIoIAMgAygCEDYCJCADQSRqIQILIAAgAikCADcCACAAQQhqIAJBCGooAgA2AgAgA0EwaiSAgICAAAvSAgMGfwF+B38jgICAgABBEGsiAySAgICAACAAKAIEIQQgACgCACEFQQAhBiACQf8BcSEHA38CQAJAAkAgBiAERw0AQX8hCAwBCwJAIAUgBkEEdGoiAkEIaikDACIJQgBTDQAgAikDAHsgCXt8pyABSQ0CCyAGQQd0IghBgAFqIQoDQCAIIApPDQIgCCAAKQIAIglCGYinQYB/cSICIAggAksbIgsgCGshDCAJp0EIIAlCIIinGyENIAhBEHRoIQ5BACECAkADQAJAIAwgAkcNACALIQ8MAgtB/wEgCCACaiIPQQdxIhBBB3N2QQEgEHRxIA0gD0EDdmotAABxRQ0BIAJBAWoiAiABSQ0AIA4gB0kNAAsgAyAJNwMIIANBCGogCCABQQAQnYCAgAAMAgsgD0EBaiEIDAALCyADQRBqJICAgIAAIAgPCyAGQQFqIQYMAAsLVAEBfyADQQFxIQQCQANAIAJFDQEgACgCAEEIIAAoAgQbIAFBA3ZqIgMgAy0AAEF+IAFBB3EiA3dxIAQgA3RyOgAAIAFBAWohASACQX9qIQIMAAsLC9sBAQN/I4CAgIAAQRBrIgIkgICAgAACQCAAQYAQTw0AI4GAgIAAQaiAwIAAaiAAIAFBgBAgAUGAEEkbIABrEJ+AgIAACwJAIAFBgBBNDQACQCOBgICAAEGggMCAAGooAgQNACOBgICAAEGggMCAAGoiA0GAIDYCBCADIAFBf2oiAUEQdCIENgIAIARBAEGAgAQQpICAgAAaCyACI4GAgIAAQaCAwIAAaikDADcDCCACQQhqIABBgBAgAEGAEEsbIgBBgHBqIAEgAGsQn4CAgAALIAJBEGokgICAgAALOwEBfyOAgICAAEEQayIDJICAgIAAIAMgACkCADcDCCADQQhqIAEgAkEBEJ2AgIAAIANBEGokgICAgAALvQEBBH9BACEEAkAgAUGBgHxPDQACQCOBgICAAEGogMCAAGogAUH//wNqQRB2IgEgAhCcgICAACIEQX9HDQACQCOBgICAAEGggMCAAGogASACEJyAgIAAIgRBf0YNACAEQYAQaiEEDAELQQAhBEEBIAJ0IgU/ACIGQRB0IgJqQX9qQQAgBWtxIgUgAmtBEHYiByABakAAQQFIDQEgByAGaiEEIAUgAkYNACAGIAQQnoCAgAALIARBEHQhBAsgBAtPAQF/AkAgAkH//wNqIgZBgIB8cSAETyICRQ0AIARB//8DakEQdiIEIAZBEHYiBkYNACAEIAFB//8DakEQdiIBaiABIAZqEJ6AgIAACyACCyEAIAFB//8DakEQdiIBIAEgAkH//wNqQRB2ahCegICAAAt1AQF+IAAgBCABfiACIAN+fCADQiCIIgIgAUIgiCIEfnwgA0L/////D4MiAyABQv////8PgyIBfiIFQiCIIAMgBH58IgNCIIh8IANC/////w+DIAIgAX58IgFCIIh8NwMIIAAgAUIghiAFQv////8Pg4Q3AwALLAEBfwJAIAJFDQAgACEDA0AgAyABOgAAIANBAWohAyACQX9qIgINAAsLIAALQgEBfwJAIAJFDQAgAkF/aiECIAAhAwNAIAMgAS0AADoAACACRQ0BIAJBf2ohAiABQQFqIQEgA0EBaiEDDAALCyAACwtBAgBBgIDAAAsIAAAAAAAAAAAAQYiAwAALKAEAAAACAAAAAwAAAAAAAAAAAAAACAAQAKqqqqoAAAAAMAAQABAAAAA="), N = await a(), A = N.exports;
+function F(I) {
+  const { ptr: E, length: g } = k(I, A), Q = A.compressPacked(E, g);
+  A.free(E, g);
+  const C = new Uint16Array(
+    A.memory.buffer.slice(
+      Q,
+      Q + (A.memory.buffer.byteLength - Q)
+    )
+  ), B = (C.at(0) << 16) + C.at(1), D = C.slice(2, B), o = h(D);
+  return A.free(Q, B), o;
+}
+function y(I) {
+  const E = (I.charCodeAt(0) << 16) + I.charCodeAt(1);
+  let g = A.allocUint16(I.length - 2), Q = new Uint16Array(
+    A.memory.buffer,
+    g,
+    I.length - 2
+  );
+  for (let i = 2; i < I.length; i++)
+    Q[i - 2] = I.charCodeAt(i);
+  const C = A.decompressPacked(
+    g,
+    I.length,
+    E
+  );
+  A.free(g, I.length);
+  const B = new Uint8Array(
+    A.memory.buffer.slice(
+      C,
+      C + (A.memory.buffer.byteLength - C)
+    )
+  ), D = B.indexOf(0), o = new TextDecoder().decode(
+    B.slice(0, D)
+  );
+  return A.free(C, D + 1), o;
+}
+export {
+  F as compressPacked,
+  y as decompressPacked
+};

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

@@ -0,0 +1,2 @@
+export declare function compress(data: string): Promise<unknown>;
+export declare function decompress(data: string): Promise<unknown>;

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

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

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

@@ -0,0 +1,2 @@
+export declare function compress(data: string): Promise<unknown>;
+export declare function decompress(data: string): Promise<unknown>;

package/dist/smol-string-worker.js

@@ -0,0 +1,37 @@
+const J = "function D(I, C) {
  const A = new TextEncoder().encode(I), g = C.allocUint8(A.length + 1), Q = new Uint8Array(
    C.memory.buffer,
    g,
    A.length + 1
  );
  return Q.set(A), Q[A.length] = 0, { ptr: g, length: A.length + 1 };
}
function a(I) {
  const C = new Array(I.length);
  for (let A = 0; A < I.length; A++)
    C[A] = String.fromCharCode(I[A]);
  return C.join("");
}
var e = 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;
}, t = (I) => e(I, "data:application/wasm;base64,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");
const s = await t(), B = s.exports;
function w(I) {
  const { ptr: C, length: A } = D(I, B), g = B.compress(C);
  B.free(C, A);
  const Q = new Uint16Array(
    B.memory.buffer.slice(
      g,
      g + (B.memory.buffer.byteLength - g)
    )
  ), E = Q.indexOf(0), i = Q.slice(0, E), o = a(i);
  return B.free(g, E + 1), o;
}
function F(I) {
  const C = B.allocUint16(
    I.length + 1
  ), A = new Uint16Array(
    B.memory.buffer,
    C,
    I.length + 1
  );
  for (let o = 0; o < I.length; o++)
    A[o] = I.charCodeAt(o);
  A[I.length] = 0;
  const g = B.decompress(
    C
  );
  B.free(C, I.length + 1);
  const Q = new Uint8Array(
    B.memory.buffer.slice(
      g,
      g + (B.memory.buffer.byteLength - g)
    )
  ), E = Q.indexOf(0);
  return B.free(g, E + 1), new TextDecoder().decode(
    Q.slice(0, E)
  );
}
onmessage = async function(I) {
  const { command: C, id: A, data: g } = I.data;
  switch (C) {
    case "decompress": {
      postMessage({ id: A, data: F(g) });
      break;
    }
    case "compress": {
      postMessage({ id: A, data: w(g) });
      break;
    }
  }
};
", V = typeof window < "u" && window.Blob && new Blob([atob(J)], { type: "text/javascript;charset=utf-8" });
+function d() {
+  let U;
+  try {
+    if (U = V && (window.URL || window.webkitURL).createObjectURL(V), !U)
+      throw "";
+    return new Worker(U);
+  } catch {
+    return new Worker("data:application/javascript;base64," + J, { type: "module" });
+  } finally {
+    U && (window.URL || window.webkitURL).revokeObjectURL(U);
+  }
+}
+const R = new d();
+let l = 0;
+const Q = {};
+R.onmessage = function(U) {
+  console.log("onmessage", U);
+  const F = U.data.id;
+  Q[F](U.data.data), delete Q[F];
+};
+async function S(U) {
+  const F = l++;
+  return console.log("compress", F), new Promise((B) => {
+    Q[F] = B, R.postMessage({ command: "compress", id: F, data: U });
+  });
+}
+async function Z(U) {
+  const F = l++;
+  return console.log("decompress", F), new Promise((B) => {
+    Q[F] = B, R.postMessage({ command: "decompress", id: F, data: U });
+  });
+}
+export {
+  S as compress,
+  Z as decompress
+};

package/dist/smol-string.d.ts

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

package/dist/smol-string.js

@@ -0,0 +1,42 @@
+import { i as o, c as F, U as G } from "./wasm-helper-6790be72.js";
+const w = (I) => o(I, "data:application/wasm;base64,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"), a = await w(), A = a.exports;
+function h(I) {
+  const { ptr: C, length: i } = F(I, A), g = A.compress(C);
+  A.free(C, i);
+  const B = new Uint16Array(
+    A.memory.buffer.slice(
+      g,
+      g + (A.memory.buffer.byteLength - g)
+    )
+  ), E = B.indexOf(0), D = B.slice(0, E), Q = G(D);
+  return A.free(g, E + 1), Q;
+}
+function J(I) {
+  const C = A.allocUint16(
+    I.length + 1
+  ), i = new Uint16Array(
+    A.memory.buffer,
+    C,
+    I.length + 1
+  );
+  for (let Q = 0; Q < I.length; Q++)
+    i[Q] = I.charCodeAt(Q);
+  i[I.length] = 0;
+  const g = A.decompress(
+    C
+  );
+  A.free(C, I.length + 1);
+  const B = new Uint8Array(
+    A.memory.buffer.slice(
+      g,
+      g + (A.memory.buffer.byteLength - g)
+    )
+  ), E = B.indexOf(0);
+  return A.free(g, E + 1), new TextDecoder().decode(
+    B.slice(0, E)
+  );
+}
+export {
+  h as compress,
+  J as decompress
+};

package/dist/wasm-helper-6790be72.js

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

package/dist/worker-packed.d.ts

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

package/dist/worker.d.ts

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

package/package.json

@@ -0,0 +1,62 @@
+{
+	"name": "smol-string",
+	"version": "0.0.0",
+	"description": "Compression for browser localStorage",
+	"author": "Senryoku <maretverdant@gmail.com>",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/Senryoku/smol-string.git"
+	},
+	"license": "MIT",
+	"keywords": [
+		"compression",
+		"browser",
+		"localStorage",
+		"zig",
+		"typescript"
+	],
+	"bugs": {
+		"url": "https://github.com/Senryoku/smol-string/issues"
+	},
+	"homepage": "https://github.com/Senryoku/smol-string",
+	"type": "module",
+	"scripts": {
+		"dev": "vite",
+		"build": "tsc && vite build",
+		"preview": "vite preview",
+		"test": "vitest",
+		"test:chrome": "vitest --browser.name=chrome --browser.headless --config browser.vitest.config.ts",
+		"test:firefox": "vitest --browser.name=firefox --browser.headless --config browser.vitest.config.ts",
+		"test:edge": "vitest --browser.name=edge --browser.headless --config browser.vitest.config.ts",
+		"test:safari": "vitest --browser.name=safari --browser.headless --config browser.vitest.config.ts",
+		"bench": "vitest bench"
+	},
+	"main": "./dist/smol-string.js",
+	"exports": {
+		".": {
+			"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",
+		"typescript": "^5.2.2",
+		"vite": "^4.4.5",
+		"vitest": "^0.34.6",
+		"webdriverio": "^8.20.4",
+		"vite-plugin-dts": "^3.6.2"
+	},
+	"dependencies": {}
+}

package/src/common.ts

@@ -0,0 +1,25 @@
+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 con allocate only exactly what we need.
+	const utf8Str = new TextEncoder().encode(str);
+	const ptrToStr = exports.allocUint8(utf8Str.length + 1);
+	const inBuffer = new Uint8Array(
+		exports.memory.buffer,
+		ptrToStr,
+		utf8Str.length + 1
+	);
+	inBuffer.set(utf8Str); // Copy to WASM buffer.
+	inBuffer[utf8Str.length] = 0; // null terminate it.
+
+	return { ptr: ptrToStr, length: utf8Str.length + 1 };
+}
+
+// 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("");
+}

package/src/smol-string-packed.ts

@@ -0,0 +1,83 @@
+import { Uint16ArraytoString, copyToWasmBuffer } 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: any;
+};
+
+const instance = await init();
+const exports = instance.exports as exportsType;
+
+export function compressPacked(str: string) {
+	const { ptr, length } = copyToWasmBuffer(str, exports);
+
+	const ptrToCompressed = exports.compressPacked(ptr, length);
+
+	exports.free(ptr, length);
+
+	const buffer = new Uint16Array(
+		exports.memory.buffer.slice(
+			ptrToCompressed,
+			ptrToCompressed +
+				(exports.memory.buffer.byteLength - ptrToCompressed)
+		)
+	);
+	const streamLength = (buffer.at(0)! << 16) + buffer.at(1)!;
+	// Includes the tokenCount at the start of the stream (2 * u16).
+	const compressedBuffer = buffer.slice(2, streamLength);
+
+	const compressed = Uint16ArraytoString(compressedBuffer);
+
+	exports.free(ptrToCompressed, streamLength);
+
+	return compressed;
+}
+
+export function decompressPacked(compressedStr: string) {
+	const tokenCount =
+		(compressedStr.charCodeAt(0)! << 16) + compressedStr.charCodeAt(1);
+
+	let ptrToCompressed = exports.allocUint16(compressedStr.length - 2);
+	let compressed_buffer = new Uint16Array(
+		exports.memory.buffer,
+		ptrToCompressed,
+		compressedStr.length - 2
+	);
+
+	for (let i = 2; i < compressedStr.length; i++)
+		compressed_buffer[i - 2] = compressedStr.charCodeAt(i);
+
+	const ptrToDecompressedNullTerminated = exports.decompressPacked(
+		ptrToCompressed,
+		compressedStr.length,
+		tokenCount
+	);
+
+	exports.free(ptrToCompressed, compressedStr.length);
+
+	const decompressed_buffer = new Uint8Array(
+		exports.memory.buffer.slice(
+			ptrToDecompressedNullTerminated,
+			ptrToDecompressedNullTerminated +
+				(exports.memory.buffer.byteLength -
+					ptrToDecompressedNullTerminated)
+		)
+	);
+	const decompressed_end = decompressed_buffer.indexOf(0);
+	const r = new TextDecoder().decode(
+		decompressed_buffer.slice(0, decompressed_end)
+	);
+
+	exports.free(ptrToDecompressedNullTerminated, decompressed_end + 1);
+
+	return r;
+}

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

@@ -0,0 +1,32 @@
+// @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 } }) {
+	console.log("onmessage", e);
+	const id = e.data.id;
+	resolver[id](e.data.data);
+	delete resolver[id];
+};
+
+export async function compress(data: string) {
+	const id = nextID++;
+	console.log("compress", id);
+	return new Promise((resolve) => {
+		resolver[id] = resolve;
+		worker.postMessage({ command: "compress", id, data });
+	});
+}
+
+export async function decompress(data: string) {
+	const id = nextID++;
+	console.log("decompress", id);
+	return new Promise((resolve) => {
+		resolver[id] = resolve;
+		worker.postMessage({ command: "decompress", id, data });
+	});
+}

package/src/smol-string-worker.ts

@@ -0,0 +1,32 @@
+// @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 } }) {
+	console.log("onmessage", e);
+	const id = e.data.id;
+	resolver[id](e.data.data);
+	delete resolver[id];
+};
+
+export async function compress(data: string) {
+	const id = nextID++;
+	console.log("compress", id);
+	return new Promise((resolve) => {
+		resolver[id] = resolve;
+		worker.postMessage({ command: "compress", id, data });
+	});
+}
+
+export async function decompress(data: string) {
+	const id = nextID++;
+	console.log("decompress", id);
+	return new Promise((resolve) => {
+		resolver[id] = resolve;
+		worker.postMessage({ command: "decompress", id, data });
+	});
+}

package/src/smol-string.ts

@@ -0,0 +1,76 @@
+import { Uint16ArraytoString, copyToWasmBuffer } from "./common.js";
+import init from "./module.wasm?init";
+
+type exportsType = {
+	allocUint8: (size: number) => number;
+	allocUint16: (size: number) => number;
+	compress: (ptr: number) => number;
+	decompress: (ptr: number) => number;
+	free: (ptr: number, length: number) => void;
+	memory: any;
+};
+
+const instance = await init();
+const exports = instance.exports as exportsType;
+
+export function compress(str: string) {
+	const { ptr, length } = copyToWasmBuffer(str, exports);
+
+	const ptrToCompressed = exports.compress(ptr);
+
+	exports.free(ptr, length);
+
+	const buffer = new Uint16Array(
+		exports.memory.buffer.slice(
+			ptrToCompressed,
+			ptrToCompressed +
+				(exports.memory.buffer.byteLength - ptrToCompressed)
+		)
+	);
+	const end = buffer.indexOf(0);
+	const compressed = buffer.slice(0, end);
+
+	const r = Uint16ArraytoString(compressed);
+
+	exports.free(ptrToCompressed, end + 1);
+
+	return r;
+}
+
+export function decompress(compressedStr: string) {
+	const ptrToCompressedNullTerminated = exports.allocUint16(
+		compressedStr.length + 1
+	);
+	const compressed_buffer = new Uint16Array(
+		exports.memory.buffer,
+		ptrToCompressedNullTerminated,
+		compressedStr.length + 1
+	);
+	for (let i = 0; i < compressedStr.length; i++)
+		compressed_buffer[i] = compressedStr.charCodeAt(i);
+	compressed_buffer[compressedStr.length] = 0;
+
+	const ptrToDecompressedNullTerminated = exports.decompress(
+		ptrToCompressedNullTerminated
+	);
+
+	exports.free(ptrToCompressedNullTerminated, compressedStr.length + 1);
+
+	const decompressed_buffer = new Uint8Array(
+		exports.memory.buffer.slice(
+			ptrToDecompressedNullTerminated,
+			ptrToDecompressedNullTerminated +
+				(exports.memory.buffer.byteLength -
+					ptrToDecompressedNullTerminated)
+		)
+	);
+	const decompressed_end = decompressed_buffer.indexOf(0);
+
+	exports.free(ptrToDecompressedNullTerminated, decompressed_end + 1);
+
+	const r = new TextDecoder().decode(
+		decompressed_buffer.slice(0, decompressed_end)
+	);
+
+	return r;
+}

package/src/wasm.d.ts

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

package/src/worker-packed.ts

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

package/src/worker.ts

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

package/test/basic.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, test } from "vitest";
+
+import { TestData } from "./common.js";
+
+import { compress, decompress } from "../dist/smol-string.js";
+import {
+	compressPacked,
+	decompressPacked,
+} from "../dist/smol-string-packed.js";
+
+describe("compress and decompress", () => {
+	for (const { name, input } of TestData) {
+		test(name, async () => {
+			const compressed = compress(input);
+			const decompressed = decompress(compressed);
+			expect(decompressed).toBe(input);
+		});
+	}
+});
+
+describe("compressPacked and decompressPacked", () => {
+	for (const { name, input } of TestData) {
+		test(name, async () => {
+			const compressed = compressPacked(input);
+			const decompressed = decompressPacked(compressed);
+			expect(decompressed).toBe(input);
+		});
+	}
+});

package/test/common.ts

@@ -0,0 +1,15 @@
+export const json_512kb = import("../../test/data/512KB.json");
+export const json_1mb = import("../../test/data/1MB.json");
+export const rw_medium = import("../../test/data/rw_medium.json");
+export const rw_large = import("../../test/data/rw_large.json");
+
+export const TestData = [
+	{
+		name: "Simple String",
+		input: "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum",
+	},
+	{ name: "json_512kb", input: JSON.stringify(await json_512kb) },
+	{ name: "json_1mb", input: JSON.stringify(await json_1mb) },
+	{ name: "rw_medium", input: JSON.stringify(await rw_medium) },
+	{ name: "rw_large", input: JSON.stringify(await rw_large) },
+];

package/test/json.bench.ts

@@ -0,0 +1,51 @@
+import { describe, bench, expect, test, beforeAll } from "vitest";
+
+import { TestData } from "./common.js";
+
+import { compress, decompress } from "../dist/smol-string.js";
+
+import {
+	compressPacked,
+	decompressPacked,
+} from "../dist/smol-string-packed.js";
+
+const options = { iterations: 5 };
+
+describe.each(TestData)("Compression: $name", ({ name, input }) => {
+	bench(
+		"compress",
+		async () => {
+			compress(input);
+		},
+		options
+	);
+	bench(
+		"compressPacked",
+		async () => {
+			compressPacked(input);
+		},
+		options
+	);
+});
+
+describe.each(TestData)("Decompression: $name", ({ name, input }) => {
+	let compressed = compress(input);
+	let compressedPacked = compressPacked(input);
+
+	bench(
+		"decompress",
+		async () => {
+			const decompressed = decompress(compressed);
+			expect(decompressed).toBe(input);
+		},
+		options
+	);
+	bench(
+		"decompressPacked",
+		async () => {
+			const decompressed = decompressPacked(compressedPacked);
+			expect(decompressed).toBe(input);
+		},
+		options
+	);
+});

package/test/localStorage.test.browser.ts

@@ -0,0 +1,39 @@
+import { describe, expect, test } from "vitest";
+
+import { TestData } from "./common.js";
+
+import { compress, decompress } from "../dist/smol-string.js";
+import {
+	compressPacked,
+	decompressPacked,
+} from "../dist/smol-string-packed.js";
+
+describe("compress and decompress via localStorage", async () => {
+	for (const { name, input } of TestData) {
+		test(name, async () => {
+			const compressed = await compress(input);
+
+			localStorage.setItem("compressed", compressed);
+			const restored = localStorage.getItem("compressed")!;
+
+			const decompressed = await decompress(restored);
+
+			expect(decompressed).toBe(input);
+		});
+	}
+});
+
+describe("compressPacked and decompressPacked via localStorage", async () => {
+	for (const { name, input } of TestData) {
+		test(name, async () => {
+			const compressed = await compressPacked(input);
+
+			localStorage.setItem("compressed", compressed);
+			const restored = localStorage.getItem("compressed")!;
+
+			const decompressed = await decompressPacked(restored);
+
+			expect(decompressed).toBe(input);
+		});
+	}
+});

package/test/sessionStorage.test.browser.ts

@@ -0,0 +1,39 @@
+import { describe, expect, test } from "vitest";
+
+import { TestData } from "./common.js";
+
+import { compress, decompress } from "../dist/smol-string.js";
+import {
+	compressPacked,
+	decompressPacked,
+} from "../dist/smol-string-packed.js";
+
+describe("compress and decompress via sessionStorage", () => {
+	for (const { name, input } of TestData) {
+		test(name, async () => {
+			const compressed = compress(input);
+
+			sessionStorage.setItem("compressed", compressed);
+			const restored = sessionStorage.getItem("compressed")!;
+
+			const decompressed = decompress(restored);
+
+			expect(decompressed).toBe(input);
+		});
+	}
+});
+
+describe("compressPacked and decompressPacked via sessionStorage", () => {
+	for (const { name, input } of TestData) {
+		test(name, async () => {
+			const compressed = compressPacked(input);
+
+			sessionStorage.setItem("compressed", compressed);
+			const restored = sessionStorage.getItem("compressed")!;
+
+			const decompressed = decompressPacked(restored);
+
+			expect(decompressed).toBe(input);
+		});
+	}
+});

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+	"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

@@ -0,0 +1,33 @@
+/// <reference types="vitest" />
+import { defineConfig } from "vite";
+import dts from "vite-plugin-dts";
+import pkg from "./package.json" assert { type: "json" };
+
+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: [
+		dts(), // emit TS declaration files
+	],
+	test: {},
+});