typia 6.10.2-dev.20240920 → 6.10.2

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

package/src/functional/IProtobufWriter.ts

@@ -1,18 +1,18 @@
-export interface IProtobufWriter {
-  bool(value: boolean): void;
-  int32(value: number): void;
-  sint32(value: number): void;
-  uint32(value: number): void;
-
-  int64(value: bigint | number): void;
-  sint64(value: bigint | number): void;
-  uint64(value: bigint | number): void;
-
-  float(value: number): void;
-  double(value: number): void;
-  bytes(value: Uint8Array): void;
-  string(value: string): void;
-
-  fork(): void;
-  ldelim(): void;
-}
+export interface IProtobufWriter {
+  bool(value: boolean): void;
+  int32(value: number): void;
+  sint32(value: number): void;
+  uint32(value: number): void;
+
+  int64(value: bigint | number): void;
+  sint64(value: bigint | number): void;
+  uint64(value: bigint | number): void;
+
+  float(value: number): void;
+  double(value: number): void;
+  bytes(value: Uint8Array): void;
+  string(value: string): void;
+
+  fork(): void;
+  ldelim(): void;
+}

package/src/functional/Namespace/functional.ts

@@ -1,5 +1,5 @@
-import { TypeGuardError } from "../../TypeGuardError";
-
-export const functionalAssert = () => ({
-  errorFactory: (p: TypeGuardError.IProps) => new TypeGuardError(p),
-});
+import { TypeGuardError } from "../../TypeGuardError";
+
+export const functionalAssert = () => ({
+  errorFactory: (p: TypeGuardError.IProps) => new TypeGuardError(p),
+});

package/src/functional/Namespace/http.ts

@@ -1,9 +1,9 @@
-import { $FormDataReader } from "../$FormDataReader";
-import { $HeadersReader } from "../$HeadersReader";
-import { $ParameterReader } from "../$ParameterReader";
-import { $QueryReader } from "../$QueryReader";
-
-export const formData = () => $FormDataReader;
-export const headers = () => $HeadersReader;
-export const parameter = () => $ParameterReader;
-export const query = () => $QueryReader;
+import { $FormDataReader } from "../$FormDataReader";
+import { $HeadersReader } from "../$HeadersReader";
+import { $ParameterReader } from "../$ParameterReader";
+import { $QueryReader } from "../$QueryReader";
+
+export const formData = () => $FormDataReader;
+export const headers = () => $HeadersReader;
+export const parameter = () => $ParameterReader;
+export const query = () => $QueryReader;

package/src/functional/Namespace/index.ts

@@ -1,77 +1,77 @@
-import { RandomGenerator } from "../../utils/RandomGenerator";
-
-import { $every } from "../$every";
-import { $guard } from "../$guard";
-import { $join } from "../$join";
-import { $report } from "../$report";
-import { IValidation } from "../../IValidation";
-import { TypeGuardError } from "../../TypeGuardError";
-import { is } from "../is";
-
-export * as functional from "./functional";
-export * as json from "./json";
-export * as http from "./http";
-export * as notations from "./notations";
-export * as misc from "./misc";
-export * as protobuf from "./protobuf";
-export * as llm from "./llm";
-
-export { is };
-
-export const assert = (method: string) => ({
-  ...is(),
-  join: $join,
-  every: $every,
-  guard: $guard(`typia.${method}`),
-  predicate: (
-    matched: boolean,
-    exceptionable: boolean,
-    closure: () => Omit<TypeGuardError.IProps, "method">,
-  ): boolean => {
-    if (matched === false && exceptionable === true)
-      throw new TypeGuardError({
-        ...closure(),
-        method: `typia.${method}`,
-      });
-    return matched;
-  },
-});
-
-export const validate = () => ({
-  ...is(),
-  join: $join,
-  report: $report,
-  predicate:
-    (res: IValidation) =>
-    (
-      matched: boolean,
-      exceptionable: boolean,
-      closure: () => IValidation.IError,
-    ) => {
-      // CHECK FAILURE
-      if (matched === false && exceptionable === true)
-        (() => {
-          res.success &&= false;
-          const errorList = (res as IValidation.IFailure).errors;
-
-          // TRACE ERROR
-          const error = closure();
-          if (errorList.length) {
-            const last = errorList[errorList.length - 1]!.path;
-            if (
-              last.length >= error.path.length &&
-              last.substring(0, error.path.length) === error.path
-            )
-              return;
-          }
-          errorList.push(error);
-          return;
-        })();
-      return matched;
-    },
-});
-
-export const random = () => ({
-  generator: RandomGenerator,
-  pick: RandomGenerator.pick,
-});
+import { RandomGenerator } from "../../utils/RandomGenerator";
+
+import { $every } from "../$every";
+import { $guard } from "../$guard";
+import { $join } from "../$join";
+import { $report } from "../$report";
+import { IValidation } from "../../IValidation";
+import { TypeGuardError } from "../../TypeGuardError";
+import { is } from "../is";
+
+export * as functional from "./functional";
+export * as json from "./json";
+export * as http from "./http";
+export * as notations from "./notations";
+export * as misc from "./misc";
+export * as protobuf from "./protobuf";
+export * as llm from "./llm";
+
+export { is };
+
+export const assert = (method: string) => ({
+  ...is(),
+  join: $join,
+  every: $every,
+  guard: $guard(`typia.${method}`),
+  predicate: (
+    matched: boolean,
+    exceptionable: boolean,
+    closure: () => Omit<TypeGuardError.IProps, "method">,
+  ): boolean => {
+    if (matched === false && exceptionable === true)
+      throw new TypeGuardError({
+        ...closure(),
+        method: `typia.${method}`,
+      });
+    return matched;
+  },
+});
+
+export const validate = () => ({
+  ...is(),
+  join: $join,
+  report: $report,
+  predicate:
+    (res: IValidation) =>
+    (
+      matched: boolean,
+      exceptionable: boolean,
+      closure: () => IValidation.IError,
+    ) => {
+      // CHECK FAILURE
+      if (matched === false && exceptionable === true)
+        (() => {
+          res.success &&= false;
+          const errorList = (res as IValidation.IFailure).errors;
+
+          // TRACE ERROR
+          const error = closure();
+          if (errorList.length) {
+            const last = errorList[errorList.length - 1]!.path;
+            if (
+              last.length >= error.path.length &&
+              last.substring(0, error.path.length) === error.path
+            )
+              return;
+          }
+          errorList.push(error);
+          return;
+        })();
+      return matched;
+    },
+});
+
+export const random = () => ({
+  generator: RandomGenerator,
+  pick: RandomGenerator.pick,
+});

