typia 5.0.0-dev.20230711 → 5.0.0-dev.20230713

package/src/functional/$proto_i64.ts

@@ -1,37 +1,37 @@
-export function $proto_i64_encode(
-    dst: Uint8Array,
-    offset: number,
-    value: bigint,
-): number {
-    value = BigInt.asUintN(64, value);
-
-    dst[offset] = Number(value & BigInt(0xff));
-    dst[offset + 1] = Number((value >> BigInt(8)) & BigInt(0xff));
-    dst[offset + 2] = Number((value >> BigInt(16)) & BigInt(0xff));
-    dst[offset + 3] = Number((value >> BigInt(24)) & BigInt(0xff));
-    dst[offset + 4] = Number((value >> BigInt(32)) & BigInt(0xff));
-    dst[offset + 5] = Number((value >> BigInt(40)) & BigInt(0xff));
-    dst[offset + 6] = Number((value >> BigInt(48)) & BigInt(0xff));
-    dst[offset + 7] = Number((value >> BigInt(56)) & BigInt(0xff));
-    offset += 8;
-
-    return offset;
-}
-
-export function $proto_i64_decode(
-    buf: Uint8Array,
-    offset: number,
-): [value: bigint, offset: number] {
-    const value =
-        (BigInt(buf[offset]!) << BigInt(0)) |
-        (BigInt(buf[offset + 1]!) << BigInt(8)) |
-        (BigInt(buf[offset + 2]!) << BigInt(16)) |
-        (BigInt(buf[offset + 3]!) << BigInt(24)) |
-        (BigInt(buf[offset + 4]!) << BigInt(32)) |
-        (BigInt(buf[offset + 5]!) << BigInt(40)) |
-        (BigInt(buf[offset + 6]!) << BigInt(48)) |
-        (BigInt(buf[offset + 7]!) << BigInt(56));
-    offset += 8;
-
-    return [BigInt.asIntN(64, value), offset];
-}
+export function $proto_i64_encode(
+    dst: Uint8Array,
+    offset: number,
+    value: bigint,
+): number {
+    value = BigInt.asUintN(64, value);
+
+    dst[offset] = Number(value & BigInt(0xff));
+    dst[offset + 1] = Number((value >> BigInt(8)) & BigInt(0xff));
+    dst[offset + 2] = Number((value >> BigInt(16)) & BigInt(0xff));
+    dst[offset + 3] = Number((value >> BigInt(24)) & BigInt(0xff));
+    dst[offset + 4] = Number((value >> BigInt(32)) & BigInt(0xff));
+    dst[offset + 5] = Number((value >> BigInt(40)) & BigInt(0xff));
+    dst[offset + 6] = Number((value >> BigInt(48)) & BigInt(0xff));
+    dst[offset + 7] = Number((value >> BigInt(56)) & BigInt(0xff));
+    offset += 8;
+
+    return offset;
+}
+
+export function $proto_i64_decode(
+    buf: Uint8Array,
+    offset: number,
+): [value: bigint, offset: number] {
+    const value =
+        (BigInt(buf[offset]!) << BigInt(0)) |
+        (BigInt(buf[offset + 1]!) << BigInt(8)) |
+        (BigInt(buf[offset + 2]!) << BigInt(16)) |
+        (BigInt(buf[offset + 3]!) << BigInt(24)) |
+        (BigInt(buf[offset + 4]!) << BigInt(32)) |
+        (BigInt(buf[offset + 5]!) << BigInt(40)) |
+        (BigInt(buf[offset + 6]!) << BigInt(48)) |
+        (BigInt(buf[offset + 7]!) << BigInt(56));
+    offset += 8;
+
+    return [BigInt.asIntN(64, value), offset];
+}

package/src/functional/$proto_size.ts

