typia 13.1.19 → 13.2.0

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/_randomFormatByte.ts

@@ -1,6 +1,33 @@
-import { _ILengthProps, _randomFormatLength } from "./_randomStringLength";
+import { _randomString } from "./_randomString";
+import {
+  _ILengthProps,
+  _RANDOM_LENGTH_ERROR,
+  _randomLengthPick,
+  _randomLengthWindow,
+} from "./_randomStringLength";
 
-export const _randomFormatByte = (props?: _ILengthProps): string =>
-  _randomFormatLength(props, () => FIXED);
+export const _randomFormatByte = (props?: _ILengthProps): string => {
+  if (props?.minLength === undefined && props?.maxLength === undefined)
+    return FIXED;
+  // Base64 encodes three bytes as four characters, so a valid length is always
+  // a multiple of four; the window is raised to the first multiple it contains
+  // and the draw steps by four from there. Every character `_randomString`
+  // emits is in the base64 alphabet, so the result needs no padding.
+  const window = _randomLengthWindow(props, { minimum: 0, spread: 16 });
+  const low: number = Math.ceil(window.low / 4) * 4;
+  if (low > window.high) throw new Error(_RANDOM_LENGTH_ERROR);
+  const length: number =
+    low +
+    4 *
+      _randomLengthPick({
+        low: 0,
+        high: Math.floor((window.high - low) / 4),
+      });
+  return _randomString({
+    type: "string",
+    minLength: length,
+    maxLength: length,
+  });
+};
 
 const FIXED = "vt7ekz4lIoNTTS9sDQYdWKharxIFAR54+z/umIxSgUM=";

package/src/internal/_randomFormatDate.ts

@@ -1,23 +1,7 @@
-import { _randomInteger } from "./_randomInteger";
-import { _randomFormatLength } from "./_randomStringLength";
+import { _ILengthProps, _randomFormatLength } from "./_randomStringLength";
+import { __IEpochProps, __randomEpoch } from "./private/__randomEpoch";
 
-export const _randomFormatDate = (props?: {
-  minimum?: number;
-  maximum?: number;
-  minLength?: number;
-  maxLength?: number;
-}) =>
+export const _randomFormatDate = (props?: __IEpochProps & _ILengthProps) =>
   _randomFormatLength(props, () =>
-    new Date(
-      _randomInteger({
-        type: "integer",
-        minimum: props?.minimum ?? 0,
-        maximum:
-          (props?.maximum ?? props?.minimum === undefined)
-            ? Date.now()
-            : props.minimum + 365 * 24 * 60 * 60 * 1_000,
-      }),
-    )
-      .toISOString()
-      .substring(0, 10),
+    new Date(__randomEpoch(props)).toISOString().substring(0, 10),
   );

package/src/internal/_randomFormatDatetime.ts

@@ -1,21 +1,35 @@
-import { _randomInteger } from "./_randomInteger";
-import { _randomFormatLength } from "./_randomStringLength";
+import {
+  _ILengthProps,
+  _RANDOM_LENGTH_ERROR,
+  _randomLengthPick,
+  _randomLengthWindow,
+} from "./_randomStringLength";
+import { __randomDigits } from "./private/__randomComposition";
+import { __IEpochProps, __randomEpoch } from "./private/__randomEpoch";
 