package/src/functional/Namespace/json.ts

@@ -1,15 +1,15 @@
-import { $number } from "../$number";
-import { $rest } from "../$rest";
-import { $string } from "../$string";
-import { $tail } from "../$tail";
-import { $throws } from "../$throws";
-import { is } from "../is";
-
-export const stringify = (method: string) => ({
-  ...is(),
-  number: $number,
-  string: $string,
-  tail: $tail,
-  rest: $rest,
-  throws: $throws(`json.${method}`),
-});
+import { $number } from "../$number";
+import { $rest } from "../$rest";
+import { $string } from "../$string";
+import { $tail } from "../$tail";
+import { $throws } from "../$throws";
+import { is } from "../is";
+
+export const stringify = (method: string) => ({
+  ...is(),
+  number: $number,
+  string: $string,
+  tail: $tail,
+  rest: $rest,
+  throws: $throws(`json.${method}`),
+});

package/src/functional/Namespace/llm.ts

@@ -1,20 +1,20 @@
-import { ILlmApplication } from "@samchon/openapi";
-
-import { LlmSchemaSeparator } from "@samchon/openapi/lib/utils/LlmSchemaSeparator";
-
-export const application = () => ({
-  finalize: (
-    app: ILlmApplication,
-    options?: ILlmApplication.IOptions,
-  ): void => {
-    app.options = {
-      separate: options?.separate ?? null,
-    };
-    if (app.options.separate === null) return;
-    for (const func of app.functions)
-      func.separated = LlmSchemaSeparator.parameters({
-        parameters: func.parameters,
-        predicator: app.options.separate,
-      });
-  },
-});
+import { ILlmApplication } from "@samchon/openapi";
+
+import { LlmSchemaSeparator } from "@samchon/openapi/lib/utils/LlmSchemaSeparator";
+
+export const application = () => ({
+  finalize: (
+    app: ILlmApplication,
+    options?: ILlmApplication.IOptions,
+  ): void => {
+    app.options = {
+      separate: options?.separate ?? null,
+    };
+    if (app.options.separate === null) return;
+    for (const func of app.functions)
+      func.separated = LlmSchemaSeparator.parameters({
+        parameters: func.parameters,
+        predicator: app.options.separate,
+      });
+  },
+});

package/src/functional/Namespace/misc.ts

@@ -1,14 +1,14 @@
-import { $any } from "../$any";
-import { $throws } from "../$throws";
-import { is } from "../is";
-
-export const clone = (method: string) => ({
-  ...is(),
-  throws: $throws(`misc.${method}`),
-  any: $any,
-});
-
-export const prune = (method: string) => ({
-  ...is(),
-  throws: $throws(`misc.${method}`),
-});
+import { $any } from "../$any";
+import { $throws } from "../$throws";
+import { is } from "../is";
+
+export const clone = (method: string) => ({
+  ...is(),
+  throws: $throws(`misc.${method}`),
+  any: $any,
+});
+
+export const prune = (method: string) => ({
+  ...is(),
+  throws: $throws(`misc.${method}`),
+});