Language bindings, KDE thumbnails, yapf compare, in-memory encoding

- yapf_encode() / yapf_free_buffer(): encode to memory; yapf_save uses it
- yapf.c also compiles as C++
- `yapf compare`: size and decode speed of the original format vs YAPF,
  with a lossless check
- bindings with tested examples: C++ (header-only), C# (P/Invoke),
  Rust (crate, builds the C code), Go (cgo), Java (FFM API, Java 22+),
  Zig (@cImport), LuaJIT (FFI), TypeScript types for the JS port;
  Python now encodes in memory
- docs/LANGUAGES.md and examples/ with measured results
- KDE Dolphin thumbnail plugin (KF6, CMake)
- README: honest status for Photoshop / VS Code / Figma (not run in the
  apps yet) and macOS (cross-compiled only), platform table

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

bindings/js/README.md

@@ -19,4 +19,6 @@ ctx.putImageData(new ImageData(YAPF.toRGBA(img), img.width, img.height), 0, 0);
 `decode` throws an `Error` for corrupt or unsupported data.  Speed: a 4K
 image decodes in about 150 ms in Node / Chrome (the C library: 6 ms).
 
-Tests: `node test.js`.
+TypeScript types are in `yapf.d.ts`.
+
+Example: `node example.mjs ../../other/YAPF.YAPF` · tests: `node test.js`.

bindings/js/example.mjs

@@ -0,0 +1,19 @@
+// node example.mjs ../../other/YAPF.YAPF
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+const YAPF = createRequire(import.meta.url)('./yapf.js');
+
+const path = process.argv[2] ?? '../../other/YAPF.YAPF';
+const file = readFileSync(path);
+
+let img = YAPF.decode(file);
+let best = Infinity;                                   // best of 10 decodes
+for (let i = 0; i < 10; i++) {
+  const t = performance.now();
+  img = YAPF.decode(file);
+  best = Math.min(best, performance.now() - t);
+}
+console.log(`${path}: ${img.width}x${img.height}, ${img.channels} channels, decoded in ${best.toFixed(2)} ms (pure JavaScript)`);
+console.log(`file is ${file.length} bytes, ${(100 * file.length / img.pixels.length).toFixed(1)}% of the raw pixels`);
+const again = YAPF.encode(img);
+console.log(`re-encoded: ${again.length} bytes, identical: ${Buffer.compare(Buffer.from(again), file) === 0}`);

bindings/js/package.json

@@ -3,7 +3,8 @@
   "version": "1.0.0",
   "description": "YAPF v1 lossless image format: encoder and decoder in plain JavaScript, no dependencies",
   "main": "yapf.js",
-  "files": ["yapf.js", "README.md"],
+  "types": "yapf.d.ts",
+  "files": ["yapf.js", "yapf.d.ts", "README.md"],
   "scripts": { "test": "node test.js" },
   "keywords": ["image", "codec", "lossless", "yapf", "texture"],
   "license": "Apache-2.0",

bindings/js/yapf.d.ts

@@ -0,0 +1,25 @@
+// TypeScript declarations for yapf.js
+export interface YapfImage {
+  width: number;
+  height: number;
+  /** 1 gray, 2 gray + alpha, 3 RGB, 4 RGBA */
+  channels: 1 | 2 | 3 | 4;
+  /** width * height * channels bytes, rows top to bottom */
+  pixels: Uint8Array;
+  gpuFormat?: number;
+  flags?: number;
+  mipLevels?: number;
+  /** mips[0] is the full-size image */
+  mips?: Uint8Array[];
+}
+
+/** Decode a .yapf file; throws on corrupt or unsupported data. */
+export function decode(bytes: Uint8Array | ArrayBuffer): Required<YapfImage>;
+/** Encode an image to the bytes of a .yapf file (identical to the C encoder). */
+export function encode(image: YapfImage): Uint8Array;
+/** Any channel count → RGBA, ready for `new ImageData(rgba, w, h)`. */
+export function toRGBA(image: YapfImage, level?: number): Uint8ClampedArray;
+
+export const GPU: { RGBA8: 0; RGB8: 1; RG8: 2; R8: 3; SRGB8_A8: 4; SRGB8: 5 };
+export const FLAG: { PREMULT_ALPHA: 1; SRGB: 2 };
+export const VERSION: 1;