typia 13.1.1 → 13.2.0

package/src/internal/_randomMultiple.ts

@@ -0,0 +1,245 @@
+import {
+  _IDecimal,
+  _IDecimalRatio,
+  _decimalDecompose,
+  _decimalDivide,
+  _decimalGcd,
+  _decimalIntegerStep,
+  _decimalPower,
+  _decimalToNumber,
+} from "./_decimal";
+import { _isMultipleOf } from "./_isMultipleOf";
+
+export const _randomMultiple = (props: {
+  minimum: number;
+  maximum: number;
+  multipleOf: number;
+  exclusiveMinimum: boolean;
+  exclusiveMaximum: boolean;
+  integer: boolean;
+}): number => {
+  const step: _IDecimal | null = props.integer
+    ? _decimalIntegerStep(props.multipleOf)
+    : _decimalDecompose(props.multipleOf);
+  if (step === null || step.coefficient <= BigInt(0))
+    throw new Error("The multipleOf value must be a positive finite number.");
+
+  const lower: _IDecimalRatio | null = _decimalDivide(props.minimum, step);
+  const upper: _IDecimalRatio | null = _decimalDivide(props.maximum, step);
+  if (lower === null || upper === null)
+    throw new Error("The random number range must be finite.");
+  const minimum: bigint = lowerBound(lower, props.exclusiveMinimum);
+  const maximum: bigint = upperBound(upper, props.exclusiveMaximum);
+  if (minimum > maximum)
+    throw new Error("The range does not contain a multipleOf value.");
+
+  const selected: bigint = randomBigint(minimum, maximum);
+  const candidates: bigint[] = unique([
+    selected,
+    minimum,
+    maximum,
+    clamp(BigInt(0), minimum, maximum),
+    clamp(BigInt(1), minimum, maximum),
+    clamp(BigInt(-1), minimum, maximum),
+    ...nearby(selected, minimum, maximum),
+  ]);
+  for (const coefficient of candidates) {
+    const value: number = _decimalToNumber({
+      coefficient: step.coefficient * coefficient,
+      exponent: step.exponent,
+    });
+    if (isValid(props, value)) return value;
+  }
+  const aligned: number | null = findRepresentableIntegerMultiple(props);
+  if (aligned !== null) return aligned;
+  const decimalAligned: number | null = findRepresentableDecimalMultiple(
+    props,
+    step,
+  );
+  if (decimalAligned !== null) return decimalAligned;
+  throw new Error(
+    "The range does not contain a representable multipleOf value.",
+  );
+};
+
+const isValid = (
+  props: Parameters<typeof _randomMultiple>[0],
+  value: number,
+): boolean =>
+  Number.isFinite(value) &&
+  (props.integer === false || Number.isInteger(value)) &&
+  (props.exclusiveMinimum ? value > props.minimum : value >= props.minimum) &&
+  (props.exclusiveMaximum ? value < props.maximum : value <= props.maximum) &&
+  _isMultipleOf(value, props.multipleOf);
+
+const findRepresentableDecimalMultiple = (
+  props: Parameters<typeof _randomMultiple>[0],
+  step: _IDecimal,
+): number | null => {
+  const limit: bigint = BigInt("999999999999999");
+  for (let exponent = -324; exponent <= 308; ++exponent) {
+    const unit: _IDecimal = { coefficient: BigInt(1), exponent };
+    const lower: _IDecimalRatio | null = _decimalDivide(props.minimum, unit);
+    const upper: _IDecimalRatio | null = _decimalDivide(props.maximum, unit);
+    if (lower === null || upper === null) return null;
+
+    const coefficientMinimum: bigint = max(
+      -limit,
+      lowerBound(lower, props.exclusiveMinimum),
+    );
+    const coefficientMaximum: bigint = min(
+      limit,
+      upperBound(upper, props.exclusiveMaximum),
+    );
+    if (coefficientMinimum > coefficientMaximum) continue;
+
+    const coefficientStep: bigint = decimalCoefficientStep(step, exponent);
+    const minimum: bigint = lowerBound(
+      { numerator: coefficientMinimum, denominator: coefficientStep },
+      false,
+    );
+    const maximum: bigint = upperBound(
+      { numerator: coefficientMaximum, denominator: coefficientStep },
+      false,
+    );
+    if (minimum > maximum) continue;
+
+    const selected: bigint = randomBigint(minimum, maximum);
+    for (const quotient of unique([
+      selected,
+      minimum,
+      maximum,
+      clamp(BigInt(0), minimum, maximum),
+      ...nearby(selected, minimum, maximum),
+    ])) {
+      const value: number = _decimalToNumber({
+        coefficient: coefficientStep * quotient,
+        exponent,
+      });
+      if (isValid(props, value)) return value;
+    }
+  }
+  return null;
+};
+
+const decimalCoefficientStep = (step: _IDecimal, exponent: number): bigint => {
+  const difference: number = exponent - step.exponent;
+  if (difference >= 0) {
+    const power: bigint = _decimalPower(difference);
+    return step.coefficient / _decimalGcd(step.coefficient, power);
+  }
+  return step.coefficient * _decimalPower(-difference);
+};
+
+const findRepresentableIntegerMultiple = (
+  props: Parameters<typeof _randomMultiple>[0],
+): number | null => {
+  const step: _IDecimal | null = _decimalIntegerStep(props.multipleOf);
+  if (step === null) return null;
+  const unit: _IDecimal = { coefficient: BigInt(1), exponent: 0 };
+  const lower: _IDecimalRatio | null = _decimalDivide(props.minimum, unit);
+  const upper: _IDecimalRatio | null = _decimalDivide(props.maximum, unit);
+  if (lower === null || upper === null) return null;
+
+  const minimum: bigint = lowerBound(lower, props.exclusiveMinimum);
+  const maximum: bigint = upperBound(upper, props.exclusiveMaximum);
+  if (minimum > maximum) return null;
+  if (minimum <= BigInt(0) && maximum >= BigInt(0)) return 0;
+
+  const candidate: bigint | null =
+    minimum > BigInt(0)
+      ? findPositiveAligned(minimum, maximum, step.coefficient)
+      : (() => {
+          const magnitude: bigint | null = findPositiveAligned(
+            -maximum,
+            -minimum,
+            step.coefficient,
+          );
+          return magnitude === null ? null : -magnitude;
+        })();
+  if (candidate === null) return null;
+  const value: number = Number(candidate);
+  return isValid(props, value) ? value : null;
+};
+
+const findPositiveAligned = (
+  minimum: bigint,
+  maximum: bigint,
+  integerStep: bigint,
+): bigint | null => {
+  const first: number = bitLength(minimum) - 1;
+  const last: number = bitLength(maximum) - 1;
+  for (let exponent = first; exponent <= last; ++exponent) {
+    const bandMinimum: bigint = max(minimum, BigInt(1) << BigInt(exponent));
+    const bandMaximum: bigint = min(
+      maximum,
+      (BigInt(1) << BigInt(exponent + 1)) - BigInt(1),
+    );
+    const quantum: bigint =
+      exponent <= 52 ? BigInt(1) : BigInt(1) << BigInt(exponent - 52);
+    const alignedStep: bigint =
+      (integerStep / _decimalGcd(integerStep, quantum)) * quantum;
+    const lower: bigint = lowerBound(
+      { numerator: bandMinimum, denominator: alignedStep },
+      false,
+    );
+    const upper: bigint = upperBound(
+      { numerator: bandMaximum, denominator: alignedStep },
+      false,
+    );
+    if (lower <= upper) return randomBigint(lower, upper) * alignedStep;
+  }
+  return null;
+};
+
+const bitLength = (value: bigint): number => value.toString(2).length;
+
+const min = (x: bigint, y: bigint): bigint => (x < y ? x : y);
+const max = (x: bigint, y: bigint): bigint => (x > y ? x : y);
+
+const lowerBound = (ratio: _IDecimalRatio, exclusive: boolean): bigint => {
+  const quotient: bigint = ratio.numerator / ratio.denominator;
+  const remainder: bigint = ratio.numerator % ratio.denominator;
+  const ceiling: bigint =
+    quotient + (remainder > BigInt(0) ? BigInt(1) : BigInt(0));
+  return (
+    ceiling + (exclusive && remainder === BigInt(0) ? BigInt(1) : BigInt(0))
+  );
+};
+
+const upperBound = (ratio: _IDecimalRatio, exclusive: boolean): bigint => {
+  const quotient: bigint = ratio.numerator / ratio.denominator;
+  const remainder: bigint = ratio.numerator % ratio.denominator;
+  const floor: bigint =
+    quotient - (remainder < BigInt(0) ? BigInt(1) : BigInt(0));
+  return floor - (exclusive && remainder === BigInt(0) ? BigInt(1) : BigInt(0));
+};
+
+const randomBigint = (minimum: bigint, maximum: bigint): bigint => {
+  const scale: bigint = BigInt(1) << BigInt(53);
+  const sample: bigint = BigInt(
+    Math.min(
+      Number(scale - BigInt(1)),
+      Math.floor(Math.max(0, Math.random()) * Number(scale)),
+    ),
+  );
+  return minimum + ((maximum - minimum + BigInt(1)) * sample) / scale;
+};
+
+const clamp = (value: bigint, minimum: bigint, maximum: bigint): bigint =>
+  value < minimum ? minimum : value > maximum ? maximum : value;
+
+const nearby = (
+  selected: bigint,
+  minimum: bigint,
+  maximum: bigint,
+): bigint[] => {
+  const output: bigint[] = [];
+  for (let distance = BigInt(1); distance <= BigInt(32); ++distance) {
+    if (selected - distance >= minimum) output.push(selected - distance);
+    if (selected + distance <= maximum) output.push(selected + distance);
+  }
+  return output;
+};
+
+const unique = (values: bigint[]): bigint[] => [...new Set(values)];