-export const _randomFormatDatetime = (props?: {
-  minimum?: number;
-  maximum?: number;
-  minLength?: number;
-  maxLength?: number;
-}) =>
-  _randomFormatLength(props, () =>
-    new Date(
-      _randomInteger({
-        type: "integer",
-        minimum: props?.minimum ?? 0,
-        maximum:
-          (props?.maximum ?? props?.minimum === undefined)
-            ? Date.now()
-            : props.minimum + 365 * 24 * 60 * 60 * 1_000,
-      }),
-    ).toISOString(),
-  );
+export const _randomFormatDatetime = (
+  props?: __IEpochProps & _ILengthProps,
+) => {
+  const instant = (): string => new Date(__randomEpoch(props)).toISOString();
+  if (props?.minLength === undefined && props?.maxLength === undefined)
+    return instant();
+  // `YYYY-MM-DDTHH:MM:SS` plus `Z` is the shortest instant, and a fractional
+  // second grows it one digit at a time. Because that fraction needs both a dot
+  // and at least one digit, 21 is the single length between the two forms that
+  // no instant can have.
+  const window = _randomLengthWindow(props, {
+    minimum: SECONDS + 1,
+    spread: 8,
+  });
+  let length: number = _randomLengthPick(window);
+  if (length === SECONDS + 2)
+    length = window.high >= SECONDS + 3 ? SECONDS + 3 : SECONDS + 1;
+  if (length < window.low || length > window.high)
+    throw new Error(_RANDOM_LENGTH_ERROR);
+  const base: string = instant().substring(0, SECONDS);
+  return length === SECONDS + 1
+    ? `${base}Z`
+    : `${base}.${__randomDigits(length - SECONDS - 2)}Z`;
+};
+
+const SECONDS = "0000-00-00T00:00:00".length;

package/src/internal/_randomFormatDuration.ts

@@ -1,8 +1,13 @@
 import { _randomInteger } from "./_randomInteger";
-import { _ILengthProps, _randomFormatLength } from "./_randomStringLength";
+import {
+  _ILengthProps,
+  _randomLengthPick,
+  _randomLengthWindow,
+} from "./_randomStringLength";
+import { __randomNumeric } from "./private/__randomComposition";
 
-export const _randomFormatDuration = (props?: _ILengthProps): string =>
-  _randomFormatLength(props, () => {
+export const _randomFormatDuration = (props?: _ILengthProps): string => {
+  if (props?.minLength === undefined && props?.maxLength === undefined) {
     const period: string = durate([
       ["Y", random(0, 100)],
       ["M", random(0, 12)],
@@ -15,7 +20,17 @@ export const _randomFormatDuration = (props?: _ILengthProps): string =>
     ]);
     if (period.length + time.length === 0) return "PT0S";
     return `P${period}${time.length ? "T" : ""}${time}`;
-  });
+  }
+  // A single designator carries an unbounded digit count, so `P<n>Y` expresses
+  // every length from three upward and `P1Y` is the shortest duration there is.
+  const length: number = _randomLengthPick(
+    _randomLengthWindow(props, { minimum: MINIMUM, spread: 6 }),
+  );
+  return `P${__randomNumeric(length - MINIMUM + 1)}Y`;
+};
+
+const MINIMUM = "P1Y".length;
+
 const durate = (elements: [string, number][]) =>
   elements
     .filter(([_unit, value]) => value !== 0)

package/src/internal/_randomFormatIpv4.ts

@@ -1,8 +1,37 @@
 import { _randomInteger } from "./_randomInteger";
-import { _ILengthProps, _randomFormatLength } from "./_randomStringLength";
+import {
+  _ILengthProps,
+  _randomLengthPick,
+  _randomLengthWindow,
+} from "./_randomStringLength";
+import { __randomComposition } from "./private/__randomComposition";
 
-export const _randomFormatIpv4 = (props?: _ILengthProps): string =>
-  _randomFormatLength(props, () => new Array(4).fill(0).map(random).join("."));
+export const _randomFormatIpv4 = (props?: _ILengthProps): string => {
+  if (props?.minLength === undefined && props?.maxLength === undefined)
+    return new Array(4).fill(0).map(random).join(".");
+  // Three dots plus four octets of one to three digits: `0.0.0.0` is the
+  // shortest address and `255.255.255.255` the longest, and every length
+  // between them is reached by choosing how many digits each octet spends.
+  const length: number = _randomLengthPick(
+    _randomLengthWindow(props, {
+      minimum: 4 * DIGITS_MIN + DOTS,
+      maximum: 4 * DIGITS_MAX + DOTS,
+      spread: 8,
+    }),
+  );
+  return __randomComposition({
+    total: length - DOTS,
+    count: 4,
+    minimum: DIGITS_MIN,
+    maximum: DIGITS_MAX,
+  })
+    .map(octet)
+    .join(".");
+};
+
+const DOTS = 3;
+const DIGITS_MIN = 1;
+const DIGITS_MAX = 3;
 
 const random = () =>
   _randomInteger({
@@ -10,3 +39,14 @@ const random = () =>
     minimum: 0,
     maximum: 255,
   });
