@bare-ts/lib 0.1.1 → 0.2.0

package/dist/codec/primitive.js

@@ -15,18 +15,18 @@ import {
 var NAN_NOT_ALLOWED = "NaN is not allowed";
 var NON_CANONICAL_REPRESENTATION = "must be canonical";
 var TOO_LARGE_NUMBER = "too large number";
-function decodeBool(bc) {
-  const val = decodeU8(bc);
+function readBool(bc) {
+  const val = readU8(bc);
   if (val > 1) {
     bc.offset--;
     throw new BareError(bc.offset, "a bool must be equal to 0 or 1");
   }
   return val !== 0;
 }
-function encodeBool(bc, x) {
-  encodeU8(bc, x ? 1 : 0);
+function writeBool(bc, x) {
+  writeU8(bc, x ? 1 : 0);
 }
-function decodeF32(bc) {
+function readF32(bc) {
   bc.check(4);
   const result = bc.view.getFloat32(bc.offset, true);
   if (Number.isNaN(result)) {
@@ -35,14 +35,14 @@ function decodeF32(bc) {
   bc.offset += 4;
   return result;
 }
-function encodeF32(bc, x) {
+function writeF32(bc, x) {
   assert(!Number.isNaN(x), NAN_NOT_ALLOWED);
   bc.reserve(4);
   bc.view.setFloat32(bc.offset, x, true);
   assert(Math.abs(bc.view.getFloat32(bc.offset, true) - x) <= Number.EPSILON, TOO_LARGE_NUMBER);
   bc.offset += 4;
 }
-function decodeF64(bc) {
+function readF64(bc) {
   bc.check(8);
   const result = bc.view.getFloat64(bc.offset, true);
   if (Number.isNaN(result)) {
@@ -51,69 +51,69 @@ function decodeF64(bc) {
   bc.offset += 8;
   return result;
 }
-function encodeF64(bc, x) {
+function writeF64(bc, x) {
   assert(!Number.isNaN(x), NAN_NOT_ALLOWED);
   bc.reserve(8);
   bc.view.setFloat64(bc.offset, x, true);
   bc.offset += 8;
 }
-function decodeI8(bc) {
+function readI8(bc) {
   bc.check(1);
   return bc.view.getInt8(bc.offset++);
 }
-function encodeI8(bc, x) {
+function writeI8(bc, x) {
   assert(isI8(x), TOO_LARGE_NUMBER);
   bc.reserve(1);
   bc.view.setInt8(bc.offset++, x);
 }
-function decodeI16(bc) {
+function readI16(bc) {
   bc.check(2);
   const result = bc.view.getInt16(bc.offset, true);
   bc.offset += 2;
   return result;
 }
-function encodeI16(bc, x) {
+function writeI16(bc, x) {
   assert(isI16(x), TOO_LARGE_NUMBER);
   bc.reserve(2);
   bc.view.setInt16(bc.offset, x, true);
   bc.offset += 2;
 }
-function decodeI32(bc) {
+function readI32(bc) {
   bc.check(4);
   const result = bc.view.getInt32(bc.offset, true);
   bc.offset += 4;
   return result;
 }
-function encodeI32(bc, x) {
+function writeI32(bc, x) {
   assert(isI32(x), TOO_LARGE_NUMBER);
   bc.reserve(4);
   bc.view.setInt32(bc.offset, x, true);
   bc.offset += 4;
 }
-function decodeI64(bc) {
+function readI64(bc) {
   bc.check(8);
   const result = bc.view.getBigInt64(bc.offset, true);
   bc.offset += 8;
   return result;
 }
-function encodeI64(bc, x) {
+function writeI64(bc, x) {
   assert(isI64(x), TOO_LARGE_NUMBER);
   bc.reserve(8);
   bc.view.setBigInt64(bc.offset, x, true);
   bc.offset += 8;
 }
-function decodeI64Safe(bc) {
-  const result = decodeU32(bc) + decodeI32(bc) * 4294967296;
+function readI64Safe(bc) {
+  const result = readU32(bc) + readI32(bc) * 4294967296;
   if (!Number.isSafeInteger(result)) {
     bc.offset -= 8;
     throw new BareError(bc.offset, TOO_LARGE_NUMBER);
   }
   return result;
 }
-function encodeI64Safe(bc, x) {
+function writeI64Safe(bc, x) {
   assert(Number.isSafeInteger(x), TOO_LARGE_NUMBER);
   const lowest32 = x >>> 0;
-  encodeU32(bc, lowest32);
+  writeU32(bc, lowest32);
   let highest32 = x / 4294967296 | 0;
   if (x < 0) {
     highest32 = ~Math.abs(highest32) >>> 0;
@@ -121,27 +121,27 @@ function encodeI64Safe(bc, x) {
       highest32++;
     }
   }
-  encodeU32(bc, highest32);
+  writeU32(bc, highest32);
 }
-function decodeInt(bc) {
-  const zigZag = decodeUint(bc);
+function readInt(bc) {
+  const zigZag = readUint(bc);
   return zigZag >> BigInt(1) ^ -(zigZag & BigInt(1));
 }
-function encodeInt(bc, x) {
+function writeInt(bc, x) {
   assert(isI64(x), TOO_LARGE_NUMBER);
   const zigZag = x >> BigInt(63) ^ x << BigInt(1);
-  encodeUint(bc, zigZag);
+  writeUint(bc, zigZag);
 }
 var INT_SAFE_MAX_BYTE_COUNT = 8;
-function decodeIntSafe(bc) {
-  const firstByte = decodeU8(bc);
+function readIntSafe(bc) {
+  const firstByte = readU8(bc);
   let result = (firstByte & 127) >> 1;
   if (firstByte >= 128) {
     let shiftMul = 64;
     let byteCount = 1;
     let byte;
     do {
-      byte = decodeU8(bc);
+      byte = readU8(bc);
       result += (byte & 127) * shiftMul;
       shiftMul *= 128;
       byteCount++;
@@ -161,7 +161,7 @@ function decodeIntSafe(bc) {
   }
   return result;
 }
-function encodeIntSafe(bc, x) {
+function writeIntSafe(bc, x) {
   assert(Number.isSafeInteger(x), TOO_LARGE_NUMBER);
   const sign = x < 0 ? 1 : 0;
   if (x < 0) {
@@ -170,103 +170,107 @@ function encodeIntSafe(bc, x) {
   const firstByte = (x & 63) << 1 | sign;
   x = Math.floor(x / 64);
   if (x > 0) {
-    encodeU8(bc, 128 | firstByte);
-    encodeUintSafe(bc, x);
+    writeU8(bc, 128 | firstByte);
+    writeUintSafe(bc, x);
   } else {
-    encodeU8(bc, firstByte);
+    writeU8(bc, firstByte);
   }
 }
-function decodeU8(bc) {
+function readU8(bc) {
   bc.check(1);
-  return bc.view.getUint8(bc.offset++);
+  return bc.bytes[bc.offset++];
 }
-function encodeU8(bc, x) {
+function writeU8(bc, x) {
   assert(isU8(x), TOO_LARGE_NUMBER);
   bc.reserve(1);
-  bc.view.setUint8(bc.offset++, x);
+  bc.bytes[bc.offset++] = x;
 }
-function decodeU16(bc) {
+function readU16(bc) {
   bc.check(2);
   const result = bc.view.getUint16(bc.offset, true);
   bc.offset += 2;
   return result;
 }
-function encodeU16(bc, x) {
+function writeU16(bc, x) {
   assert(isU16(x), TOO_LARGE_NUMBER);
   bc.reserve(2);
   bc.view.setUint16(bc.offset, x, true);
   bc.offset += 2;
 }
-function decodeU32(bc) {
+function readU32(bc) {
   bc.check(4);
   const result = bc.view.getUint32(bc.offset, true);
   bc.offset += 4;
   return result;
 }
-function encodeU32(bc, x) {
+function writeU32(bc, x) {
   assert(isU32(x), TOO_LARGE_NUMBER);
   bc.reserve(4);
   bc.view.setUint32(bc.offset, x, true);
   bc.offset += 4;
 }
-function decodeU64(bc) {
+function readU64(bc) {
   bc.check(8);
   const result = bc.view.getBigUint64(bc.offset, true);
   bc.offset += 8;
   return result;
 }
-function encodeU64(bc, x) {
+function writeU64(bc, x) {
   assert(isU64(x), TOO_LARGE_NUMBER);
   bc.reserve(8);
   bc.view.setBigUint64(bc.offset, x, true);
   bc.offset += 8;
 }
-function decodeU64Safe(bc) {
-  const result = decodeU32(bc) + decodeU32(bc) * 4294967296;
+function readU64Safe(bc) {
+  const result = readU32(bc) + readU32(bc) * 4294967296;
   if (!isSafeU64(result)) {
     bc.offset -= 8;
     throw new BareError(bc.offset, TOO_LARGE_NUMBER);
   }
   return result;
 }
-function encodeU64Safe(bc, x) {
+function writeU64Safe(bc, x) {
   assert(isSafeU64(x), TOO_LARGE_NUMBER);
-  encodeU32(bc, x >>> 0);
-  encodeU32(bc, x / 4294967296 >>> 0);
+  writeU32(bc, x >>> 0);
+  writeU32(bc, x / 4294967296 >>> 0);
 }
 var UINT_MAX_BYTE_COUNT = 10;
-function decodeUint(bc) {
-  let byteCount = 0;
-  let byte;
-  let low = 0;
-  let shiftMul = 1;
-  do {
-    byte = decodeU8(bc);
-    low += (byte & 127) * shiftMul;
-    shiftMul *= 128;
-    byteCount++;
-  } while (byte >= 128 && byteCount < 7);
-  let height = 0;
-  shiftMul = 1;
-  while (byte >= 128 && byteCount < UINT_MAX_BYTE_COUNT) {
-    byte = decodeU8(bc);
-    height += (byte & 127) * shiftMul;
-    shiftMul *= 128;
-    byteCount++;
-  }
-  if (byteCount !== 1 && byte === 0 || byteCount === UINT_MAX_BYTE_COUNT && byte > 1) {
-    bc.offset -= byteCount;
-    throw new BareError(bc.offset, NON_CANONICAL_REPRESENTATION);
+function readUint(bc) {
+  let low = readU8(bc);
+  if (low >= 128) {
+    low &= 127;
+    let shiftMul = 128;
+    let byteCount = 1;
+    let byte;
+    do {
+      byte = readU8(bc);
+      low += (byte & 127) * shiftMul;
+      shiftMul *= 128;
+      byteCount++;
+    } while (byte >= 128 && byteCount < 7);
+    let height = 0;
+    shiftMul = 1;
+    while (byte >= 128 && byteCount < UINT_MAX_BYTE_COUNT) {
+      byte = readU8(bc);
+      height += (byte & 127) * shiftMul;
+      shiftMul *= 128;
+      byteCount++;
+    }
+    if (byte === 0 || byteCount === UINT_MAX_BYTE_COUNT && byte > 1) {
+      bc.offset -= byteCount;
+      throw new BareError(bc.offset, NON_CANONICAL_REPRESENTATION);
+    }
+    return BigInt(low) + (BigInt(height) << BigInt(7 * 7));
   }
-  return BigInt(low) + (BigInt(height) << BigInt(7 * 7));
+  return BigInt(low);
 }
-function encodeUint(bc, x) {
+function writeUint(bc, x) {
   assert(isU64(x), TOO_LARGE_NUMBER);
   let tmp = Number(BigInt.asUintN(7 * 7, x));
   let rest = Number(x >> BigInt(7 * 7));
   let byteCount = 0;
   while (tmp >= 128 || rest !== 0) {
-    encodeU8(bc, 128 | tmp & 127);
+    writeU8(bc, 128 | tmp & 127);
     tmp = Math.floor(tmp / 128);
     byteCount++;
     if (byteCount === 7) {
@@ -274,79 +278,82 @@ function encodeUint(bc, x) {
       rest = 0;
     }
   }
-  encodeU8(bc, tmp);
+  writeU8(bc, tmp);
 }
 var UINT_SAFE_MAX_BYTE_COUNT = 8;
-function decodeUintSafe(bc) {
-  let result = 0;
-  let shiftMul = 1;
-  let byteCount = 0;
-  let byte;
-  do {
-    byte = decodeU8(bc);
-    result += (byte & 127) * shiftMul;
-    shiftMul *= 128;
-    byteCount++;
-  } while (byte >= 128 && byteCount < UINT_SAFE_MAX_BYTE_COUNT);
-  if (byteCount !== 1 && byte === 0) {
-    bc.offset -= byteCount - 1;
-    throw new BareError(bc.offset - byteCount + 1, NON_CANONICAL_REPRESENTATION);
-  }
-  if (byteCount === UINT_SAFE_MAX_BYTE_COUNT && byte > 15) {
-    bc.offset -= byteCount - 1;
-    throw new BareError(bc.offset, TOO_LARGE_NUMBER);
+function readUintSafe(bc) {
+  let result = readU8(bc);
+  if (result >= 128) {
+    result &= 127;
+    let shiftMul = 128;
+    let byteCount = 1;
+    let byte;
+    do {
+      byte = readU8(bc);
+      result += (byte & 127) * shiftMul;
+      shiftMul *= 128;
+      byteCount++;
+    } while (byte >= 128 && byteCount < UINT_SAFE_MAX_BYTE_COUNT);
+    if (byte === 0) {
+      bc.offset -= byteCount - 1;
+      throw new BareError(bc.offset - byteCount + 1, NON_CANONICAL_REPRESENTATION);
+    }
+    if (byteCount === UINT_SAFE_MAX_BYTE_COUNT && byte > 15) {
+      bc.offset -= byteCount - 1;
+      throw new BareError(bc.offset, TOO_LARGE_NUMBER);
+    }
   }
   return result;
 }
-function encodeUintSafe(bc, x) {
+function writeUintSafe(bc, x) {
   assert(isSafeU64(x), TOO_LARGE_NUMBER);
   while (x >= 128) {
-    encodeU8(bc, 128 | x & 127);
+    writeU8(bc, 128 | x & 127);
     x = Math.floor(x / 128);
   }
-  encodeU8(bc, x);
+  writeU8(bc, x);
 }
-function decodeVoid(_dc) {
+function readVoid(_dc) {
   return void 0;
 }
-function encodeVoid(_dc, _x) {
+function writeVoid(_dc, _x) {
 }
 export {
-  decodeBool,
-  decodeF32,
-  decodeF64,
-  decodeI16,
-  decodeI32,
-  decodeI64,
-  decodeI64Safe,
-  decodeI8,
-  decodeInt,
-  decodeIntSafe,
-  decodeU16,
-  decodeU32,
-  decodeU64,
-  decodeU64Safe,
-  decodeU8,
-  decodeUint,
-  decodeUintSafe,
-  decodeVoid,
-  encodeBool,
-  encodeF32,
-  encodeF64,
-  encodeI16,
-  encodeI32,
-  encodeI64,
-  encodeI64Safe,
-  encodeI8,
-  encodeInt,
-  encodeIntSafe,
-  encodeU16,
-  encodeU32,
-  encodeU64,
-  encodeU64Safe,
-  encodeU8,
-  encodeUint,
-  encodeUintSafe,
-  encodeVoid
+  readBool,
+  readF32,
+  readF64,
+  readI16,
+  readI32,
+  readI64,
+  readI64Safe,
+  readI8,
+  readInt,
+  readIntSafe,
+  readU16,
+  readU32,
+  readU64,
+  readU64Safe,
+  readU8,
+  readUint,
+  readUintSafe,
+  readVoid,
+  writeBool,
+  writeF32,
+  writeF64,
+  writeI16,
+  writeI32,
+  writeI64,
+  writeI64Safe,
+  writeI8,
+  writeInt,
+  writeIntSafe,
+  writeU16,
+  writeU32,
+  writeU64,
+  writeU64Safe,
+  writeU8,
+  writeUint,
+  writeUintSafe,
+  writeVoid
 };
 //# sourceMappingURL=primitive.js.map

package/dist/codec/string.d.ts

@@ -1,3 +1,5 @@
 import type { ByteCursor } from "../core/index.js";
-export declare function decodeString(bc: ByteCursor): string;
-export declare function encodeString(bc: ByteCursor, x: string): void;
+export declare function readString(bc: ByteCursor): string;
+export declare function writeString(bc: ByteCursor, x: string): void;
+export declare function readFixedString(bc: ByteCursor, byteLen: number): string;
+export declare function writeFixedString(bc: ByteCursor, x: string): void;

package/dist/codec/string.js

@@ -1,111 +1,113 @@
 // src/codec/string.ts
 import { BareError } from "../core/bare-error.js";
-import { decodeUintSafe, encodeUintSafe } from "./primitive.js";
-function decodeString(bc) {
-  const strBytesLen = decodeUintSafe(bc);
-  const strBytes = bc.read(strBytesLen);
+import { readUintSafe, writeUintSafe } from "./primitive.js";
+import { writeU8FixedArray } from "./u8-array.js";
+var INVALID_UTF8_STRING = "invalid UTF-8 string";
+function readString(bc) {
+  return readFixedString(bc, readUintSafe(bc));
+}
+function writeString(bc, x) {
+  if (x.length < bc.config.textEncoderThreshold) {
+    const byteLen = utf8ByteLength(x);
+    writeUintSafe(bc, byteLen);
+    bc.reserve(byteLen);
+    writeUtf8Js(bc, x);
+  } else {
+    const strBytes = UTF8_ENCODER.encode(x);
+    writeUintSafe(bc, strBytes.length);
+    writeU8FixedArray(bc, strBytes);
+  }
+}
+function readFixedString(bc, byteLen) {
+  if (byteLen < bc.config.textDecoderThreshold) {
+    return readUtf8Js(bc, byteLen);
+  }
   try {
-    return strBytesLen < bc.config.textDecoderThreshold ? decodeUtf8Js(strBytes) : UTF8_DECODER.decode(strBytes);
+    return UTF8_DECODER.decode(bc.read(byteLen));
   } catch (cause) {
-    throw new BareError(bc.offset - strBytesLen, "invalid UTF-8 string", {
-      cause
-    });
+    throw new BareError(bc.offset, INVALID_UTF8_STRING);
   }
 }
-function encodeString(bc, x) {
+function writeFixedString(bc, x) {
   if (x.length < bc.config.textEncoderThreshold) {
     const byteLen = utf8ByteLength(x);
-    encodeUintSafe(bc, byteLen);
     bc.reserve(byteLen);
-    encodeUtf8Js(bc, x);
+    writeUtf8Js(bc, x);
   } else {
-    const strBytes = UTF8_ENCODER.encode(x);
-    encodeUintSafe(bc, strBytes.length);
-    bc.write(strBytes);
+    writeU8FixedArray(bc, UTF8_ENCODER.encode(x));
   }
 }
-function decodeUtf8Js(bytes) {
-  const bytesLen = bytes.length;
+function readUtf8Js(bc, byteLen) {
+  bc.check(byteLen);
   let result = "";
-  let i = 0;
-  while (i < bytesLen) {
-    let codePoint = bytes[i++] | 0;
-    switch (Math.clz32(~codePoint << 24)) {
-      case 0:
-        break;
-      case 2: {
-        if (i < bytesLen) {
-          codePoint = (codePoint & 31) << 6 | bytes[i] & 63;
-        }
-        if (codePoint >> 7 === 0 || bytes[i] >> 6 !== 2) {
-          throw TypeError("Decoding failed");
-        }
-        i += 1;
-        break;
+  const bytes = bc.bytes;
+  let offset = bc.offset;
+  const upperOffset = offset + byteLen;
+  while (offset < upperOffset) {
+    let codePoint = bytes[offset++];
+    if (codePoint > 127) {
+      let malformed = true;
+      const byte1 = codePoint;
+      if (offset < upperOffset && codePoint < 224) {
+        const byte2 = bytes[offset++];
+        codePoint = (byte1 & 31) << 6 | byte2 & 63;
+        malformed = codePoint >> 7 === 0 || byte1 >> 5 !== 6 || byte2 >> 6 !== 2;
+      } else if (offset + 1 < upperOffset && codePoint < 240) {
+        const byte2 = bytes[offset++];
+        const byte3 = bytes[offset++];
+        codePoint = (byte1 & 15) << 12 | (byte2 & 63) << 6 | byte3 & 63;
+        malformed = codePoint >> 11 === 0 || codePoint >> 11 === 27 || byte1 >> 4 !== 14 || byte2 >> 6 !== 2 || byte3 >> 6 !== 2;
+      } else if (offset + 2 < upperOffset) {
+        const byte2 = bytes[offset++];
+        const byte3 = bytes[offset++];
+        const byte4 = bytes[offset++];
+        codePoint = (byte1 & 7) << 18 | (byte2 & 63) << 12 | (byte3 & 63) << 6 | byte4 & 63;
+        malformed = codePoint >> 16 === 0 || codePoint > 1114111 || byte1 >> 3 !== 30 || byte2 >> 6 !== 2 || byte3 >> 6 !== 2 || byte4 >> 6 !== 2;
       }
-      case 3: {
-        if (i + 1 < bytesLen) {
-          codePoint = (codePoint & 15) << 12 | (bytes[i] & 63) << 6 | bytes[i + 1] & 63;
-        }
-        if (codePoint >> 11 === 0 || bytes[i] >> 6 !== 2 || bytes[i + 1] >> 6 !== 2 || codePoint >> 11 === 27) {
-          throw TypeError("Decoding failed");
-        }
-        i += 2;
-        break;
+      if (malformed) {
+        throw new BareError(bc.offset, INVALID_UTF8_STRING);
       }
-      case 4: {
-        if (i + 2 < bytesLen) {
-          codePoint = (codePoint & 7) << 18 | (bytes[i] & 63) << 12 | (bytes[i + 1] & 63) << 6 | bytes[i + 2] & 63;
-        }
-        if (codePoint >> 16 === 0 || codePoint > 1114111 || bytes[i] >> 6 !== 2 || bytes[i + 1] >> 6 !== 2 || bytes[i + 2] >> 6 !== 2) {
-          throw TypeError("Decoding failed");
-        }
-        i += 3;
-        break;
-      }
-      default:
-        throw TypeError("Decoding failed");
     }
     result += String.fromCodePoint(codePoint);
   }
+  bc.offset = offset;
   return result;
 }
-function encodeUtf8Js(bc, s) {
-  const sLen = s.length;
+function writeUtf8Js(bc, s) {
+  const bytes = bc.bytes;
   let offset = bc.offset;
-  const view = bc.view;
   let i = 0;
-  while (i < sLen) {
+  while (i < s.length) {
     const codePoint = s.codePointAt(i++);
     if (codePoint < 128) {
-      view.setUint8(offset++, codePoint);
-    } else if (codePoint < 2048) {
-      view.setUint8(offset++, 192 | codePoint >> 6);
-      view.setUint8(offset++, 128 | codePoint & 63);
-    } else if (codePoint < 65536) {
-      view.setUint8(offset++, 224 | codePoint >> 12);
-      view.setUint8(offset++, 128 | codePoint >> 6 & 63);
-      view.setUint8(offset++, 128 | codePoint & 63);
+      bytes[offset++] = codePoint;
     } else {
-      view.setUint8(offset++, 240 | codePoint >> 18);
-      view.setUint8(offset++, 128 | codePoint >> 12 & 63);
-      view.setUint8(offset++, 128 | codePoint >> 6 & 63);
-      view.setUint8(offset++, 128 | codePoint & 63);
-      i++;
+      if (codePoint < 2048) {
+        bytes[offset++] = 192 | codePoint >> 6;
+      } else {
+        if (codePoint < 65536) {
+          bytes[offset++] = 224 | codePoint >> 12;
+        } else {
+          bytes[offset++] = 240 | codePoint >> 18;
+          bytes[offset++] = 128 | codePoint >> 12 & 63;
+          i++;
+        }
+        bytes[offset++] = 128 | codePoint >> 6 & 63;
+      }
+      bytes[offset++] = 128 | codePoint & 63;
     }
   }
   bc.offset = offset;
 }
 function utf8ByteLength(s) {
-  const sLen = s.length;
-  let result = sLen;
-  for (let i = 0; i < sLen; i++) {
+  let result = s.length;
+  for (let i = 0; i < s.length; i++) {
     const codePoint = s.codePointAt(i);
-    if (codePoint >= 128) {
+    if (codePoint > 127) {
       result++;
-      if (codePoint >= 2048) {
+      if (codePoint > 2047) {
         result++;
-        if (codePoint >= 65536) {
+        if (codePoint > 65535) {
           i++;
         }
       }
@@ -116,7 +118,9 @@ function utf8ByteLength(s) {
 var UTF8_DECODER = new TextDecoder("utf-8", { fatal: true });
 var UTF8_ENCODER = new TextEncoder();
 export {
-  decodeString,
-  encodeString
+  readFixedString,
+  readString,
+  writeFixedString,
+  writeString
 };
 //# sourceMappingURL=string.js.map