smart-downscaler 0.1.4 → 0.2.1

package/package.json

@@ -5,11 +5,11 @@
     "Pixagram"
   ],
   "description": "Intelligent pixel art downscaler with region-aware color quantization",
-  "version": "0.1.4",
+  "version": "0.2.1",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/pixagram/smart-downscaler"
+    "url": "https://github.com/pixagram-blockchain/smart-downscaler"
   },
   "files": [
     "smart_downscaler_bg.wasm",
@@ -30,4 +30,4 @@
     "quantization",
     "wasm"
   ]
-}
+}

package/smart_downscaler.d.ts

@@ -104,6 +104,17 @@ export class WasmDownscaleResult {
   readonly palette_size: number;
 }
 
+/**
+ * Highly optimized color analysis using a custom linear-probing hash table.
+ * 
+ * OPTIMIZATIONS:
+ * 1. Casts u8 slice to u32 slice (Zero Copy, 4x read speed)
+ * 2. Uses Power-of-Two capacity for bitwise masking (vs modulo)
+ * 3. FxHash-style integer mixer
+ * 4. Linear probing with localized memory access
+ */
+export function analyze_colors(image_data: Uint8Array, max_colors: number, sort_method: string): any;
+
 /**
  * Main downscaling function for WebAssembly
  *

package/smart_downscaler_bg.js

@@ -31,6 +31,13 @@ function isLikeNone(x) {
     return x === undefined || x === null;
 }
 
+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 passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);
@@ -439,6 +446,31 @@ export class WasmDownscaleResult {
 }
 if (Symbol.dispose) WasmDownscaleResult.prototype[Symbol.dispose] = WasmDownscaleResult.prototype.free;
 
+/**
+ * Highly optimized color analysis using a custom linear-probing hash table.
+ *
+ * OPTIMIZATIONS:
+ * 1. Casts u8 slice to u32 slice (Zero Copy, 4x read speed)
+ * 2. Uses Power-of-Two capacity for bitwise masking (vs modulo)
+ * 3. FxHash-style integer mixer
+ * 4. Linear probing with localized memory access
+ * @param {Uint8Array} image_data
+ * @param {number} max_colors
+ * @param {string} sort_method
+ * @returns {any}
+ */
+export function analyze_colors(image_data, max_colors, sort_method) {
+    const ptr0 = passArray8ToWasm0(image_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(sort_method, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.analyze_colors(ptr0, len0, max_colors, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Main downscaling function for WebAssembly
  *
@@ -618,6 +650,16 @@ export function __wbg_log_1d990106d99dacb7(arg0) {
     console.log(arg0);
 };
 
+export function __wbg_new_1ba21ce319a06297() {
+    const ret = new Object();
+    return ret;
+};
+
+export function __wbg_new_25f239778d6112b9() {
+    const ret = new Array();
+    return ret;
+};
+
 export function __wbg_new_6421f6084cc5bc5a(arg0) {
     const ret = new Uint8Array(arg0);
     return ret;
@@ -642,12 +684,26 @@ export function __wbg_prototypesetcall_dfe9b766cdc1f1fd(arg0, arg1, arg2) {
     Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
 };
 
+export function __wbg_set_3f1d0b984ed272ed(arg0, arg1, arg2) {
+    arg0[arg1] = arg2;
+};
+
+export function __wbg_set_7df433eea03a5c14(arg0, arg1, arg2) {
+    arg0[arg1 >>> 0] = arg2;
+};
+
 export function __wbindgen_cast_2241b6af4c4b2941(arg0, arg1) {
     // Cast intrinsic for `Ref(String) -> Externref`.
     const ret = getStringFromWasm0(arg0, arg1);
     return ret;
 };
 
+export function __wbindgen_cast_d6cd19b81560fd6e(arg0) {
+    // Cast intrinsic for `F64 -> Externref`.
+    const ret = arg0;
+    return ret;
+};
+
 export function __wbindgen_init_externref_table() {
     const table = wasm.__wbindgen_externrefs;
     const offset = table.grow(4);