+
+// An octet is bounded by 255, so a three-digit one starts at 100 and stops
+// there rather than at 999.
+const octet = (digits: number): string =>
+  String(
+    _randomInteger({
+      type: "integer",
+      minimum: digits === 1 ? 0 : Math.pow(10, digits - 1),
+      maximum: digits === 3 ? 255 : Math.pow(10, digits) - 1,
+    }),
+  );

package/src/internal/_randomFormatIpv6.ts

@@ -1,8 +1,61 @@
+import { _randomFormatIpv4 } from "./_randomFormatIpv4";
 import { _randomInteger } from "./_randomInteger";
-import { _ILengthProps, _randomFormatLength } from "./_randomStringLength";
+import {
+  _ILengthProps,
+  _randomLengthPick,
+  _randomLengthWindow,
+} from "./_randomStringLength";
+import { __randomComposition } from "./private/__randomComposition";
 
-export const _randomFormatIpv6 = (props?: _ILengthProps): string =>
-  _randomFormatLength(props, () => new Array(8).fill(0).map(random).join(":"));
+export const _randomFormatIpv6 = (props?: _ILengthProps): string => {
+  if (props?.minLength === undefined && props?.maxLength === undefined)
+    return new Array(GROUPS).fill(0).map(random).join(":");
+  const length: number = _randomLengthPick(
+    _randomLengthWindow(props, {
+      minimum: SHORTEST,
+      maximum: LONGEST,
+      spread: 12,
+    }),
+  );
+  // `::` alone is the all-zero address, and the three forms below cover every
+  // length between it and the padded IPv4-suffixed address: a compressed prefix
+  // for the short ones, eight groups of one to four hexadecimal digits for the
+  // middle, and six groups plus a dotted-quad tail for the long ones.
+  if (length === SHORTEST) return "::";
+  if (length < GROUPS * DIGITS_MIN + COLONS) {
+    // `::` plus `count` groups spends one colon between each pair.
+    const count: number = Math.ceil((length - 1) / (DIGITS_MAX + 1));
+    return `::${compose(length - 1 - count, count)}`;
+  }
+  if (length <= GROUPS * DIGITS_MAX + COLONS)
+    return compose(length - COLONS, GROUPS);
+  // The dotted-quad tail is drawn at its longest so the six leading groups keep
+  // a composable number of digits.
+  const tail: string = _randomFormatIpv4({
+    minLength: IPV4_MAX,
+    maxLength: IPV4_MAX,
+  });
+  return `${compose(length - IPV4_MAX - EMBEDDED, EMBEDDED)}:${tail}`;
+};
+
+const GROUPS = 8;
+const COLONS = GROUPS - 1;
+const DIGITS_MIN = 1;
+const DIGITS_MAX = 4;
+const EMBEDDED = 6; // groups preceding a dotted-quad tail
+const IPV4_MAX = "255.255.255.255".length;
+const SHORTEST = "::".length;
+const LONGEST = EMBEDDED * DIGITS_MAX + EMBEDDED + IPV4_MAX;
+
+const compose = (digits: number, count: number): string =>
+  __randomComposition({
+    total: digits,
+    count,
+    minimum: DIGITS_MIN,
+    maximum: DIGITS_MAX,
+  })
+    .map(group)
+    .join(":");
 
 const random = () =>
   _randomInteger({
@@ -10,3 +63,14 @@ const random = () =>
     minimum: 0,
     maximum: 65_535,
   }).toString(16);
