typia 13.1.1 → 13.2.0

package/src/internal/_isFormatUriReference.ts

@@ -2,4 +2,4 @@ export const _isFormatUriReference = (str: string): boolean =>
   PATTERN.test(str);
 
 const PATTERN =
-  /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
+  /^(?:(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?)?|(?:[a-z][a-z0-9+\-.]*:)(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|(?:[a-z0-9\-._~!$&'()*+,;=@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;

package/src/internal/_isMultipleOf.ts

@@ -0,0 +1,8 @@
+import { _decimalDecompose, _decimalDivide } from "./_decimal";
+
+export const _isMultipleOf = (value: number, multipleOf: number): boolean => {
+  const divisor = _decimalDecompose(multipleOf);
+  if (divisor === null || divisor.coefficient <= BigInt(0)) return false;
+  const ratio = _decimalDivide(value, divisor);
+  return ratio !== null && ratio.numerator % ratio.denominator === BigInt(0);
+};

package/src/internal/_isTypeFloat.ts

@@ -1,5 +1,5 @@
 export const _isTypeFloat = (value: number): boolean =>
   MINIMUM <= value && value <= MAXIMUM;
 
-const MINIMUM = -1.175494351e38;
+const MINIMUM = -3.4028235e38;
 const MAXIMUM = 3.4028235e38;

package/src/internal/_isTypeInt64.ts

@@ -1,5 +1,6 @@
 export const _isTypeInt64 = (value: number): boolean =>
   Math.floor(value) === value && MINIMUM <= value && value <= MAXIMUM;
 
+// The maximum is `2 ** 63 - 1`, the int64 upper bound.
 const MINIMUM = -(2 ** 63);
 const MAXIMUM = 2 ** 63 - 1;

package/src/internal/_isTypeInt64Bigint.ts

@@ -0,0 +1,12 @@
+export const _isTypeInt64Bigint = (value: bigint): boolean =>
+  MINIMUM <= value && value <= MAXIMUM;
+
+// Unlike the `number` path, a `bigint` represents both bounds exactly, so this
+// is the true inclusive int64 range rather than an exclusive approximation.
+//
+// The arguments must stay strings. `BigInt(9223372036854775807)` rounds its
+// `number` literal to `2 ** 63` before `BigInt` ever sees it, which is the
+// defect this helper exists to close; `BigInt("9223372036854775807")` parses
+// the digits directly and is exact.
+const MINIMUM = -BigInt("9223372036854775808");
+const MAXIMUM = BigInt("9223372036854775807");

package/src/internal/_isTypeUint64.ts

@@ -1,5 +1,6 @@
 export const _isTypeUint64 = (value: number): boolean =>
   Math.floor(value) === value && MINIMUM <= value && value <= MAXIMUM;
 
+// The maximum is `2 ** 64 - 1`, the uint64 upper bound.
 const MINIMUM = 0;
 const MAXIMUM = 2 ** 64 - 1;

package/src/internal/_isTypeUint64Bigint.ts

@@ -0,0 +1,7 @@
+export const _isTypeUint64Bigint = (value: bigint): boolean =>
+  MINIMUM <= value && value <= MAXIMUM;
+
+// See `_isTypeInt64Bigint`: the bound is exact only because the argument is a
+// string, and `bigint` can represent the true inclusive maximum.
+const MINIMUM = BigInt(0);
+const MAXIMUM = BigInt("18446744073709551615");

package/src/internal/_isUniqueItems.ts

@@ -1,12 +1,4 @@
 export const _isUniqueItems = (elements: any[]): boolean => {
-  // EMPTY OR ONLY ONE
-  if (elements.length < 2) return true;
-
-  // SHALLOW COMPARISON
-  if (["boolean", "bigint", "number", "string"].includes(typeof elements[0]))
-    return new Set(elements).size === elements.length;
-
-  // DEEP COMPARISON
   for (let i = 0; i < elements.length; i++)
     for (let j = i + 1; j < elements.length; j++)
       if (equals(new WeakMap())(elements[i], elements[j])) return false;
@@ -15,145 +7,155 @@ export const _isUniqueItems = (elements: any[]): boolean => {
 
 const equals = (visited: WeakMap<object, WeakMap<object, boolean>>) => {
   const next = (a: any, b: any): boolean => {
-    // SHALLOW EQUAL
     if (a === b) return true;
-    else if (typeof a !== typeof b || typeof a !== "object") return false;
-    // COMPARE CONTAINERS
-    else if (Array.isArray(a))
-      return Array.isArray(b) && a.map((x, i) => next(x, b[i])).every((x) => x);
-    else if (a instanceof Set)
+    if (
+      a === null ||
+      b === null ||
+      typeof a !== "object" ||
+      typeof b !== "object"
+    )
+      return false;
+
+    const previous: boolean | undefined = visited.get(a)?.get(b);
+    if (previous !== undefined) return previous;
+    const pairs: WeakMap<object, boolean> =
+      visited.get(a) ?? new WeakMap<object, boolean>();
+    visited.set(a, pairs);
+    pairs.set(b, true);
+
+    const result: boolean = compare(a, b);
+    pairs.set(b, result);
+    return result;
+  };
+
+  const compare = (a: object, b: object): boolean => {
+    if (Array.isArray(a)) {
+      if (!Array.isArray(b) || a.length !== b.length) return false;
+      for (let i = 0; i < a.length; i++) {
+        const aHas: boolean = Object.hasOwn(a, i);
+        if (aHas !== Object.hasOwn(b, i) || (aHas && !next(a[i], b[i])))
+          return false;
+      }
+      return true;
+    }
+    if (Array.isArray(b)) return false;
+
+    if (a instanceof Set) {
+      if (!(b instanceof Set) || a.size !== b.size) return false;
+      const unmatched: any[] = [...b];
+      for (const value of a) {
+        const index: number = unmatched.findIndex((candidate) =>
+          next(value, candidate),
+        );
+        if (index === -1) return false;
+        unmatched.splice(index, 1);
+      }
+      return true;
+    }
+    if (a instanceof Map) {
+      if (!(b instanceof Map) || a.size !== b.size) return false;
+      const unmatched: [any, any][] = [...b];
+      for (const [key, value] of a) {
+        const index: number = unmatched.findIndex(
+          ([candidateKey, candidateValue]) =>
+            next(key, candidateKey) && next(value, candidateValue),
+        );
+        if (index === -1) return false;
+        unmatched.splice(index, 1);
+      }
+      return true;
+    }
+
+    if (a instanceof Boolean)
+      return b instanceof Boolean && a.valueOf() === b.valueOf();
+    if (Object.prototype.toString.call(a) === "[object BigInt]")
       return (
-        b instanceof Set && a.size === b.size && [...a].every((x) => b.has(x))
+        Object.prototype.toString.call(b) === "[object BigInt]" &&
+        a.valueOf() === b.valueOf()
       );
-    else if (a instanceof Map)
+    if (Object.prototype.toString.call(a) === "[object Symbol]")
       return (
-        b instanceof Map &&
-        a.size === b.size &&
-        [...a].every(([k, v]) => b.has(k) && next(v, b.get(k)))
+        Object.prototype.toString.call(b) === "[object Symbol]" &&
+        a.valueOf() === b.valueOf()
       );
-    // ATOMIC CLASSES
-    else if (a instanceof Boolean)
-      return b instanceof Boolean
-        ? a.valueOf() === b.valueOf()
-        : a.valueOf() === b;
-    else if (a instanceof BigInt)
-      return b instanceof BigInt ? a === b : a === BigInt(b);
-    else if (a instanceof Number)
-      return b instanceof Number
-        ? a.valueOf() === b.valueOf()
-        : a.valueOf() === b;
-    else if (a instanceof String)
-      return b instanceof String
-        ? a.valueOf() === b.valueOf()
-        : a.valueOf() === b;
-    else if (a instanceof Date)
+    if (a instanceof Number)
+      return b instanceof Number && a.valueOf() === b.valueOf();
+    if (a instanceof String)
+      return b instanceof String && a.valueOf() === b.valueOf();
+    if (a instanceof Date)
       return b instanceof Date && a.getTime() === b.getTime();
-    // BINARY DATA
-    else if (a instanceof Uint8Array)
+    if (a instanceof RegExp)
       return (
-        b instanceof Uint8Array &&
-        a.length === b.length &&
-        a.every((x, i) => x === b[i])
+        b instanceof RegExp && a.source === b.source && a.flags === b.flags
       );
-    else if (a instanceof Uint8ClampedArray)
-      return (
-        b instanceof Uint8ClampedArray &&
-        a.length === b.length &&
-        a.every((x, i) => x === b[i])
-      );
-    else if (a instanceof Uint16Array)
-      return (
-        b instanceof Uint16Array &&
-        a.length === b.length &&
-        a.every((x, i) => x === b[i])
-      );
-    else if (a instanceof Uint32Array)
-      return (
-        b instanceof Uint32Array &&
-        a.length === b.length &&
-        a.every((x, i) => x === b[i])
-      );
-    else if (a instanceof BigUint64Array)
-      return (
-        b instanceof BigUint64Array &&
-        a.length === b.length &&
-        a.every((x, i) => x === b[i])
-      );
-    else if (a instanceof Int8Array)
-      return (
-        b instanceof Int8Array &&
-        a.length === b.length &&
-        a.every((x, i) => x === b[i])
-      );
-    else if (a instanceof Int16Array)
-      return (
-        b instanceof Int16Array &&
-        a.length === b.length &&
-        a.every((x, i) => x === b[i])
-      );
-    else if (a instanceof Int32Array)
-      return (
-        b instanceof Int32Array &&
-        a.length === b.length &&
-        a.every((x, i) => x === b[i])
-      );
-    else if (a instanceof BigInt64Array)
-      return (
-        b instanceof BigInt64Array &&
-        a.length === b.length &&
-        a.every((x, i) => x === b[i])
-      );
-    else if (a instanceof Float32Array)
-      return (
-        b instanceof Float32Array &&
-        a.length === b.length &&
-        a.every((x, i) => x === b[i])
-      );
-    else if (a instanceof Float64Array)
-      return (
-        b instanceof Float64Array &&
-        a.length === b.length &&
-        a.every((x, i) => x === b[i])
-      );
-    else if (a instanceof ArrayBuffer) {
-      if (!(b instanceof ArrayBuffer) || a.byteLength !== b.byteLength)
-        return false;
-      const x: Uint8Array = new Uint8Array(a);
-      const y: Uint8Array = new Uint8Array(b);
-      return x.every((v, i) => v === y[i]);
-    } else if (a instanceof SharedArrayBuffer) {
-      if (!(b instanceof SharedArrayBuffer) || a.byteLength !== b.byteLength)
-        return false;
-      const x: Uint8Array = new Uint8Array(a);
-      const y: Uint8Array = new Uint8Array(b);
-      return x.every((v, i) => v === y[i]);
-    } else if (a instanceof DataView) {
-      if (!(b instanceof DataView) || a.byteLength !== b.byteLength)
-        return false;
-      const x: Uint8Array = new Uint8Array(a.buffer);
-      const y: Uint8Array = new Uint8Array(b.buffer);
-      return x.every((v, i) => v === y[i]);
-    } else if (a instanceof File)
+
+    if (typeof File !== "undefined" && a instanceof File)
       return (
         b instanceof File &&
         a.name === b.name &&
         a.size === b.size &&
         a.type === b.type &&
-        next(a.slice(), b.slice())
+        a.lastModified === b.lastModified
       );
-    // JUST PLAIN OBJECTS
-    else if (a !== null && b !== null) {
-      if (visited.has(a) && visited.get(a)!.has(b))
-        return visited.get(a)!.get(b)!;
-      if (!visited.has(a)) visited.set(a, new WeakMap());
-      visited.get(a)!.set(b, true);
-      const res: boolean =
-        Object.keys(a).length === Object.keys(b).length &&
-        Object.keys(a).every((x) => next(a[x], b[x]));
-      visited.get(a)!.set(b, res);
-      return res;
+    if (typeof Blob !== "undefined" && a instanceof Blob)
+      return b instanceof Blob && a.size === b.size && a.type === b.type;
+
+    if (a instanceof DataView) {
+      if (!(b instanceof DataView) || a.byteLength !== b.byteLength)
+        return false;
+      return bytes(a.buffer, a.byteOffset, a.byteLength).every(
+        (value, index) =>
+          value === bytes(b.buffer, b.byteOffset, b.byteLength)[index],
+      );
+    }
+    if (ArrayBuffer.isView(a)) {
+      if (
+        !ArrayBuffer.isView(b) ||
+        b instanceof DataView ||
+        Object.getPrototypeOf(a) !== Object.getPrototypeOf(b) ||
+        a.byteLength !== b.byteLength
+      )
+        return false;
+      const x: Uint8Array = bytes(a.buffer, a.byteOffset, a.byteLength);
+      const y: Uint8Array = bytes(b.buffer, b.byteOffset, b.byteLength);
+      return x.every((value, index) => value === y[index]);
     }
-    return false;
+    if (a instanceof ArrayBuffer)
+      return (
+        b instanceof ArrayBuffer &&
+        a.byteLength === b.byteLength &&
+        bytes(a).every((value, index) => value === bytes(b)[index])
+      );
+    if (
+      typeof SharedArrayBuffer !== "undefined" &&
+      a instanceof SharedArrayBuffer
+    )
+      return (
+        b instanceof SharedArrayBuffer &&
+        a.byteLength === b.byteLength &&
+        bytes(a).every((value, index) => value === bytes(b)[index])
+      );
+
+    const keys: PropertyKey[] = Reflect.ownKeys(a).filter((key) =>
+      Object.prototype.propertyIsEnumerable.call(a, key),
+    );
+    return (
+      keys.length ===
+        Reflect.ownKeys(b).filter((key) =>
+          Object.prototype.propertyIsEnumerable.call(b, key),
+        ).length &&
+      keys.every(
+        (key) =>
+          Object.prototype.propertyIsEnumerable.call(b, key) &&
+          next((a as any)[key], (b as any)[key]),
+      )
+    );
   };
   return next;
 };
+
+const bytes = (
+  buffer: ArrayBufferLike,
+  byteOffset: number = 0,
+  byteLength: number = buffer.byteLength,
+): Uint8Array => new Uint8Array(buffer, byteOffset, byteLength);

package/src/internal/_jsonStringifyArray.ts

@@ -0,0 +1,50 @@
+/**
+ * Serializes the elements of an array the way ECMAScript `JSON.stringify` does.
+ *
+ * `SerializeJSONArray` walks index `0` to `LengthOfArrayLike(value) - 1` and
+ * writes `null` wherever the element serializes to `undefined`. Neither
+ * `Array.prototype.map` nor `Array.prototype.join` reproduces that:
+ *
+ * - `map` never visits a hole and leaves one behind, and `join` renders a hole as
+ *   empty text, so a sparse array joined into malformed text such as `[,1]`. A
+ *   hole exists at runtime whatever the element type declares, so this is not
+ *   an `any` concern.
+ * - `join` renders a mapped `undefined` as empty text too, which is what an `any`
+ *   or `unknown` element holding a function, a symbol, or a `toJSON` that
+ *   returns nothing serializes to.
+ *
+ * The length is converted with `ToLength` and read once, which is both what
+ * `JSON.stringify` does and what `Array.prototype.every` - the traversal
+ * typia's own array checkers emit - does, so the checker and the serializer
+ * walk one index range rather than two that merely usually coincide.
+ *
+ * @param elements Array being serialized.
+ * @param mapper Serializer of one element, emitted by the transform.
+ * @returns Comma separated element text, without the enclosing brackets.
+ * @internal
+ */
+export const _jsonStringifyArray = <T>(
+  elements: ArrayLike<T>,
+  mapper: (elem: T, index: number) => string,
+): string => {
+  const length: number = Math.min(
+    Math.max(Math.trunc(elements.length) || 0, 0),
+    Number.MAX_SAFE_INTEGER,
+  );
+  let output: string = "";
+  for (let i: number = 0; i < length; ++i) {
+    const elem: T | undefined = elements[i];
+    // A hole and an explicit `undefined` are answered without calling the
+    // mapper, because the mapper is the element type's own serializer and a
+    // typed one has no answer for a missing value. Everything else is answered
+    // from the mapper's *result*: an element that is present but serializes to
+    // nothing — a function, a symbol, or a `toJSON` returning nothing in an
+    // `any` slot — is `null` in an array position, exactly as
+    // SerializeJSONArray specifies, and testing the input instead would let its
+    // text become the literal `undefined`.
+    const text: string | undefined =
+      elem === undefined ? undefined : mapper(elem, i);
+    output += (i === 0 ? "" : ",") + (text === undefined ? "null" : text);
+  }
+  return output;
+};

package/src/internal/_jsonStringifyElement.ts

@@ -0,0 +1,19 @@
+/**
+ * Writes one array or tuple element the way ECMAScript `JSON.stringify` writes
+ * it.
+ *
+ * `SerializeJSONArray` writes `null` wherever an element serializes to
+ * `undefined`, because an array position cannot be omitted without shifting
+ * every element after it. A present value with no serialization — a function, a
+ * symbol, or a `toJSON` returning nothing — is therefore `null`, not the
+ * literal text `undefined` and not an empty slot.
+ *
+ * This is the fixed-position counterpart of `_jsonStringifyArray`, which
+ * answers the same question while walking an array's own index range.
+ *
+ * @param text Serialized element value, or `undefined` when it has none.
+ * @returns Element text, or `null` when the element has no serialization.
+ * @internal
+ */
+export const _jsonStringifyElement = (text: string | undefined): string =>
+  text === undefined ? "null" : text;

package/src/internal/_jsonStringifyProperty.ts

@@ -0,0 +1,30 @@
+/**
+ * Writes one object member the way ECMAScript `JSON.stringify` writes it.
+ *
+ * `SerializeJSONObject` serializes each member first and drops the member
+ * entirely when that result is `undefined`. Deciding omission from the _input_
+ * instead cannot reach the same answer: a symbol and a `toJSON` returning
+ * nothing are both present, non-`undefined`, non-function values whose
+ * serialization is `undefined`, so the member's text became the literal
+ * `"k":undefined` — output that is not JSON at all.
+ *
+ * The serialized text is passed in already evaluated, so the member's value is
+ * serialized exactly once. Testing the input and then serializing would
+ * evaluate a `toJSON` twice, and a `toJSON` is free to answer differently each
+ * call.
+ *
+ * The trailing separator belongs to the member because a dropped member must
+ * take its comma with it; `_jsonStringifyTail` removes the one that is left
+ * behind when the last written member is the one that dropped.
+ *
+ * @param head Quoted key and colon, emitted by the transform.
+ * @param text Serialized member value, or `undefined` when it has none.
+ * @param tail Separator following this member, empty for the last one.
+ * @returns Member text, or an empty string when the member is omitted.
+ * @internal
+ */
+export const _jsonStringifyProperty = (
+  head: string,
+  text: string | undefined,
+  tail: string,
+): string => (text === undefined ? "" : head + text + tail);

package/src/internal/_llmApplicationFinalize.ts

@@ -7,7 +7,12 @@ export const _llmApplicationFinalize = <Class extends object = any>(
 ): ILlmApplication<Class> => ({
   ...app,
   config: {
-    ...LlmSchemaConverter.getConfig(),
+    // The schema configuration comes from the emitted application, which is
+    // where the `Config` generic was resolved. Rebuilding it from the
+    // converter's defaults reported `strict: false` for a strict build, and
+    // `@typia/mcp` then inverted a strict output schema without strict, which
+    // drops every constraint it carries as a description tag (issue #2293).
+    ...LlmSchemaConverter.getConfig(app.config),
     validate: config?.validate ?? null,
   },
   functions: app.functions.map((func) => ({

package/src/internal/_notationAny.ts

@@ -1,3 +1,5 @@
+import { _notationAssign } from "./_notationAssign";
+
 export const _notationAny = (rename: (str: string) => string) => {
   const main = (input: any): any => {
     if (typeof input === "object")
@@ -29,9 +31,12 @@ export const _notationAny = (rename: (str: string) => string) => {
       else return object(input);
     return input;
   };
-  const object = (input: Record<string, any>) =>
-    Object.fromEntries(
-      Object.entries(input).map(([key, value]) => [rename(key), main(value)]),
-    );
+  const object = (input: Record<string, any>) => {
+    const output: Record<string, any> = {};
+    const sources: Record<string, string> = Object.create(null);
+    for (const [key, value] of Object.entries(input))
+      _notationAssign(output, sources, key, main(value), rename);
+    return output;
+  };
   return main;
 };

package/src/internal/_notationAssign.ts

@@ -0,0 +1,20 @@
+import { _notationKeyCollision } from "./_notationKeyCollision";
+
+export const _notationAssign = (
+  output: Record<string, any>,
+  sources: Record<string, string>,
+  source: string,
+  value: any,
+  rename: (str: string) => string,
+): void => {
+  const destination: string = rename(source);
+  if (Object.hasOwn(output, destination))
+    _notationKeyCollision(sources[destination]!, source, destination);
+  Object.defineProperty(output, destination, {
+    configurable: true,
+    enumerable: true,
+    value,
+    writable: true,
+  });
+  sources[destination] = source;
+};

package/src/internal/_notationCamel.ts

@@ -1,13 +1,34 @@
-import { __notationCapitalize } from "./private/__notationCapitalize";
-import { __notationUnsnake } from "./private/__notationUnsnake";
+import { __notationRename } from "./private/__notationRename";
 
-export const _notationCamel = __notationUnsnake({
+const _notationCamelSnake = (str: string): string => {
+  while (str.startsWith("_")) str = str.substring(1);
+  if (str.length === 0) return "";
+  const index: number = str.indexOf("_");
+  if (index < 0) return str.toLowerCase();
+  const middle: string | undefined = str[index + 1];
+  // A trailing underscore has no character to uppercase, so `CamelizeSnakeString`
+  // falls through to lowercasing the whole key (`foo_` -> `foo_`).
+  if (middle === undefined) return str.toLowerCase();
+  // A doubled underscore collapses to a single one before continuing.
+  return middle === "_"
+    ? _notationCamelSnake(
+        `${str.substring(0, index)}_${str.substring(index + 2)}`,
+      )
+    : `${str
+        .substring(0, index)
+        .toLowerCase()}${middle.toUpperCase()}${_notationCamelSnake(
+        str.substring(index + 2),
+      )}`;
+};
+
+export const _notationCamel = __notationRename({
+  // `CamelCase<T>` lowercases an all-caps key and otherwise lowercases only the
+  // first character of an underscore-free key (`HTTP` -> `http`, `userID` stays).
   plain: (str) =>
-    str.length
-      ? str === str.toUpperCase()
-        ? str.toLocaleLowerCase()
-        : `${str[0]!.toLowerCase()}${str.substring(1)}`
-      : str,
-  snake: (str, i) =>
-    i === 0 ? str.toLowerCase() : __notationCapitalize(str.toLowerCase()),
+    str === str.toUpperCase()
+      ? str.toLowerCase()
+      : `${str[0]!.toLowerCase()}${str.substring(1)}`,
+  // With an underscore present, the character after each underscore is
+  // uppercased and the rest lowercased, matching `CamelizeSnakeString`.
+  snake: _notationCamelSnake,
 });

package/src/internal/_notationKebab.ts

@@ -0,0 +1,11 @@
+import { _notationSnake } from "./_notationSnake";
+
+export const _notationKebab = (str: string): string => {
+  let snaked: string = _notationSnake(str);
+  let prefix: string = "";
+  while (snaked.startsWith("_")) {
+    prefix += "_";
+    snaked = snaked.substring(1);
+  }
+  return `${prefix}${snaked.replaceAll("_", "-")}`;
+};

package/src/internal/_notationKeyCollision.ts

@@ -0,0 +1,9 @@
+export const _notationKeyCollision = (
+  first: string,
+  second: string,
+  destination: string,
+): never => {
+  throw new Error(
+    `typia.notations cannot rename both ${JSON.stringify(first)} and ${JSON.stringify(second)} to ${JSON.stringify(destination)}.`,
+  );
+};

package/src/internal/_notationPascal.ts

@@ -1,8 +1,21 @@
-import { __notationCapitalize } from "./private/__notationCapitalize";
-import { __notationUnsnake } from "./private/__notationUnsnake";
+import { __notationRename } from "./private/__notationRename";
 
-export const _notationPascal = __notationUnsnake({
-  plain: (str) =>
-    str.length ? `${str[0]!.toUpperCase()}${str.substring(1)}` : str,
-  snake: __notationCapitalize,
+const _notationPascalSnake = (str: string): string => {
+  while (str.startsWith("_")) str = str.substring(1);
+  if (str.length === 0) return "";
+  const index: number = str.indexOf("_");
+  return index < 0
+    ? `${str[0]!.toUpperCase()}${str.substring(1).toLowerCase()}`
+    : `${str[0]!.toUpperCase()}${str
+        .substring(1, index)
+        .toLowerCase()}${_notationPascalSnake(str.substring(index + 1))}`;
+};
+
+export const _notationPascal = __notationRename({
+  // `PascalCase<T>` capitalizes the first character of an underscore-free key
+  // and keeps the rest verbatim (`userID` -> `UserID`).
+  plain: (str) => `${str[0]!.toUpperCase()}${str.substring(1)}`,
+  // With an underscore present, each segment is capitalized and its tail is
+  // lowercased (`MAX_COUNT` -> `MaxCount`), matching `PascalizeSnakeString`.
+  snake: _notationPascalSnake,
 });