typia 5.0.0-dev.20230820-2 → 5.0.0-dev.20230821

package/src/functional/$ProtobufWriter.ts

@@ -1,152 +1,152 @@
-import { $ProtobufSizer } from "./$ProtobufSizer";
-import { IProtobufWriter } from "./IProtobufWriter";
-
-export class $ProtobufWriter implements IProtobufWriter {
-    /**
-     * Related sizer
-     */
-    private readonly sizer: $ProtobufSizer;
-
-    /**
-     * Current pointer.
-     */
-    private ptr: number;
-
-    /**
-     * Protobuf buffer.
-     */
-    private buf: Uint8Array;
-
-    /**
-     * DataView for buffer.
-     */
-    private view: DataView;
-
-    /**
-     * Index in varlen array from sizer.
-     */
-    private varlenidx: number;
-
-    constructor(sizer: $ProtobufSizer) {
-        this.sizer = sizer;
-        this.buf = new Uint8Array(sizer.len);
-        this.view = new DataView(this.buf.buffer);
-        this.ptr = 0;
-        this.varlenidx = 0;
-    }
-
-    buffer(): Uint8Array {
-        return this.buf;
-    }
-
-    bool(value: boolean): void {
-        this.byte(value ? 1 : 0);
-    }
-
-    byte(value: number): void {
-        this.buf[this.ptr++] = value & 255;
-    }
-
-    int32(value: number): void {
-        if (value < 0) this.int64(value);
-        else this.variant32(value >>> 0);
-    }
-
-    sint32(value: number): void {
-        this.variant32((value << 1) ^ (value >> 31));
-    }
-
-    uint32(value: number): void {
-        this.variant32(value);
-    }
-
-    sint64(value: number | bigint): void {
-        value = BigInt(value);
-        this.variant64((value << ND01) ^ (value >> ND63));
-    }
-
-    int64(value: number | bigint): void {
-        this.variant64(BigInt(value));
-    }
-
-    uint64(value: number | bigint): void {
-        this.variant64(BigInt(value));
-    }
-
-    float(val: number): void {
-        this.view.setFloat32(this.ptr, val, true);
-        this.ptr += 4;
-    }
-
-    double(val: number): void {
-        this.view.setFloat64(this.ptr, val, true);
-        this.ptr += 8;
-    }
-
-    bytes(value: Uint8Array): void {
-        this.fork();
-        this.uint32(value.byteLength);
-        for (let i = 0; i < value.byteLength; i++)
-            this.buf[this.ptr++] = value[i]!;
-    }
-
-    string(value: string): void {
-        const len: number = this.varlen(); // use precomputed length
-        this.uint32(len);
-
-        const binary: Uint8Array = utf8.encode(value);
-        for (let i = 0; i < binary.byteLength; i++)
-            this.buf[this.ptr++] = binary[i]!;
-    }
-
-    fork(): void {
-        this.uint32(this.varlen()); // use precomputed length
-    }
-
-    ldelim(): void {
-        // nothing to do - all dirty work done by sizer
-    }
-
-    finish(): Uint8Array {
-        return this.buf;
-    }
-
-    reset(): void {
-        this.buf = new Uint8Array(this.sizer.len);
-        this.view = new DataView(this.buf.buffer);
-        this.ptr = 0;
-        this.varlenidx = 0;
-    }
-
-    private variant32(val: number): void {
-        while (val > 0x7f) {
-            this.buf[this.ptr++] = (val & 0x7f) | 0x80;
-            val = val >>> 7;
-        }
-        this.buf[this.ptr++] = val;
-    }
-
-    private variant64(val: bigint): void {
-        val = BigInt.asUintN(64, val);
-        while (val > NX7F) {
-            this.buf[this.ptr++] = Number((val & NX7F) | NX80);
-            val = val >> ND07; // @todo
-            // (val / (128n) % 2n === 1n)
-        }
-        this.buf[this.ptr++] = Number(val);
-    }
-
-    private varlen(): number {
-        return this.varlenidx >= this.sizer.varlen.length
-            ? 0
-            : this.sizer.varlen[this.varlenidx++]!;
-    }
-}
-
-const utf8 = new TextEncoder();
-
-const ND01 = BigInt(1);
-const ND07 = BigInt(7);
-const ND63 = BigInt(63);
-const NX7F = BigInt(0x7f);
-const NX80 = BigInt(0x80);
+import { $ProtobufSizer } from "./$ProtobufSizer";
+import { IProtobufWriter } from "./IProtobufWriter";
+
+export class $ProtobufWriter implements IProtobufWriter {
+    /**
+     * Related sizer
+     */
+    private readonly sizer: $ProtobufSizer;
+
+    /**
+     * Current pointer.
+     */
+    private ptr: number;
+
+    /**
+     * Protobuf buffer.
+     */
+    private buf: Uint8Array;
+
+    /**
+     * DataView for buffer.
+     */
+    private view: DataView;
+
+    /**
+     * Index in varlen array from sizer.
+     */
+    private varlenidx: number;
+
+    constructor(sizer: $ProtobufSizer) {
+        this.sizer = sizer;
+        this.buf = new Uint8Array(sizer.len);
+        this.view = new DataView(this.buf.buffer);
+        this.ptr = 0;
+        this.varlenidx = 0;
+    }
+
+    buffer(): Uint8Array {
+        return this.buf;
+    }
+
+    bool(value: boolean): void {
+        this.byte(value ? 1 : 0);
+    }
+
+    byte(value: number): void {
+        this.buf[this.ptr++] = value & 255;
+    }
+
+    int32(value: number): void {
+        if (value < 0) this.int64(value);
+        else this.variant32(value >>> 0);
+    }
+
+    sint32(value: number): void {
+        this.variant32((value << 1) ^ (value >> 31));
+    }
+
+    uint32(value: number): void {
+        this.variant32(value);
+    }
+
+    sint64(value: number | bigint): void {
+        value = BigInt(value);
+        this.variant64((value << ND01) ^ (value >> ND63));
+    }
+
+    int64(value: number | bigint): void {
+        this.variant64(BigInt(value));
+    }
+
+    uint64(value: number | bigint): void {
+        this.variant64(BigInt(value));
+    }
+
+    float(val: number): void {
+        this.view.setFloat32(this.ptr, val, true);
+        this.ptr += 4;
+    }
+
+    double(val: number): void {
+        this.view.setFloat64(this.ptr, val, true);
+        this.ptr += 8;
+    }
+
+    bytes(value: Uint8Array): void {
+        this.fork();
+        this.uint32(value.byteLength);
+        for (let i = 0; i < value.byteLength; i++)
+            this.buf[this.ptr++] = value[i]!;
+    }
+
+    string(value: string): void {
+        const len: number = this.varlen(); // use precomputed length
+        this.uint32(len);
+
+        const binary: Uint8Array = utf8.encode(value);
+        for (let i = 0; i < binary.byteLength; i++)
+            this.buf[this.ptr++] = binary[i]!;
+    }
+
+    fork(): void {
+        this.uint32(this.varlen()); // use precomputed length
+    }
+
+    ldelim(): void {
+        // nothing to do - all dirty work done by sizer
+    }
+
+    finish(): Uint8Array {
+        return this.buf;
+    }
+
+    reset(): void {
+        this.buf = new Uint8Array(this.sizer.len);
+        this.view = new DataView(this.buf.buffer);
+        this.ptr = 0;
+        this.varlenidx = 0;
+    }
+
+    private variant32(val: number): void {
+        while (val > 0x7f) {
+            this.buf[this.ptr++] = (val & 0x7f) | 0x80;
+            val = val >>> 7;
+        }
+        this.buf[this.ptr++] = val;
+    }
+
+    private variant64(val: bigint): void {
+        val = BigInt.asUintN(64, val);
+        while (val > NX7F) {
+            this.buf[this.ptr++] = Number((val & NX7F) | NX80);
+            val = val >> ND07; // @todo
+            // (val / (128n) % 2n === 1n)
+        }
+        this.buf[this.ptr++] = Number(val);
+    }
+
+    private varlen(): number {
+        return this.varlenidx >= this.sizer.varlen.length
+            ? 0
+            : this.sizer.varlen[this.varlenidx++]!;
+    }
+}
+
+const utf8 = new TextEncoder();
+
+const ND01 = BigInt(1);
+const ND07 = BigInt(7);
+const ND63 = BigInt(63);
+const NX7F = BigInt(0x7f);
+const NX80 = BigInt(0x80);