@@ -1,82 +1,82 @@
-import { $proto_field_wiretype } from "./$proto_field";
-
-export function $proto_size_varint(n: number): number;
-export function $proto_size_varint(n: bigint): number;
-
-export function $proto_size_varint(n: number | bigint): number {
-    if (typeof n === "number") {
-        if (n < 0) {
-            return SizeVarInt64(BigInt(n));
-        }
-        return SizeVarInt32(n);
-    }
-
-    return SizeVarInt64(n);
-}
-
-export function $proto_size_field(
-    fieldNumber: number,
-    wireType: $proto_field_wiretype,
-): number {
-    const tag = (fieldNumber << 3) | Number(wireType);
-    return $proto_size_varint(tag);
-}
-
-export function $proto_size_bytes(len: number): number {
-    return $proto_size_varint(len) + len;
-}
-
-const utf8_encoder = new TextEncoder();
-
-export function $proto_size_string(value: string): number {
-    // TODO: optimize (DON'T ENCODE TEXT TWICE)
-    const bytes = utf8_encoder.encode(value);
-    return $proto_size_bytes(bytes.length);
-}
-
-function SizeVarInt32(value: number): number {
-    value = (value | 0) >>> 0; // 32-bit integer
-    // TODO: optimize ( branchless solution exists )
-    // TODO: try lookup table based solution
-
-    if (value <= 127) {
-        return 1;
-    } else if (value <= 16383) {
-        return 2;
-    } else if (value <= 2097151) {
-        return 3;
-    } else if (value <= 268435455) {
-        return 4;
-    }
-
-    // < 34359738367
-    return 5;
-}
-
-function SizeVarInt64(value: bigint): number {
-    value = BigInt.asUintN(64, value);
-    // TODO: optimize ( branchless solution exists )
-    // TODO: try lookup table based solution
-
-    if (value <= BigInt("127")) {
-        return 1;
-    } else if (value <= BigInt("16383")) {
-        return 2;
-    } else if (value <= BigInt("2097151")) {
-        return 3;
-    } else if (value <= BigInt("268435455")) {
-        return 4;
-    } else if (value <= BigInt("34359738367")) {
-        return 5;
-    } else if (value <= BigInt("4398046511103")) {
-        return 6;
-    } else if (value <= BigInt("562949953421311")) {
-        return 7;
-    } else if (value <= BigInt("72057594037927935")) {
-        return 8;
-    } else if (value <= BigInt("9223372036854775807")) {
-        return 9;
-    }
-
-    return 10;
-}
+import { $proto_field_wiretype } from "./$proto_field";
+
+export function $proto_size_varint(n: number): number;
+export function $proto_size_varint(n: bigint): number;
+
+export function $proto_size_varint(n: number | bigint): number {
+    if (typeof n === "number") {
+        if (n < 0) {
+            return SizeVarInt64(BigInt(n));
+        }
+        return SizeVarInt32(n);
+    }
+
+    return SizeVarInt64(n);
+}
+
+export function $proto_size_field(
+    fieldNumber: number,
+    wireType: $proto_field_wiretype,
+): number {
+    const tag = (fieldNumber << 3) | Number(wireType);
+    return $proto_size_varint(tag);
+}
+
+export function $proto_size_bytes(len: number): number {
+    return $proto_size_varint(len) + len;
+}
+
+const utf8_encoder = new TextEncoder();
+
+export function $proto_size_string(value: string): number {
+    // TODO: optimize (DON'T ENCODE TEXT TWICE)
+    const bytes = utf8_encoder.encode(value);
+    return $proto_size_bytes(bytes.length);
+}
+
+function SizeVarInt32(value: number): number {
+    value = (value | 0) >>> 0; // 32-bit integer
+    // TODO: optimize ( branchless solution exists )
+    // TODO: try lookup table based solution
+
+    if (value <= 127) {
+        return 1;
+    } else if (value <= 16383) {
+        return 2;
+    } else if (value <= 2097151) {
+        return 3;
+    } else if (value <= 268435455) {
+        return 4;
+    }
+
+    // < 34359738367
+    return 5;
+}
+
+function SizeVarInt64(value: bigint): number {
+    value = BigInt.asUintN(64, value);
+    // TODO: optimize ( branchless solution exists )
+    // TODO: try lookup table based solution
+
+    if (value <= BigInt("127")) {
+        return 1;
+    } else if (value <= BigInt("16383")) {
+        return 2;
+    } else if (value <= BigInt("2097151")) {
+        return 3;
+    } else if (value <= BigInt("268435455")) {
+        return 4;
+    } else if (value <= BigInt("34359738367")) {
+        return 5;
+    } else if (value <= BigInt("4398046511103")) {
+        return 6;
+    } else if (value <= BigInt("562949953421311")) {
+        return 7;
+    } else if (value <= BigInt("72057594037927935")) {
+        return 8;
+    } else if (value <= BigInt("9223372036854775807")) {
+        return 9;
+    }
+
+    return 10;
+}