package/src/internal/_randomNumber.ts

@@ -1,80 +1,97 @@
 import { OpenApi } from "@typia/interface";
 
+import { _randomMultiple } from "./_randomMultiple";
+
 export const _randomNumber = (schema: OpenApi.IJsonSchema.INumber): number => {
+  const lower: IBoundary | null = getLowerBoundary(schema);
+  const upper: IBoundary | null = getUpperBoundary(schema);
   const minimum: number =
-    schema.minimum ??
-    schema.exclusiveMinimum ??
-    (schema.multipleOf ?? 1) *
-      (schema.maximum === undefined && schema.exclusiveMaximum === undefined
-        ? 0
-        : (schema.maximum ?? schema.exclusiveMaximum!) - 100);
+    lower?.value ?? (upper === null ? 0 : upper.value - 100);
   const maximum: number =
-    schema.maximum ??
-    schema.exclusiveMaximum ??
-    (schema.multipleOf ?? 1) *
-      (schema.minimum === undefined && schema.exclusiveMinimum === undefined
-        ? 100
-        : (schema.minimum ?? schema.exclusiveMinimum!) + 100);
+    upper?.value ?? (lower === null ? 100 : lower.value + 100);
   if (minimum > maximum)
     throw new Error("Minimum value is greater than maximum value.");
   return schema.multipleOf === undefined
     ? scalar({
         minimum,
         maximum,
-        exclusiveMinimum: schema.exclusiveMinimum !== undefined,
-        exclusiveMaximum: schema.exclusiveMaximum !== undefined,
+        exclusiveMinimum: lower?.exclusive ?? false,
+        exclusiveMaximum: upper?.exclusive ?? false,
       })
-    : multiple({
+    : _randomMultiple({
         minimum,
         maximum,
         multipleOf: schema.multipleOf,
-        exclusiveMinimum: schema.exclusiveMinimum !== undefined,
-        exclusiveMaximum: schema.exclusiveMaximum !== undefined,
+        exclusiveMinimum: lower?.exclusive ?? false,
+        exclusiveMaximum: upper?.exclusive ?? false,
+        integer: false,
       });
 };
 
-const scalar = (p: {
+const scalar = (props: {
   minimum: number;
   maximum: number;
-  exclusiveMinimum?: boolean;
-  exclusiveMaximum?: boolean;
+  exclusiveMinimum: boolean;
+  exclusiveMaximum: boolean;
 }): number => {
-  if (p.minimum === p.maximum && (p.exclusiveMinimum || p.exclusiveMaximum))
-    throw new Error(
-      p.exclusiveMinimum
-        ? "Exclusive minimum value equals maximum value."
-        : "Exclusive maximum value equals minimum value.",
-    );
-  while (true) {
-    const value: number = Math.random() * (p.maximum - p.minimum) + p.minimum;
-    if (p.exclusiveMinimum && value === p.minimum) continue;
-    else if (p.exclusiveMaximum && value === p.maximum) continue;
-    return value;
+  if (
+    props.minimum === props.maximum &&
+    (props.exclusiveMinimum || props.exclusiveMaximum)
+  )
+    throw new Error("Exclusive numeric range is empty.");
+  const value: number =
+    Math.random() * (props.maximum - props.minimum) + props.minimum;
+  if (
+    (props.exclusiveMinimum && value === props.minimum) ||
+    (props.exclusiveMaximum && value === props.maximum)
+  ) {
+    const middle: number = props.minimum + (props.maximum - props.minimum) / 2;
+    if (middle <= props.minimum || middle >= props.maximum)
+      throw new Error("Exclusive numeric range has no representable value.");
+    return middle;
   }
+  return value;
 };
 
-const multiple = (p: {
-  minimum: number;
-  maximum: number;
-  multipleOf: number;
-  exclusiveMinimum?: boolean;
-  exclusiveMaximum?: boolean;
-}): number => {
-  let minimum = Math.ceil(p.minimum / p.multipleOf) * p.multipleOf;
-  let maximum = Math.floor(p.maximum / p.multipleOf) * p.multipleOf;
-  if (p.exclusiveMinimum === true && minimum % p.multipleOf === 0)
-    minimum += p.multipleOf;
-  if (p.exclusiveMaximum === true && maximum % p.multipleOf === 0)
-    maximum -= p.multipleOf;
-  if (minimum > maximum)
-    throw new Error(
-      "The range of the integer is smaller than the multipleOf value.",
-    );
-  const value: number = scalar({
-    minimum,
-    maximum,
-    exclusiveMinimum: p.exclusiveMinimum,
-    exclusiveMaximum: p.exclusiveMaximum,
-  });
-  return value - (value % p.multipleOf);
+const getLowerBoundary = (
+  schema: OpenApi.IJsonSchema.INumber,
+): IBoundary | null =>
+  selectBoundary(
+    schema.minimum === undefined
+      ? null
+      : { value: schema.minimum, exclusive: false },
+    schema.exclusiveMinimum === undefined
+      ? null
+      : { value: schema.exclusiveMinimum, exclusive: true },
+    Math.max,
+  );
+
+const getUpperBoundary = (
+  schema: OpenApi.IJsonSchema.INumber,
+): IBoundary | null =>
+  selectBoundary(
+    schema.maximum === undefined
+      ? null
+      : { value: schema.maximum, exclusive: false },
+    schema.exclusiveMaximum === undefined
+      ? null
+      : { value: schema.exclusiveMaximum, exclusive: true },
+    Math.min,
+  );
+
+const selectBoundary = (
+  x: IBoundary | null,
+  y: IBoundary | null,
+  compare: (x: number, y: number) => number,
+): IBoundary | null => {
+  if (x === null) return y;
+  if (y === null) return x;
+  if (x.value === y.value)
+    return { value: x.value, exclusive: x.exclusive || y.exclusive };
+  return compare(x.value, y.value) === x.value ? x : y;
 };
+
+interface IBoundary {
+  value: number;
+  exclusive: boolean;
+}

package/src/internal/_randomPattern.ts

@@ -1,10 +1,35 @@
 import RandExp from "randexp";
 
-export const _randomPattern = (regex: RegExp): string => {
+import { _ILengthProps } from "./_randomStringLength";
+
+export const _randomPattern = (
+  regex: RegExp,
+  props?: _ILengthProps,
+): string => {
   const r: RandExp = new RandExp(regex);
-  for (let i: number = 0; i < 10; ++i) {
+  const min: number | undefined = props?.minLength;
+  const max: number | undefined = props?.maxLength;
+
+  // RandExp expands an unbounded quantifier to `randInt(token.min, token.min +
+  // r.max)`, so steering `r.max` biases the generated length toward the window.
+  // There is no matching floor control, so the length is still verified below.
+  if (max !== undefined) r.max = max;
+  else if (min !== undefined && min * 2 > r.max) r.max = min * 2;
+
+  const bounded: boolean = min !== undefined || max !== undefined;
+  const limit: number = bounded ? 1024 : 10;
+  for (let i: number = 0; i < limit; ++i) {
     const str: string = r.gen();
-    if (regex.test(str)) return str;
+    if (
+      regex.test(str) &&
+      (min === undefined || str.length >= min) &&
+      (max === undefined || str.length <= max)
+    )
+      return str;
   }
-  return r.gen();
+  throw new Error(
+    bounded
+      ? "unable to generate a random string matching the pattern within the length range."
+      : "unable to generate a random string matching the pattern.",
+  );
 };

package/src/internal/_randomStringLength.ts

@@ -0,0 +1,116 @@
+import { _randomInteger } from "./_randomInteger";
+import { _randomString } from "./_randomString";
+
+export const _RANDOM_LENGTH_ERROR =
+  "unable to generate a random string satisfying both the format and the length constraints.";
+
+/**
+ * Length bounds forwarded to a string format or pattern generator.
+ *
+ * `typia.random<T>()` passes this object to the `_randomFormat*` and
+ * `_randomPattern` helpers whenever the string leaf also carries a `MinLength`
+ * or `MaxLength` tag, so a constrained format or pattern is generated at a
+ * length its own validator accepts (issue #2189).
+ */
+export interface _ILengthProps {
+  minLength?: number;
+  maxLength?: number;
+}
+
+/**
+ * Builds the variable segment of a fixed-shape format string so that the total
+ * length `fixed + segment.length` lands inside the requested window.
+ *
+ * `fixed` is the number of characters the format always contributes around the
+ * segment, `fallback` is the segment length used when the leaf is unconstrained
+ * on that side, and `minimum` is the smallest segment the format still
+ * validates with. Throws when the window cannot be satisfied by this format's
+ * shape (e.g. `Format<"email"> & MaxLength<3>`).
+ */
+export const _randomSegmentLength = (
+  props: _ILengthProps | undefined,
+  fixed: number,
+  fallback: number,
+  minimum: number,
+): string => {
+  let low: number =
+    props?.minLength === undefined ? minimum : props.minLength - fixed;
+  if (low < minimum) low = minimum;
+  // With only a lower bound, spread the segment across `fallback` extra
+  // characters so the generated length varies, mirroring `_randomString`.
+  const high: number =
+    props?.maxLength === undefined ? low + fallback : props.maxLength - fixed;
+  if (high < low || high < minimum) throw new Error(_RANDOM_LENGTH_ERROR);
+  return _randomString({ type: "string", minLength: low, maxLength: high });
+};
+
+/**
+ * Intersects the requested length window with the lengths a format's grammar
+ * can express, and draws one of them.
+ *
+ * `minimum` and `maximum` are the shortest and longest values the format admits
+ * — omit `maximum` when the grammar is open above — and `spread` is how far
+ * past the floor an unbounded request may reach, so an open side still varies
+ * the way `_randomString` does. The caller draws from the returned window and
+ * applies whatever step its grammar has (base64 lengths are multiples of four,
+ * a fractional second needs at least one digit).
+ *
+ * Throws only when the window and the grammar do not overlap at all. That is
+ * the distinction the retry driver below cannot make: it redraws one shape, so
+ * it gives up on every length that shape never emits even when the format
+ * itself accepts one (issue #2284).
+ */
+export const _randomLengthWindow = (
+  props: _ILengthProps | undefined,
+  format: { minimum: number; maximum?: number; spread?: number },
+): { low: number; high: number } => {
+  const ceiling: number = format.maximum ?? Number.MAX_SAFE_INTEGER;
+  const low: number = Math.max(
+    props?.minLength ?? format.minimum,
+    format.minimum,
+  );
+  const high: number = Math.min(
+    props?.maxLength ?? low + (format.spread ?? 0),
+    ceiling,
+  );
+  if (low > high) throw new Error(_RANDOM_LENGTH_ERROR);
+  return { low, high };
+};
+
+/** Draws a length inside a window produced by {@link _randomLengthWindow}. */
+export const _randomLengthPick = (window: {
+  low: number;
+  high: number;
+}): number =>
+  _randomInteger({
+    type: "integer",
+    minimum: window.low,
+    maximum: window.high,
+  });
+
+/**
+ * Wraps a fixed-length format generator (uuid, date) with the requested length
+ * window.
+ *
+ * Use it only where the grammar admits exactly one length, so a window that
+ * excludes it is genuinely unsatisfiable. A format that can express more than
+ * one length must build its value at a length drawn from
+ * {@link _randomLengthWindow} instead; redrawing one shape cannot reach a length
+ * that shape never emits.
+ */
+export const _randomFormatLength = (
+  props: _ILengthProps | undefined,
+  generate: () => string,
+): string => {
+  if (props?.minLength === undefined && props?.maxLength === undefined)
+    return generate();
+  for (let i: number = 0; i < 256; ++i) {
+    const value: string = generate();
+    if (
+      (props.minLength === undefined || value.length >= props.minLength) &&
+      (props.maxLength === undefined || value.length <= props.maxLength)
+    )
+      return value;
+  }
+  throw new Error(_RANDOM_LENGTH_ERROR);
+};

package/src/internal/_stringLength.ts

@@ -0,0 +1,5 @@
+export const _stringLength = (value: string): number => {
+  let count: number = 0;
+  for (const _ch of value) ++count;
+  return count;
+};

package/src/internal/_validateReport.ts

@@ -1,10 +1,14 @@
 import { IValidation } from "@typia/interface";
 
 export const _validateReport = (array: IValidation.IError[]) => {
+  const isAncestor = (ancestor: string, descendant: string): boolean =>
+    descendant === ancestor ||
+    descendant.startsWith(`${ancestor}.`) ||
+    descendant.startsWith(`${ancestor}[`);
   const reportable = (path: string): boolean => {
     if (array.length === 0) return true;
     const last: string = array[array.length - 1]!.path;
-    return path.length > last.length || last.substring(0, path.length) !== path;
+    return isAncestor(path, last) === false && isAncestor(last, path) === false;
   };
   return (exceptable: boolean, error: IValidation.IError): false => {
     if (exceptable && reportable(error.path)) {

package/src/internal/private/__notationRename.ts

@@ -0,0 +1,21 @@
+/**
+ * Shared outer walk for the `camel`/`pascal` notations.
+ *
+ * Mirrors the `CamelCase<T>` / `PascalCase<T>` typings: leading underscores are
+ * preserved verbatim, an all-underscore key stays untouched, and the presence
+ * of any remaining underscore — not the number of non-empty segments — selects
+ * the `snake` conversion. Routing on underscore presence keeps a trailing or
+ * doubled underscore (`fooBar_`) on the same path the type takes, instead of
+ * collapsing it to the underscore-free `plain` path.
+ */
+export const __notationRename =
+  (props: { plain: (str: string) => string; snake: (str: string) => string }) =>
+  (str: string): string => {
+    let prefix: string = "";
+    while (str.startsWith("_")) {
+      prefix += "_";
+      str = str.substring(1);
+    }
+    if (str.length === 0) return prefix;
+    return `${prefix}${str.includes("_") ? props.snake(str) : props.plain(str)}`;
+  };

package/src/internal/private/__randomComposition.ts

@@ -0,0 +1,50 @@
+import { _randomInteger } from "../_randomInteger";
+
+/**
+ * Splits `total` into `count` parts, each inside `[minimum, maximum]`.
+ *
+ * Used where a format's length is the sum of its segments — an IPv4 octet spans
+ * one to three digits, an IPv6 group one to four — so a requested total length
+ * is realized by choosing how many characters each segment contributes instead
+ * of redrawing whole addresses and hoping one lands in the window (issue
+ * #2284).
+ *
+ * The caller guarantees `count * minimum <= total <= count * maximum`; each
+ * part is drawn from the range that still leaves the remaining parts
+ * satisfiable.
+ */
+export const __randomComposition = (props: {
+  total: number;
+  count: number;
+  minimum: number;
+  maximum: number;
+}): number[] => {
+  const parts: number[] = [];
+  let remaining: number = props.total;
+  for (let i: number = 0; i < props.count; ++i) {
+    const rest: number = props.count - i - 1;
+    const value: number = _randomInteger({
+      type: "integer",
+      minimum: Math.max(props.minimum, remaining - rest * props.maximum),
+      maximum: Math.min(props.maximum, remaining - rest * props.minimum),
+    });
+    parts.push(value);
+    remaining -= value;
+  }
+  return parts;
+};
+
+/** Draws `length` decimal digits, leading zeros included. */
+export const __randomDigits = (length: number): string => {
+  let text: string = "";
+  for (let i: number = 0; i < length; ++i)
+    text += String(_randomInteger({ type: "integer", minimum: 0, maximum: 9 }));
+  return text;
+};
+
+/** Draws a decimal number of exactly `length` digits without a leading zero. */
+export const __randomNumeric = (length: number): string =>
+  length <= 1
+    ? String(_randomInteger({ type: "integer", minimum: 0, maximum: 9 }))
+    : String(_randomInteger({ type: "integer", minimum: 1, maximum: 9 })) +
+      __randomDigits(length - 1);