package/src/functional/$number.ts

@@ -1,13 +1,13 @@
-import { TypeGuardError } from "../TypeGuardError";
-
-export const $number = (value: number): number => {
-    if (isFinite(value) === false)
-        throw new TypeGuardError({
-            method: "typia.json.stringify",
-            expected: "number",
-            value,
-            message:
-                "Error on typia.json.stringify(): infinite or not a number.",
-        });
-    return value;
-};
+import { TypeGuardError } from "../TypeGuardError";
+
+export const $number = (value: number): number => {
+    if (isFinite(value) === false)
+        throw new TypeGuardError({
+            method: "typia.json.stringify",
+            expected: "number",
+            value,
+            message:
+                "Error on typia.json.stringify(): infinite or not a number.",
+        });
+    return value;
+};

package/src/functional/$strlen.ts

@@ -1,7 +1,7 @@
-export const $strlen = (s: string): number => {
-    let b: number;
-    let i: number;
-    let c: number;
-    for (b = i = 0; (c = s.charCodeAt(i++)); b += c >> 11 ? 3 : c >> 7 ? 2 : 1);
-    return b;
-};
+export const $strlen = (s: string): number => {
+    let b: number;
+    let i: number;
+    let c: number;
+    for (b = i = 0; (c = s.charCodeAt(i++)); b += c >> 11 ? 3 : c >> 7 ? 2 : 1);
+    return b;
+};

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;
+}