package/src/functional/$proto_string.ts

@@ -1,24 +1,24 @@
-import { $proto_bytes_decode, $proto_bytes_encode } from "./$proto_bytes";
-
-const utf8_encoder = new TextEncoder();
-
-export function $proto_string_encode(
-    dst: Uint8Array,
-    offset: number,
-    value: string,
-): number {
-    // TODO: optimize (DON'T ENCODE TEXT TWICE)
-
-    const bytes = utf8_encoder.encode(value);
-    return $proto_bytes_encode(dst, offset, bytes);
-}
-
-export function $proto_string_decode(
-    src: Uint8Array,
-    offset: number,
-): [value: string, offset: number] {
-    const utf8_decoder = new TextDecoder("utf-8");
-    const [bytes, o] = $proto_bytes_decode(src, offset);
-    const value = utf8_decoder.decode(bytes);
-    return [value, o];
-}
+import { $proto_bytes_decode, $proto_bytes_encode } from "./$proto_bytes";
+
+const utf8_encoder = new TextEncoder();
+
+export function $proto_string_encode(
+    dst: Uint8Array,
+    offset: number,
+    value: string,
+): number {
+    // TODO: optimize (DON'T ENCODE TEXT TWICE)
+
+    const bytes = utf8_encoder.encode(value);
+    return $proto_bytes_encode(dst, offset, bytes);
+}
+
+export function $proto_string_decode(
+    src: Uint8Array,
+    offset: number,
+): [value: string, offset: number] {
+    const utf8_decoder = new TextDecoder("utf-8");
+    const [bytes, o] = $proto_bytes_decode(src, offset);
+    const value = utf8_decoder.decode(bytes);
+    return [value, o];
+}

package/src/functional/$varint.ts

