@gjsify/string_decoder 0.1.0

package/README.md

@@ -0,0 +1,27 @@
+# @gjsify/string_decoder
+
+GJS implementation of the Node.js `string_decoder` module. Supports UTF-8, Base64, hex, and streaming decoding.
+
+Part of the [gjsify](https://github.com/gjsify/gjsify) project — Node.js and Web APIs for GJS (GNOME JavaScript).
+
+## Installation
+
+```bash
+npm install @gjsify/string_decoder
+# or
+yarn add @gjsify/string_decoder
+```
+
+## Usage
+
+```typescript
+import { StringDecoder } from '@gjsify/string_decoder';
+
+const decoder = new StringDecoder('utf-8');
+console.log(decoder.write(Buffer.from([0xe2, 0x82])));
+console.log(decoder.end(Buffer.from([0xac])));
+```
+
+## License
+
+MIT

package/lib/esm/index.js

@@ -0,0 +1,402 @@
+import { normalizeEncoding, checkEncoding, base64Encode as bytesToBase64 } from "@gjsify/utils";
+function normalizeAndValidateEncoding(enc) {
+  if (enc) checkEncoding(enc);
+  return normalizeEncoding(enc);
+}
+function utf8DecodeMaximalSubpart(bytes, start, end2) {
+  let result = "";
+  let i = start;
+  while (i < end2) {
+    const b0 = bytes[i];
+    if (b0 <= 127) {
+      result += String.fromCharCode(b0);
+      i++;
+      continue;
+    }
+    if (b0 >= 194 && b0 <= 223) {
+      if (i + 1 < end2 && bytes[i + 1] >= 128 && bytes[i + 1] <= 191) {
+        result += String.fromCharCode((b0 & 31) << 6 | bytes[i + 1] & 63);
+        i += 2;
+      } else {
+        result += "\uFFFD";
+        i++;
+      }
+      continue;
+    }
+    if (b0 >= 224 && b0 <= 239) {
+      let lo2, hi2;
+      if (b0 === 224) {
+        lo2 = 160;
+        hi2 = 191;
+      } else if (b0 === 237) {
+        lo2 = 128;
+        hi2 = 159;
+      } else {
+        lo2 = 128;
+        hi2 = 191;
+      }
+      if (i + 1 >= end2) {
+        result += "\uFFFD";
+        i++;
+        continue;
+      }
+      const b1 = bytes[i + 1];
+      if (b1 < lo2 || b1 > hi2) {
+        result += "\uFFFD";
+        i++;
+        continue;
+      }
+      if (i + 2 >= end2) {
+        result += "\uFFFD";
+        i += 2;
+        continue;
+      }
+      const b2 = bytes[i + 2];
+      if (b2 < 128 || b2 > 191) {
+        result += "\uFFFD";
+        i += 2;
+        continue;
+      }
+      const cp = (b0 & 15) << 12 | (b1 & 63) << 6 | b2 & 63;
+      result += String.fromCharCode(cp);
+      i += 3;
+      continue;
+    }
+    if (b0 >= 240 && b0 <= 244) {
+      let lo2, hi2;
+      if (b0 === 240) {
+        lo2 = 144;
+        hi2 = 191;
+      } else if (b0 === 244) {
+        lo2 = 128;
+        hi2 = 143;
+      } else {
+        lo2 = 128;
+        hi2 = 191;
+      }
+      if (i + 1 >= end2) {
+        result += "\uFFFD";
+        i++;
+        continue;
+      }
+      const b1 = bytes[i + 1];
+      if (b1 < lo2 || b1 > hi2) {
+        result += "\uFFFD";
+        i++;
+        continue;
+      }
+      if (i + 2 >= end2) {
+        result += "\uFFFD";
+        i += 2;
+        continue;
+      }
+      const b2 = bytes[i + 2];
+      if (b2 < 128 || b2 > 191) {
+        result += "\uFFFD";
+        i += 2;
+        continue;
+      }
+      if (i + 3 >= end2) {
+        result += "\uFFFD";
+        i += 3;
+        continue;
+      }
+      const b3 = bytes[i + 3];
+      if (b3 < 128 || b3 > 191) {
+        result += "\uFFFD";
+        i += 3;
+        continue;
+      }
+      const cp = (b0 & 7) << 18 | (b1 & 63) << 12 | (b2 & 63) << 6 | b3 & 63;
+      result += String.fromCharCode(
+        55296 + (cp - 65536 >> 10),
+        56320 + (cp - 65536 & 1023)
+      );
+      i += 4;
+      continue;
+    }
+    result += "\uFFFD";
+    i++;
+  }
+  return result;
+}
+function utf8CharLength(byte) {
+  if ((byte & 128) === 0) return 1;
+  if (byte >= 194 && byte <= 223) return 2;
+  if (byte >= 224 && byte <= 239) return 3;
+  if (byte >= 240 && byte <= 244) return 4;
+  return 0;
+}
+function isValidContinuation(leadByte, charLen, position, byte) {
+  if (position === 1) {
+    if (charLen === 3) {
+      if (leadByte === 224) return byte >= 160 && byte <= 191;
+      if (leadByte === 237) return byte >= 128 && byte <= 159;
+      return byte >= 128 && byte <= 191;
+    }
+    if (charLen === 4) {
+      if (leadByte === 240) return byte >= 144 && byte <= 191;
+      if (leadByte === 244) return byte >= 128 && byte <= 143;
+      return byte >= 128 && byte <= 191;
+    }
+  }
+  return byte >= 128 && byte <= 191;
+}
+const StringDecoder = function StringDecoder2(encoding) {
+  this.encoding = normalizeAndValidateEncoding(encoding);
+  this._lastNeed = 0;
+  this._lastTotal = 0;
+  this._lastLeadByte = 0;
+  if (this.encoding === "utf8") {
+    this._lastChar = new Uint8Array(4);
+  } else if (this.encoding === "utf16le") {
+    this._lastChar = new Uint8Array(4);
+  } else if (this.encoding === "base64") {
+    this._lastChar = new Uint8Array(3);
+  } else {
+    this._lastChar = new Uint8Array(0);
+  }
+};
+StringDecoder.prototype.write = function write(buf) {
+  if (buf.length === 0) return "";
+  switch (this.encoding) {
+    case "utf8":
+      return writeUtf8(this, buf);
+    case "utf16le":
+      return writeUtf16le(this, buf);
+    case "base64":
+      return writeBase64(this, buf);
+    case "ascii":
+      return decodeAscii(buf);
+    case "latin1":
+      return decodeLatin1(buf);
+    case "hex":
+      return decodeHex(buf);
+    default:
+      return decodeAscii(buf);
+  }
+};
+StringDecoder.prototype.end = function end(buf) {
+  let result = "";
+  if (buf && buf.length > 0) {
+    result = this.write(buf);
+  }
+  if (this.encoding === "utf8" && this._lastNeed > 0) {
+    result += "\uFFFD";
+    this._lastNeed = 0;
+    this._lastTotal = 0;
+  } else if (this.encoding === "utf16le" && this._lastNeed > 0) {
+    const stored = this._lastTotal - this._lastNeed;
+    for (let i = 0; i + 1 < stored; i += 2) {
+      result += String.fromCharCode(this._lastChar[i] | this._lastChar[i + 1] << 8);
+    }
+    this._lastNeed = 0;
+    this._lastTotal = 0;
+  } else if (this.encoding === "base64" && this._lastNeed > 0) {
+    const remaining = this._lastChar.subarray(0, this._lastTotal - this._lastNeed);
+    result += bytesToBase64(remaining);
+    this._lastNeed = 0;
+    this._lastTotal = 0;
+  }
+  return result;
+};
+function writeUtf8(self, buf) {
+  let i = 0;
+  let result = "";
+  if (self._lastNeed > 0) {
+    while (i < buf.length && self._lastNeed > 0) {
+      const byte = buf[i];
+      const position = self._lastTotal - self._lastNeed;
+      if (isValidContinuation(self._lastLeadByte, self._lastTotal, position, byte)) {
+        self._lastChar[position] = byte;
+        self._lastNeed--;
+        i++;
+      } else {
+        result += "\uFFFD";
+        self._lastNeed = 0;
+        self._lastTotal = 0;
+        self._lastLeadByte = 0;
+        break;
+      }
+    }
+    if (self._lastNeed === 0 && self._lastTotal > 0) {
+      result += utf8DecodeMaximalSubpart(self._lastChar, 0, self._lastTotal);
+      self._lastTotal = 0;
+      self._lastLeadByte = 0;
+    }
+    if (self._lastNeed > 0) {
+      return result;
+    }
+  }
+  let completeEnd = buf.length;
+  for (let j = 0; j < Math.min(4, buf.length - i); j++) {
+    const idx = buf.length - 1 - j;
+    if (idx < i) break;
+    const byte = buf[idx];
+    if ((byte & 192) !== 128) {
+      const charLen = utf8CharLength(byte);
+      if (charLen > 0 && byte >= 128) {
+        const available = buf.length - idx;
+        if (available < charLen) {
+          let allValid = true;
+          for (let k = 1; k < available; k++) {
+            if (!isValidContinuation(byte, charLen, k, buf[idx + k])) {
+              allValid = false;
+              break;
+            }
+          }
+          if (allValid) {
+            completeEnd = idx;
+            for (let k = 0; k < available; k++) {
+              self._lastChar[k] = buf[idx + k];
+            }
+            self._lastNeed = charLen - available;
+            self._lastTotal = charLen;
+            self._lastLeadByte = byte;
+          }
+        }
+      }
+      break;
+    }
+  }
+  if (completeEnd > i) {
+    result += utf8DecodeMaximalSubpart(buf, i, completeEnd);
+  }
+  return result;
+}
+function writeUtf16le(self, buf) {
+  let result = "";
+  let i = 0;
+  if (self._lastNeed > 0) {
+    const offset = self._lastTotal - self._lastNeed;
+    const needed = Math.min(self._lastNeed, buf.length);
+    for (let j2 = 0; j2 < needed; j2++) {
+      self._lastChar[offset + j2] = buf[j2];
+    }
+    self._lastNeed -= needed;
+    i = needed;
+    if (self._lastNeed > 0) return "";
+    const stored = self._lastTotal;
+    let j = 0;
+    while (j + 1 < stored) {
+      const code = self._lastChar[j] | self._lastChar[j + 1] << 8;
+      j += 2;
+      if (code >= 55296 && code <= 56319) {
+        if (j + 1 < stored) {
+          const nextCode = self._lastChar[j] | self._lastChar[j + 1] << 8;
+          if (nextCode >= 56320 && nextCode <= 57343) {
+            result += String.fromCharCode(code, nextCode);
+            j += 2;
+            continue;
+          }
+        }
+        if (i + 1 < buf.length) {
+          const nextCode = buf[i] | buf[i + 1] << 8;
+          if (nextCode >= 56320 && nextCode <= 57343) {
+            result += String.fromCharCode(code, nextCode);
+            i += 2;
+            continue;
+          }
+        } else if (i >= buf.length) {
+          self._lastChar[0] = self._lastChar[j - 2];
+          self._lastChar[1] = self._lastChar[j - 1];
+          self._lastNeed = 2;
+          self._lastTotal = 4;
+          return result;
+        }
+      }
+      result += String.fromCharCode(code);
+    }
+    self._lastTotal = 0;
+  }
+  while (i + 1 < buf.length) {
+    const code = buf[i] | buf[i + 1] << 8;
+    i += 2;
+    if (code >= 55296 && code <= 56319) {
+      if (i + 1 < buf.length) {
+        const nextCode = buf[i] | buf[i + 1] << 8;
+        if (nextCode >= 56320 && nextCode <= 57343) {
+          result += String.fromCharCode(code, nextCode);
+          i += 2;
+          continue;
+        }
+      } else if (i < buf.length) {
+        result += String.fromCharCode(code);
+        self._lastChar[0] = buf[i];
+        self._lastNeed = 1;
+        self._lastTotal = 2;
+        return result;
+      } else {
+        self._lastChar[0] = buf[i - 2];
+        self._lastChar[1] = buf[i - 1];
+        self._lastNeed = 2;
+        self._lastTotal = 4;
+        return result;
+      }
+    }
+    result += String.fromCharCode(code);
+  }
+  if (i < buf.length) {
+    self._lastChar[0] = buf[i];
+    self._lastNeed = 1;
+    self._lastTotal = 2;
+  }
+  return result;
+}
+function writeBase64(self, buf) {
+  let start = 0;
+  if (self._lastNeed > 0) {
+    const needed = Math.min(self._lastNeed, buf.length);
+    for (let i = 0; i < needed; i++) {
+      self._lastChar[self._lastTotal - self._lastNeed + i] = buf[i];
+      self._lastNeed--;
+    }
+    start = needed;
+    if (self._lastNeed > 0) return "";
+  }
+  const remaining = buf.length - start;
+  const complete = remaining - remaining % 3;
+  let result = "";
+  if (self._lastTotal > 0 && self._lastNeed === 0) {
+    result += bytesToBase64(self._lastChar.subarray(0, self._lastTotal));
+    self._lastTotal = 0;
+  }
+  if (complete > 0) {
+    result += bytesToBase64(buf.subarray(start, start + complete));
+  }
+  const leftover = remaining - complete;
+  if (leftover > 0) {
+    for (let i = 0; i < leftover; i++) {
+      self._lastChar[i] = buf[start + complete + i];
+    }
+    self._lastNeed = 3 - leftover;
+    self._lastTotal = 3;
+  }
+  return result;
+}
+function decodeAscii(buf) {
+  let result = "";
+  for (let i = 0; i < buf.length; i++) {
+    result += String.fromCharCode(buf[i] & 127);
+  }
+  return result;
+}
+function decodeLatin1(buf) {
+  let result = "";
+  for (let i = 0; i < buf.length; i++) {
+    result += String.fromCharCode(buf[i]);
+  }
+  return result;
+}
+function decodeHex(buf) {
+  let result = "";
+  for (let i = 0; i < buf.length; i++) {
+    result += buf[i].toString(16).padStart(2, "0");
+  }
+  return result;
+}
+var index_default = { StringDecoder };
+export {
+  StringDecoder,
+  index_default as default
+};

package/lib/types/index.d.ts

@@ -0,0 +1,24 @@
+interface StringDecoderInstance {
+    readonly encoding: string;
+    write(buf: Uint8Array): string;
+    end(buf?: Uint8Array): string;
+}
+interface StringDecoderConstructor {
+    new (encoding?: string): StringDecoderInstance;
+    (this: StringDecoderInstance, encoding?: string): void;
+    prototype: StringDecoderInstance;
+}
+/**
+ * StringDecoder provides an interface for efficiently decoding Buffer data
+ * into strings while preserving multi-byte characters that are split across
+ * Buffer boundaries.
+ *
+ * Implemented as a function constructor (not ES6 class) for compatibility
+ * with legacy CJS patterns that use StringDecoder.call(this, enc).
+ */
+declare const StringDecoder: StringDecoderConstructor;
+export { StringDecoder };
+declare const _default: {
+    StringDecoder: StringDecoderConstructor;
+};
+export default _default;

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@gjsify/string_decoder",
+  "version": "0.1.0",
+  "description": "Node.js string_decoder module for Gjs",
+  "type": "module",
+  "module": "lib/esm/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/esm/index.js"
+    }
+  },
+  "scripts": {
+    "clear": "rm -rf lib tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo test.gjs.mjs test.node.mjs || exit 0",
+    "check": "tsc --noEmit",
+    "build": "yarn build:gjsify && yarn build:types",
+    "build:gjsify": "gjsify build --library 'src/**/*.{ts,js}' --exclude 'src/**/*.spec.{mts,ts}' 'src/test.{mts,ts}'",
+    "build:types": "tsc",
+    "build:test": "yarn build:test:gjs && yarn build:test:node",
+    "build:test:gjs": "gjsify build src/test.mts --app gjs --outfile test.gjs.mjs",
+    "build:test:node": "gjsify build src/test.mts --app node --outfile test.node.mjs",
+    "test": "yarn build:gjsify && yarn build:test && yarn test:node && yarn test:gjs",
+    "test:gjs": "gjs -m test.gjs.mjs",
+    "test:node": "node test.node.mjs"
+  },
+  "keywords": [
+    "gjs",
+    "node",
+    "string_decoder"
+  ],
+  "devDependencies": {
+    "@gjsify/cli": "^0.1.0",
+    "@gjsify/unit": "^0.1.0",
+    "@types/node": "^25.5.0",
+    "typescript": "^6.0.2"
+  },
+  "dependencies": {
+    "@gjsify/utils": "^0.1.0"
+  }
+}