+
+const group = (digits: number): string => {
+  let text: string = "";
+  for (let i: number = 0; i < digits; ++i)
+    text += _randomInteger({
+      type: "integer",
+      minimum: 0,
+      maximum: 15,
+    }).toString(16);
+  return text;
+};

package/src/internal/_randomFormatJsonPointer.ts

@@ -1,13 +1,33 @@
 import { _randomString } from "./_randomString";
-import { _ILengthProps, _randomSegmentLength } from "./_randomStringLength";
+import {
+  _ILengthProps,
+  _randomLengthPick,
+  _randomLengthWindow,
+  _randomSegmentLength,
+} from "./_randomStringLength";
 
 export const _randomFormatJsonPointer = (props?: _ILengthProps): string => {
   if (props?.minLength === undefined && props?.maxLength === undefined)
-    return `/components/schemas/${random()}`;
+    return `${PREFIX}${random()}`;
   // The `/components/schemas/` prefix (20 chars) is fixed; the reference token
   // after it grows or shrinks to hit the requested length.
-  return `/components/schemas/${_randomSegmentLength(props, 20, 10, 0)}`;
+  if (props.maxLength === undefined || props.maxLength >= PREFIX.length)
+    return `${PREFIX}${_randomSegmentLength(props, PREFIX.length, 10, 0)}`;
+  // Below that prefix a pointer still exists: the empty pointer addresses the
+  // whole document, and one `/`-prefixed token addresses a member of it.
+  const length: number = _randomLengthPick(
+    _randomLengthWindow(props, { minimum: 0, spread: 6 }),
+  );
+  return length === 0
+    ? ""
+    : `/${_randomString({
+        type: "string",
+        minLength: length - 1,
+        maxLength: length - 1,
+      })}`;
 };
 
+const PREFIX = "/components/schemas/";
+
 const random = () =>
   _randomString({ type: "string", minLength: 10, maxLength: 10 });

package/src/internal/_randomFormatRegex.ts

@@ -1,7 +1,25 @@
-import { _ILengthProps, _randomFormatLength } from "./_randomStringLength";
+import { _randomString } from "./_randomString";
+import {
+  _ILengthProps,
+  _randomLengthPick,
+  _randomLengthWindow,
+} from "./_randomStringLength";
 
-export const _randomFormatRegex = (props?: _ILengthProps): string =>
-  _randomFormatLength(props, () => FIXED);
+export const _randomFormatRegex = (props?: _ILengthProps): string => {
+  if (props?.minLength === undefined && props?.maxLength === undefined)
+    return FIXED;
+  // Every character `_randomString` emits is a literal in regular expression
+  // syntax, so a source of any length — including the empty source `new
+  // RegExp("")` accepts — compiles.
+  const length: number = _randomLengthPick(
+    _randomLengthWindow(props, { minimum: 0, spread: 16 }),
+  );
+  return _randomString({
+    type: "string",
+    minLength: length,
+    maxLength: length,
+  });
+};
 
 const FIXED =
   "/^(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)$/";

package/src/internal/_randomFormatRelativeJsonPointer.ts

@@ -1,15 +1,28 @@
 import { _randomInteger } from "./_randomInteger";
-import { _ILengthProps, _randomFormatLength } from "./_randomStringLength";
+import { _randomString } from "./_randomString";
+import {
+  _ILengthProps,
+  _randomLengthPick,
+  _randomLengthWindow,
+} from "./_randomStringLength";
+import { __randomNumeric } from "./private/__randomComposition";
 
 export const _randomFormatRelativeJsonPointer = (
   props?: _ILengthProps,
-): string =>
-  _randomFormatLength(
-    props,
-    () =>
-      `${_randomInteger({
-        type: "integer",
-        minimum: 0,
-        maximum: 10,
-      })}#`,
+): string => {
+  if (props?.minLength === undefined && props?.maxLength === undefined)
+    return `${_randomInteger({ type: "integer", minimum: 0, maximum: 10 })}#`;
+  // The leading non-negative integer stands alone as a pointer, so a single
+  // digit is the shortest form; `#` names the key and a `/`-prefixed token names
+  // a member, which absorbs any remaining length.
+  const length: number = _randomLengthPick(
+    _randomLengthWindow(props, { minimum: 1, spread: 6 }),
   );
+  if (length === 1) return __randomNumeric(1);
+  if (length === 2) return `${__randomNumeric(1)}#`;
+  return `${__randomNumeric(1)}/${_randomString({
+    type: "string",
+    minLength: length - 2,
+    maxLength: length - 2,
+  })}`;
+};