@@ -1,130 +1,130 @@
-function EncodeVarNumber(
-    dst: Uint8Array,
-    offset: number,
-    value: number,
-): number {
-    value = (value | 0) >>> 0; // 32-bit integer
-
-    while (value > 127) {
-        dst[offset++] = (value & 0b01111111) | 0b10000000;
-        value >>>= 7;
-    }
-    dst[offset++] = value;
-
-    return offset;
-}
-
-function DecodeVarNumber(
-    buf: Uint8Array,
-    offset: number,
-): [value: number, offset: number] {
-    let value = 0;
-    let shift = 0;
-
-    while (true) {
-        const byte = buf[offset++]!;
-        value |= (byte & 0b01111111) << shift;
-        if (byte < 128) {
-            break;
-        }
-        shift += 7;
-    }
-
-    return [value | 0, offset];
-}
-
-function DecodeVarBigInt(
-    buf: Uint8Array,
-    offset: number,
-): [value: bigint, offset: number] {
-    let value = BigInt(0);
-    let shift = BigInt(0);
-
-    while (true) {
-        const byte = buf[offset++]!;
-        value |= BigInt(byte & 0b01111111) << shift;
-        if (byte < 128) {
-            break;
-        }
-        shift += BigInt(7);
-    }
-
-    return [BigInt.asIntN(64, value), offset];
-}
-
-export function $varint_decode_i32(
-    buf: Uint8Array,
-    offset: number,
-): [value: number, offset: number] {
-    const [v, o] = DecodeVarNumber(buf, offset);
-    return [v, o];
-}
-
-export function $varint_decode_u32(
-    buf: Uint8Array,
-    offset: number,
-): [value: number, offset: number] {
-    const [v, o] = DecodeVarNumber(buf, offset);
-    return [v >>> 0, o];
-}
-
-export function $varint_decode_i64(
-    buf: Uint8Array,
-    offset: number,
-): [value: bigint, offset: number] {
-    const [v, o] = DecodeVarBigInt(buf, offset);
-    return [v, o];
-}
-
-export function $varint_decode_u64(
-    buf: Uint8Array,
-    offset: number,
-): [value: bigint, offset: number] {
-    const [v, o] = DecodeVarBigInt(buf, offset);
-    return [BigInt.asUintN(64, v), o];
-}
-
-function EncodeVarBigInt(
-    dst: Uint8Array,
-    offset: number,
-    value: bigint,
-): number {
-    value = BigInt.asUintN(64, value);
-
-    while (value > BigInt(127)) {
-        dst[offset++] = Number(value & BigInt(0b01111111)) | 0b10000000;
-        value >>= BigInt(7);
-    }
-    dst[offset++] = Number(value);
-
-    return offset;
-}
-
-export function $varint_encode(
-    dst: Uint8Array,
-    offset: number,
-    value: number,
-): number;
-export function $varint_encode(
-    dst: Uint8Array,
-    offset: number,
-    value: bigint,
-): number;
-
-export function $varint_encode(
-    dst: Uint8Array,
-    offset: number,
-    value: number | bigint,
-): number {
-    if (typeof value === "bigint") {
-        offset = EncodeVarBigInt(dst, offset, value);
-    } else {
-        if (value < 0) {
-            // NOTE: Protocol Buffers signed varint encoding uses two's complement of 64-bit unsigned integers.
-            offset = EncodeVarBigInt(dst, offset, BigInt(value));
-        } else {
-            offset = EncodeVarNumber(dst, offset, value);
-        }
-    }
-    return offset;
-}
+function EncodeVarNumber(
+    dst: Uint8Array,
+    offset: number,
+    value: number,
+): number {
+    value = (value | 0) >>> 0; // 32-bit integer
+
+    while (value > 127) {
+        dst[offset++] = (value & 0b01111111) | 0b10000000;
+        value >>>= 7;
+    }
+    dst[offset++] = value;
+
+    return offset;
+}
+
+function DecodeVarNumber(
+    buf: Uint8Array,
+    offset: number,
+): [value: number, offset: number] {
+    let value = 0;
+    let shift = 0;
+
+    while (true) {
+        const byte = buf[offset++]!;
+        value |= (byte & 0b01111111) << shift;
+        if (byte < 128) {
+            break;
+        }
+        shift += 7;
+    }
+
+    return [value | 0, offset];
+}
+
+function DecodeVarBigInt(
+    buf: Uint8Array,
+    offset: number,
+): [value: bigint, offset: number] {
+    let value = BigInt(0);
+    let shift = BigInt(0);
+
+    while (true) {
+        const byte = buf[offset++]!;
+        value |= BigInt(byte & 0b01111111) << shift;
+        if (byte < 128) {
+            break;
+        }
+        shift += BigInt(7);
+    }
+
+    return [BigInt.asIntN(64, value), offset];
+}
+
+export function $varint_decode_i32(
+    buf: Uint8Array,
+    offset: number,
+): [value: number, offset: number] {
+    const [v, o] = DecodeVarNumber(buf, offset);
+    return [v, o];
+}
+
+export function $varint_decode_u32(
+    buf: Uint8Array,
+    offset: number,
+): [value: number, offset: number] {
+    const [v, o] = DecodeVarNumber(buf, offset);
+    return [v >>> 0, o];
+}
+
+export function $varint_decode_i64(
+    buf: Uint8Array,
+    offset: number,
+): [value: bigint, offset: number] {
+    const [v, o] = DecodeVarBigInt(buf, offset);
+    return [v, o];
+}
+
+export function $varint_decode_u64(
+    buf: Uint8Array,
+    offset: number,
+): [value: bigint, offset: number] {
+    const [v, o] = DecodeVarBigInt(buf, offset);
+    return [BigInt.asUintN(64, v), o];
+}
+
+function EncodeVarBigInt(
+    dst: Uint8Array,
+    offset: number,
+    value: bigint,
+): number {
+    value = BigInt.asUintN(64, value);
+
+    while (value > BigInt(127)) {
+        dst[offset++] = Number(value & BigInt(0b01111111)) | 0b10000000;
+        value >>= BigInt(7);
+    }
+    dst[offset++] = Number(value);
+
+    return offset;
+}
+
+export function $varint_encode(
+    dst: Uint8Array,
+    offset: number,
+    value: number,
+): number;
+export function $varint_encode(
+    dst: Uint8Array,
+    offset: number,
+    value: bigint,
+): number;
+
+export function $varint_encode(
+    dst: Uint8Array,
+    offset: number,
+    value: number | bigint,
+): number {
+    if (typeof value === "bigint") {
+        offset = EncodeVarBigInt(dst, offset, value);
+    } else {
+        if (value < 0) {
+            // NOTE: Protocol Buffers signed varint encoding uses two's complement of 64-bit unsigned integers.
+            offset = EncodeVarBigInt(dst, offset, BigInt(value));
+        } else {
+            offset = EncodeVarNumber(dst, offset, value);
+        }
+    }
+    return offset;
+}

