@atcute/uint8array 1.0.5 → 1.1.0

package/lib/index.ts

@@ -135,56 +135,192 @@ export const encodeUtf8Into = (to: Uint8Array, str: string, offset?: number, len
 	return result.written;
 };
 
-const fromCharCode = String.fromCharCode;
+const _fromCharCode = String.fromCharCode;
+
+// fully unrolled short string decoder, inspired by cbor-x
+// returns null if non-ASCII byte encountered, signaling fallback to TextDecoder
+const _shortString = (from: Uint8Array, p: number, length: number): string | null => {
+	if (length < 4) {
+		if (length < 2) {
+			if (length === 0) return '';
+			const a = from[p];
+			if (a & 0x80) return null;
+			return _fromCharCode(a);
+		}
+		const a = from[p];
+		const b = from[p + 1];
+		if ((a | b) & 0x80) return null;
+		if (length === 2) return _fromCharCode(a, b);
+		const c = from[p + 2];
+		if (c & 0x80) return null;
+		return _fromCharCode(a, b, c);
+	}
+	const a = from[p];
+	const b = from[p + 1];
+	const c = from[p + 2];
+	const d = from[p + 3];
+	if ((a | b | c | d) & 0x80) return null;
+	if (length < 8) {
+		if (length === 4) return _fromCharCode(a, b, c, d);
+		const e = from[p + 4];
+		if (e & 0x80) return null;
+		if (length === 5) return _fromCharCode(a, b, c, d, e);
+		const f = from[p + 5];
+		if (f & 0x80) return null;
+		if (length === 6) return _fromCharCode(a, b, c, d, e, f);
+		const g = from[p + 6];
+		if (g & 0x80) return null;
+		return _fromCharCode(a, b, c, d, e, f, g);
+	}
+	const e = from[p + 4];
+	const f = from[p + 5];
+	const g = from[p + 6];
+	const h = from[p + 7];
+	if ((e | f | g | h) & 0x80) return null;
+	if (length < 12) {
+		if (length === 8) return _fromCharCode(a, b, c, d, e, f, g, h);
+		const i = from[p + 8];
+		if (i & 0x80) return null;
+		if (length === 9) return _fromCharCode(a, b, c, d, e, f, g, h, i);
+		const j = from[p + 9];
+		if (j & 0x80) return null;
+		if (length === 10) return _fromCharCode(a, b, c, d, e, f, g, h, i, j);
+		const k = from[p + 10];
+		if (k & 0x80) return null;
+		return _fromCharCode(a, b, c, d, e, f, g, h, i, j, k);
+	}
+	const i = from[p + 8];
+	const j = from[p + 9];
+	const k = from[p + 10];
+	const l = from[p + 11];
+	if ((i | j | k | l) & 0x80) return null;
+	if (length === 12) return _fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l);
+	const m = from[p + 12];
+	if (m & 0x80) return null;
+	if (length === 13) return _fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m);
+	const n = from[p + 13];
+	if (n & 0x80) return null;
+	if (length === 14) return _fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n);
+	const o = from[p + 14];
+	if (o & 0x80) return null;
+	return _fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o);
+};
 
 /**
  * decodes a UTF-8 string from a given buffer
+ * @param from source buffer
+ * @param offset byte offset to start reading from
+ * @param length number of bytes to read
+ * @returns decoded string
  */