package/src/internal/_randomFormatTime.ts

@@ -1,17 +1,50 @@
 import { _randomInteger } from "./_randomInteger";
-import { _ILengthProps, _randomFormatLength } from "./_randomStringLength";
+import {
+  _ILengthProps,
+  _RANDOM_LENGTH_ERROR,
+  _randomLengthPick,
+  _randomLengthWindow,
+} from "./_randomStringLength";
+import { __randomDigits } from "./private/__randomComposition";
 
-export const _randomFormatTime = (props?: _ILengthProps): string =>
-  _randomFormatLength(props, () =>
+export const _randomFormatTime = (props?: _ILengthProps): string => {
+  const clock = (): string =>
     new Date(
-      _randomInteger({
-        type: "integer",
-        minimum: 0,
-        maximum: DAY,
-      }),
-    )
-      .toISOString()
-      .substring(11),
-  );
+      _randomInteger({ type: "integer", minimum: 0, maximum: DAY }),
+    ).toISOString();
+  if (props?.minLength === undefined && props?.maxLength === undefined)
+    return clock().substring(11);
+  // `HH:MM:SS` carries a mandatory offset — one character as `Z`, six as
+  // `+HH:MM` — and an optional fraction of one to nine digits between them.
+  // Together they express 9 and every length from 11 through 24; 10 is the one
+  // gap, because a fraction needs both a dot and a digit.
+  const window = _randomLengthWindow(props, {
+    minimum: CLOCK + 1,
+    maximum: CLOCK + 1 + FRACTION_MAX + OFFSET,
+    spread: 6,
+  });
+  let length: number = _randomLengthPick(window);
+  if (length === CLOCK + 2)
+    length = window.high >= CLOCK + 3 ? CLOCK + 3 : CLOCK + 1;
+  if (length < window.low || length > window.high)
+    throw new Error(_RANDOM_LENGTH_ERROR);
+  const base: string = clock().substring(11, 11 + CLOCK);
+  if (length === CLOCK + 1) return `${base}Z`;
+  // Nine fraction digits cap the `Z` form at 19 characters, so anything longer
+  // spends the extra five on a numeric offset instead.
+  return length <= CLOCK + 2 + FRACTION_MAX
+    ? `${base}.${__randomDigits(length - CLOCK - 2)}Z`
+    : `${base}.${__randomDigits(length - CLOCK - 1 - OFFSET)}${offset()}`;
+};
 
 const DAY = 86_400_000;
+const CLOCK = "00:00:00".length;
+const OFFSET = "+00:00".length;
+const FRACTION_MAX = 9;
+
+const offset = (): string =>
+  `${_randomInteger({ type: "integer", minimum: 0, maximum: 1 }) === 0 ? "+" : "-"}${pad(
+    _randomInteger({ type: "integer", minimum: 0, maximum: 23 }),
+  )}:${pad(_randomInteger({ type: "integer", minimum: 0, maximum: 59 }))}`;
+
+const pad = (value: number): string => String(value).padStart(2, "0");

package/src/internal/_randomPattern.ts

@@ -2,7 +2,10 @@ import RandExp from "randexp";
 
 import { _ILengthProps } from "./_randomStringLength";
 
-export const _randomPattern = (regex: RegExp, props?: _ILengthProps): string => {
+export const _randomPattern = (
+  regex: RegExp,
+  props?: _ILengthProps,
+): string => {
   const r: RandExp = new RandExp(regex);
   const min: number | undefined = props?.minLength;
   const max: number | undefined = props?.maxLength;