package/src/functional/$zigzag.ts

@@ -1,39 +1,39 @@
-export function $zigzag_encode(value: number): number;
-export function $zigzag_encode(value: bigint): bigint;
-export function $zigzag_encode(value: number | bigint): any {
-    // TODO: optimize (branchless solution exists)
-
-    if (typeof value === "bigint") {
-        if (value < BigInt(0)) {
-            value = -value;
-            return value * BigInt(2) - BigInt(1);
-        }
-        return value * BigInt(2);
-    }
-
-    if (value < 0) {
-        value = -value;
-        return value * 2 - 1;
-    }
-    return value * 2;
-}
-
-export function $zigzag_decode(value: number): number;
-export function $zigzag_decode(value: bigint): bigint;
-export function $zigzag_decode(value: number | bigint): any {
-    // TODO: optimize (branchless solution exists)
-
-    if (typeof value === "bigint") {
-        value = BigInt.asUintN(64, value);
-        if (value & BigInt(1)) {
-            return -(value + BigInt(1)) / BigInt(2);
-        }
-        return value / BigInt(2);
-    }
-
-    value = value >>> 0;
-    if (value & 1) {
-        return -(value + 1) / 2;
-    }
-    return value / 2;
-}
+export function $zigzag_encode(value: number): number;
+export function $zigzag_encode(value: bigint): bigint;
+export function $zigzag_encode(value: number | bigint): any {
+    // TODO: optimize (branchless solution exists)
+
+    if (typeof value === "bigint") {
+        if (value < BigInt(0)) {
+            value = -value;
+            return value * BigInt(2) - BigInt(1);
+        }
+        return value * BigInt(2);
+    }
+
+    if (value < 0) {
+        value = -value;
+        return value * 2 - 1;
+    }
+    return value * 2;
+}
+
+export function $zigzag_decode(value: number): number;
+export function $zigzag_decode(value: bigint): bigint;
+export function $zigzag_decode(value: number | bigint): any {
+    // TODO: optimize (branchless solution exists)
+
+    if (typeof value === "bigint") {
+        value = BigInt.asUintN(64, value);
+        if (value & BigInt(1)) {
+            return -(value + BigInt(1)) / BigInt(2);
+        }
+        return value / BigInt(2);
+    }
+
+    value = value >>> 0;
+    if (value & 1) {
+        return -(value + 1) / 2;
+    }
+    return value / 2;
+}