-export const decodeUtf8From = (from: Uint8Array, offset?: number, length?: number): string => {
-	let buffer: Uint8Array;
-
-	if (offset === undefined) {
-		buffer = from;
-	} else if (length === undefined) {
-		buffer = from.subarray(offset);
-	} else {
-		buffer = from.subarray(offset, offset + length);
+export const decodeUtf8From = (
+	from: Uint8Array,
+	offset: number = 0,
+	length: number = from.length,
+): string => {
+	if (length <= 15) {
+		const result = _shortString(from, offset, length);
+		if (result !== null) return result;
 	}
+	return textDecoder.decode(from.subarray(offset, offset + length));
+};
 
-	const end = buffer.length;
-	if (end > 24) {
-		return textDecoder.decode(buffer);
-	}
+/**
+ * calculates the UTF-8 byte length of a string
+ * @param str string to measure
+ * @returns byte length when encoded as UTF-8
+ */
+export const getUtf8Length = (str: string): number => {
+	const len = str.length;
 
-	{
-		let str = '';
-		let idx = 0;
+	let u16pos = 0;
+	let u8pos = 0;
 
-		for (; idx + 3 < end; idx += 4) {
-			const a = buffer[idx];
-			const b = buffer[idx + 1];
-			const c = buffer[idx + 2];
-			const d = buffer[idx + 3];
+	// ASCII fast-path: batch process 4 chars at a time
+	while (u16pos + 3 < len) {
+		const a = str.charCodeAt(u16pos);
+		const b = str.charCodeAt(u16pos + 1);
+		const c = str.charCodeAt(u16pos + 2);
+		const d = str.charCodeAt(u16pos + 3);
 
-			if ((a | b | c | d) & 0x80) {
-				return str + textDecoder.decode(buffer.subarray(idx));
-			}
+		if ((a | b | c | d) >= 0x80) {
+			break;
+		}
+
+		u16pos += 4;
+		u8pos += 4;
+	}
 
-			str += fromCharCode(a, b, c, d);
+	// handle remaining chars
+	while (u16pos < len) {
+		const code = str.charCodeAt(u16pos);
+
+		if (code < 0x80) {
+			u16pos += 1;
+			u8pos += 1;
+		} else if (code < 0x800) {
+			u16pos += 1;
+			u8pos += 2;
+		} else if (code < 0xd800 || code > 0xdbff) {
+			u16pos += 1;
+			u8pos += 3;
+		} else {
+			u16pos += 2;
+			u8pos += 4;
 		}
+	}
 
-		for (; idx < end; idx++) {
-			const x = buffer[idx];
+	return u8pos;
+};
 
-			if (x & 0x80) {
-				return str + textDecoder.decode(buffer.subarray(idx));
-			}
+/**
+ * checks if a string's UTF-8 byte length is within a given range.
+ * includes early-exit optimization when exceeding max length.
+ * @param str string to measure
+ * @param min minimum byte length (inclusive)
+ * @param max maximum byte length (inclusive)
+ * @returns true if byte length is within [min, max]
+ */
+export const isUtf8LengthInRange = (str: string, min: number, max: number): boolean => {
+	const len = str.length;
+
+	// fast path: if max possible UTF-8 length is below min, fail
+	if (len * 3 < min) {
+		return false;
+	}
 
-			str += fromCharCode(x);
+	// fast path: if UTF-16 length satisfies min and max possible satisfies max
+	if (len >= min && len * 3 <= max) {
+		return true;
+	}
+
+	let u16pos = 0;
+	let u8pos = 0;
+
+	while (u16pos < len) {
+		const code = str.charCodeAt(u16pos);
+
+		if (code < 0x80) {
+			u16pos += 1;
+			u8pos += 1;
+		} else if (code < 0x800) {
+			u16pos += 1;
+			u8pos += 2;
+		} else if (code < 0xd800 || code > 0xdbff) {
+			u16pos += 1;
+			u8pos += 3;
+		} else {
+			u16pos += 2;
+			u8pos += 4;
 		}
 
-		return str;
+		// early exit once we exceed max
+		if (u8pos > max) {
+			return false;
+		}
 	}
+
+	return u8pos >= min;
 };
 
 /**
@@ -193,3 +329,12 @@ export const decodeUtf8From = (from: Uint8Array, offset?: number, length?: numbe
 export const toSha256 = async (buffer: Uint8Array<ArrayBuffer>): Promise<Uint8Array<ArrayBuffer>> => {
 	return new Uint8Array(await subtle.digest('SHA-256', buffer));
 };
+
+/**
+ * generates cryptographically secure random bytes
+ * @param size number of bytes to generate
+ * @returns buffer filled with random bytes
+ */
+export const randomBytes = (size: number): Uint8Array<ArrayBuffer> => {
+	return crypto.getRandomValues(new Uint8Array(size));
+};

package/package.json

@@ -1,12 +1,11 @@
 {
-  "type": "module",
   "name": "@atcute/uint8array",
-  "version": "1.0.5",
+  "version": "1.1.0",
   "description": "uint8array utilities",
   "license": "0BSD",
   "repository": {
     "url": "https://github.com/mary-ext/atcute",
-    "directory": "packages/utilities/uint8array"
+    "directory": "packages/misc/uint8array"
   },
   "files": [
     "dist/",
@@ -14,6 +13,8 @@
     "!lib/**/*.bench.ts",
     "!lib/**/*.test.ts"
   ],
+  "type": "module",
+  "sideEffects": false,
   "exports": {
     ".": {
       "bun": "./dist/index.bun.js",
@@ -21,13 +22,14 @@
       "default": "./dist/index.js"
     }
   },
-  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
   "devDependencies": {
-    "@types/bun": "^1.2.21"
+    "@types/bun": "^1.3.5"
   },
   "scripts": {
-    "build": "tsc --project tsconfig.build.json",
-    "test": "bun test --coverage",
+    "build": "tsgo --project tsconfig.build.json",
     "prepublish": "rm -rf dist; pnpm run build"
   }
 }