typia 13.2.0 → 14.0.0

package/src/internal/_randomPattern.ts

@@ -1,6 +1,7 @@
 import RandExp from "randexp";
 
 import { _ILengthProps } from "./_randomStringLength";
+import { _stringLength } from "./_stringLength";
 
 export const _randomPattern = (
   regex: RegExp,
@@ -16,14 +17,28 @@ export const _randomPattern = (
   if (max !== undefined) r.max = max;
   else if (min !== undefined && min * 2 > r.max) r.max = min * 2;
 
+  // The verification counts characters, not UTF-16 code units, because that is
+  // what `MinLength` and `MaxLength` compare against. `Pattern` compiles to a
+  // flagless `RegExp`, so a quantifier binds one code unit wherever its atom is
+  // a bare astral character: under `^😀+$` the `+` repeats the trailing low
+  // surrogate alone, and RandExp draws `\ud83d` + k * `\ude00` -- k characters
+  // in k + 1 code units. Measuring in code units accepted a two-character draw
+  // for `MinLength<3>` and handed back a value the generated validator rejects.
+  // Group the atom (`^(?:😀)+$`) and the arithmetic changes to 2k units for k
+  // characters; the two counts still differ, which is the point.
+  //
+  // The count is taken only after the pattern matches, and only when a bound
+  // exists, so an unbounded draw still walks nothing.
   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) === false) continue;
+    if (bounded === false) return str;
+    const length: number = _stringLength(str);
     if (
-      regex.test(str) &&
-      (min === undefined || str.length >= min) &&
-      (max === undefined || str.length <= max)
+      (min === undefined || length >= min) &&
+      (max === undefined || length <= max)
     )
       return str;
   }

package/src/internal/_randomStringLength.ts

@@ -1,5 +1,6 @@
 import { _randomInteger } from "./_randomInteger";
 import { _randomString } from "./_randomString";
+import { _stringLength } from "./_stringLength";
 
 export const _RANDOM_LENGTH_ERROR =
   "unable to generate a random string satisfying both the format and the length constraints.";
@@ -106,9 +107,15 @@ export const _randomFormatLength = (
     return generate();
   for (let i: number = 0; i < 256; ++i) {
     const value: string = generate();
+    // Characters, not UTF-16 code units: `minLength` and `maxLength` are the
+    // bounds the generated validator compares in characters. `uuid` and `date`,
+    // the only two shapes routed through here, are ASCII, so the two counts
+    // agree for them today -- this keeps one measure so a later non-ASCII
+    // format cannot reintroduce the divergence unnoticed.
+    const length: number = _stringLength(value);
     if (
-      (props.minLength === undefined || value.length >= props.minLength) &&
-      (props.maxLength === undefined || value.length <= props.maxLength)
+      (props.minLength === undefined || length >= props.minLength) &&
+      (props.maxLength === undefined || length <= props.maxLength)
     )
       return value;
   }

package/src/internal/private/__randomComposition.ts

@@ -34,6 +34,30 @@ export const __randomComposition = (props: {
   return parts;
 };
 
+/**
+ * Draws `length` characters of the base64 alphabet.
+ *
+ * The caller passes a multiple of four, which `format: "byte"` accepts without
+ * padding; every character below is in the alphabet its validator spells out,
+ * so the result needs no encoding step.
+ */
+export const __randomBase64 = (length: number): string => {
+  let text: string = "";
+  for (let i: number = 0; i < length; ++i)
+    text +=
+      BASE64[
+        _randomInteger({
+          type: "integer",
+          minimum: 0,
+          maximum: BASE64.length - 1,
+        })
+      ];
+  return text;
+};
+
+const BASE64 =
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
 /** Draws `length` decimal digits, leading zeros included. */
 export const __randomDigits = (length: number): string => {
   let text: string = "";

package/src/json.ts

@@ -431,10 +431,16 @@ export function createAssertParse(
  */
 export function createAssertParse<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: string) => Primitive<T>;
+): (
+  input: string,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => Primitive<T>;
 
 /** @internal */
-export function createAssertParse<T>(): (input: string) => Primitive<T> {
+export function createAssertParse<T>(): (
+  input: string,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => Primitive<T> {
   NoTransformConfigurationError("json.createAssertParse");
 }
 
@@ -501,10 +507,16 @@ export function createAssertStringify(
  */
 export function createAssertStringify<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: unknown) => string;
+): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => string;
 
 /** @internal */
-export function createAssertStringify(): (input: unknown) => string {
+export function createAssertStringify(): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => string {
   NoTransformConfigurationError("json.createAssertStringify");
 }
 

package/src/module.ts

@@ -1,10 +1,5 @@
 import { StandardSchemaV1 } from "@standard-schema/spec";
-import {
-  AssertionGuard,
-  IRandomGenerator,
-  IValidation,
-  Resolved,
-} from "@typia/interface";
+import { IRandomGenerator, IValidation, Resolved } from "@typia/interface";
 
 import { TypeGuardError } from "./TypeGuardError";
 import { NoTransformConfigurationError } from "./transformers/NoTransformConfigurationError";
@@ -577,7 +572,7 @@ export function random(): never {
  * @template T Target type to validate against
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
- * @returns Reusable assert function `(input: unknown) => T`
+ * @returns Reusable assert function `(input: unknown, errorFactory?) => T`
  * @danger You must configure the generic argument `T`
  */
 export function createAssert(
@@ -593,14 +588,21 @@ export function createAssert(
  * @template T Target type to validate against
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
- * @returns Reusable assert function `(input: unknown) => T`
+ * @returns Reusable assert function `(input: unknown, errorFactory?) => T`,
+ *   whose own `errorFactory` overrides this one for that single call
  */
 export function createAssert<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: unknown) => T;
+): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => T;
 
 /** @internal */
-export function createAssert<T>(): (input: unknown) => T {
+export function createAssert<T>(): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => T {
   NoTransformConfigurationError("createAssert");
 }
 
@@ -611,6 +613,9 @@ export function createAssert<T>(): (input: unknown) => T {
  *
  * TypeScript requirement: You must declare the variable type explicitly. `const
  * fn: AssertionGuard<T> = createAssertGuard<T>()` — otherwise compile error.
+ * That annotation is one parameter wide, so it also hides the call-time
+ * `errorFactory`; annotate with `(input: unknown, errorFactory?: (props:
+ * TypeGuardError.IProps) => Error) => asserts input is T` when you need it.
  *
  * @template T Target type to validate against
  * @param errorFactory Custom error factory receiving
@@ -629,18 +634,28 @@ export function createAssertGuard(
  *
  * TypeScript requirement: You must declare the variable type explicitly. `const
  * fn: AssertionGuard<T> = createAssertGuard<T>()` — otherwise compile error.
+ * That annotation is one parameter wide, so it also hides the call-time
+ * `errorFactory`; annotate with `(input: unknown, errorFactory?: (props:
+ * TypeGuardError.IProps) => Error) => asserts input is T` when you need it.
  *
  * @template T Target type to validate against
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
- * @returns Reusable assertion guard function
+ * @returns Reusable assertion guard function, whose own `errorFactory`
+ *   overrides this one for that single call
  */
 export function createAssertGuard<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): AssertionGuard<T>;
+): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => asserts input is T;
 
 /** @internal */
-export function createAssertGuard<T>(): AssertionGuard<T> {
+export function createAssertGuard<T>(): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => asserts input is T {
   NoTransformConfigurationError("createAssertGuard");
 }
 
@@ -747,7 +762,8 @@ export function createValidate(): ((input: unknown) => IValidation) &
  * @template T Target type for exact match
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
- * @returns Reusable assertEquals function `(input: unknown) => T`
+ * @returns Reusable assertEquals function `(input: unknown, errorFactory?) =>
+ *   T`
  * @danger You must configure the generic argument `T`
  */
 export function createAssertEquals(
@@ -763,14 +779,21 @@ export function createAssertEquals(
  * @template T Target type for exact match
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
- * @returns Reusable assertEquals function `(input: unknown) => T`
+ * @returns Reusable assertEquals function `(input: unknown, errorFactory?) =>
+ *   T`, whose own `errorFactory` overrides this one for that single call
  */
 export function createAssertEquals<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: unknown) => T;
+): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => T;
 
 /** @internal */
-export function createAssertEquals<T>(): (input: unknown) => T {
+export function createAssertEquals<T>(): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => T {
   NoTransformConfigurationError("createAssertEquals");
 }
 
@@ -781,7 +804,9 @@ export function createAssertEquals<T>(): (input: unknown) => T {
  *
  * TypeScript requirement: You must declare the variable type explicitly. `const
  * fn: AssertionGuard<T> = createAssertGuardEquals<T>()` — otherwise compile
- * error.
+ * error. That annotation is one parameter wide, so it also hides the call-time
+ * `errorFactory`; annotate with `(input: unknown, errorFactory?: (props:
+ * TypeGuardError.IProps) => Error) => asserts input is T` when you need it.
  *
  * @template T Target type for exact match
  * @param errorFactory Custom error factory receiving
@@ -800,19 +825,28 @@ export function createAssertGuardEquals(
  *
  * TypeScript requirement: You must declare the variable type explicitly. `const
  * fn: AssertionGuard<T> = createAssertGuardEquals<T>()` — otherwise compile
- * error.
+ * error. That annotation is one parameter wide, so it also hides the call-time
+ * `errorFactory`; annotate with `(input: unknown, errorFactory?: (props:
+ * TypeGuardError.IProps) => Error) => asserts input is T` when you need it.
  *
  * @template T Target type for exact match
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
- * @returns Reusable assertion guard function
+ * @returns Reusable assertion guard function, whose own `errorFactory`
+ *   overrides this one for that single call
  */
 export function createAssertGuardEquals<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): AssertionGuard<T>;
+): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => asserts input is T;
 
 /** @internal */
-export function createAssertGuardEquals<T>(): AssertionGuard<T> {
+export function createAssertGuardEquals<T>(): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => asserts input is T {
   NoTransformConfigurationError("createAssertGuardEquals");
 }
 

package/src/notations.ts

@@ -530,7 +530,10 @@ export function createAssertCamel(
  */
 export function createAssertCamel<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: T) => CamelCase<T>;
+): (
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => CamelCase<T>;
 
 /** @internal */
 export function createAssertCamel(): never {
@@ -618,7 +621,10 @@ export function createAssertPascal(
  */
 export function createAssertPascal<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: T) => PascalCase<T>;
+): (
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => PascalCase<T>;
 
 /** @internal */
 export function createAssertPascal(): never {
@@ -706,7 +712,10 @@ export function createAssertSnake(
  */
 export function createAssertSnake<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: T) => SnakeCase<T>;
+): (
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => SnakeCase<T>;
 
 /** @internal */
 export function createAssertSnake(): never {
@@ -794,7 +803,10 @@ export function createAssertKebab(
  */
 export function createAssertKebab<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: T) => KebabCase<T>;
+): (
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => KebabCase<T>;
 
 /** @internal */
 export function createAssertKebab(): never {

package/src/plain.ts

@@ -383,7 +383,10 @@ export function createAssertClone(
  */
 export function createAssertClone<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: unknown) => Resolved<T>;
+): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => Resolved<T>;
 
 /** @internal */
 export function createAssertClone(): never {
@@ -471,7 +474,10 @@ export function createAssertPrune(
  */
 export function createAssertPrune<T extends object>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: unknown) => T;
+): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => T;
 
 /** @internal */
 export function createAssertPrune(): never {
@@ -563,7 +569,10 @@ export function createAssertClassify(
  */
 export function createAssertClassify<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: unknown) => ClassifyResult<T>;
+): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => ClassifyResult<T>;
 
 /** @internal */
 export function createAssertClassify(): never {

package/src/protobuf.ts

@@ -377,10 +377,16 @@ export function createAssertDecode(
  */
 export function createAssertDecode<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: Uint8Array) => Resolved<T>;
+): (
+  input: Uint8Array,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => Resolved<T>;
 
 /** @internal */
-export function createAssertDecode<T>(): (input: Uint8Array) => Resolved<T> {
+export function createAssertDecode<T>(): (
+  input: Uint8Array,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => Resolved<T> {
   NoTransformConfigurationError("protobuf.createAssertDecode");
 }
 
@@ -467,10 +473,16 @@ export function createAssertEncode(
  */
 export function createAssertEncode<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: T) => Uint8Array;
+): (
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => Uint8Array;
 
 /** @internal */
-export function createAssertEncode<T>(): (input: T) => Uint8Array {
+export function createAssertEncode<T>(): (
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => Uint8Array {
   NoTransformConfigurationError("protobuf.createAssertEncode");
 }
 

package/lib/executable/FileSystemIdentity.d.ts

@@ -1,44 +0,0 @@
-import fs from "fs";
-import path from "path";
-export declare namespace FileSystemIdentity {
-    interface IIdentity {
-        readonly caseSensitive: boolean;
-        contains(file: string, directory: string): boolean;
-        filesystemKey(file: string): string;
-        isDeclarationFile(file: string): boolean;
-        isSamePath(x: string, y: string): boolean;
-        isSupportedExtension(file: string): boolean;
-        projectFileKey(file: string): string;
-    }
-    function create(caseSensitive: boolean, pathApi?: typeof path.posix): IIdentity;
-    class Policy {
-        private caseSensitive_;
-        private location_;
-        observe(caseSensitive: boolean | undefined, location: string): void;
-        get(): IIdentity;
-    }
-    function inspectDirectory(directory: string): Promise<boolean | undefined>;
-    function probeDirectory(directory: string): Promise<boolean>;
-    /**
-     * Builds the key that decides whether two paths are the same filesystem
-     * object.
-     *
-     * The identity is read from `fs.BigIntStats` rather than `fs.Stats`, because
-     * `fs.Stats.ino` is a JavaScript number. An NTFS file ID is `(sequenceNumber
-     * << 48) | mftRecordIndex` and routinely exceeds `Number.MAX_SAFE_INTEGER` —
-     * in a 4000-directory probe, 1879 of them did — where the spacing between
-     * representable doubles is 8 or more. Two entries sharing a sequence number
-     * with MFT record indices within that spacing round to one double. The
-     * traversal callers would then treat a distinct directory or file as already
-     * visited and skip it with no diagnostic, and the overwrite guard would
-     * refuse a legitimate output (samchon/typia#2269).
-     *
-     * A filesystem that reports no inode at all keeps the canonical path
-     * fallback, which is the only identity available there.
-     *
-     * @param stat Stats read with `{ bigint: true }`.
-     * @param realpath Canonical path of the same object.
-     * @returns Key that is equal for two paths only when they are one object.
-     */
-    function identityKey(stat: Pick<fs.BigIntStats, "dev" | "ino">, realpath: string): string;
-}

package/lib/executable/FileSystemIdentity.js

@@ -1,213 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileSystemIdentity = void 0;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-var FileSystemIdentity;
-(function (FileSystemIdentity) {
-    function create(caseSensitive, pathApi = path_1.default) {
-        const fold = (value) => caseSensitive ? value : value.toLowerCase();
-        const filesystemKey = (file) => fold(pathApi.normalize(file));
-        return {
-            caseSensitive,
-            contains: (file, directory) => {
-                const fileKey = filesystemKey(pathApi.resolve(file));
-                const directoryKey = filesystemKey(pathApi.resolve(directory));
-                const prefix = directoryKey.endsWith(pathApi.sep)
-                    ? directoryKey
-                    : `${directoryKey}${pathApi.sep}`;
-                return fileKey === directoryKey || fileKey.startsWith(prefix);
-            },
-            filesystemKey,
-            isDeclarationFile: (file) => DTS_PATTERN.test(fold(pathApi.basename(file))),
-            isSamePath: (x, y) => filesystemKey(x) === filesystemKey(y),
-            isSupportedExtension: (file) => {
-                const filename = fold(pathApi.basename(file));
-                return (TS_PATTERN.test(filename) && DTS_PATTERN.test(filename) === false);
-            },
-            projectFileKey: fold,
-        };
-    }
-    FileSystemIdentity.create = create;
-    class Policy {
-        observe(caseSensitive, location) {
-            if (caseSensitive === undefined)
-                return;
-            if (this.caseSensitive_ === undefined) {
-                this.caseSensitive_ = caseSensitive;
-                this.location_ = location;
-            }
-            else if (this.caseSensitive_ !== caseSensitive) {
-                throw new URIError(`Error on TypiaGenerateWizard.generate(): inconsistent filesystem case behavior between ${this.location_} and ${location}.`);
-            }
-        }
-        get() {
-            if (this.caseSensitive_ === undefined) {
-                throw new URIError("Error on TypiaGenerateWizard.generate(): unable to determine filesystem case behavior for this run.");
-            }
-            return create(this.caseSensitive_);
-        }
-    }
-    FileSystemIdentity.Policy = Policy;
-    function inspectDirectory(directory) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const names = yield fs_1.default.promises.readdir(directory);
-            const entries = new Set(names);
-            for (const name of names) {
-                const alternate = alternateCase(name);
-                if (alternate === undefined)
-                    continue;
-                if (entries.has(alternate))
-                    return true;
-                try {
-                    yield fs_1.default.promises.lstat(path_1.default.join(directory, alternate));
-                    return false;
-                }
-                catch (error) {
-                    if (isMissingFileError(error))
-                        return true;
-                    throw error;
-                }
-            }
-            return undefined;
-        });
-    }
-    FileSystemIdentity.inspectDirectory = inspectDirectory;
-    function probeDirectory(directory) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const inspected = yield inspectDirectory(directory);
-            if (inspected !== undefined)
-                return inspected;
-            for (let attempt = 0; attempt < 10; ++attempt) {
-                const name = `.typia-case-probe-${process.pid}-${Date.now()}-${Math.random()
-                    .toString(36)
-                    .slice(2)}`.toLowerCase();
-                const original = path_1.default.join(directory, name);
-                const alternate = path_1.default.join(directory, name.toUpperCase());
-                let handle;
-                try {
-                    handle = yield fs_1.default.promises.open(original, "wx");
-                }
-                catch (error) {
-                    if (isAlreadyExistsError(error))
-                        continue;
-                    throw new URIError(`Error on TypiaGenerateWizard.generate(): unable to probe filesystem case behavior at ${directory}: ${formatUnknownError(error)}`);
-                }
-                let closed = false;
-                try {
-                    yield handle.close();
-                    closed = true;
-                    try {
-                        yield fs_1.default.promises.lstat(alternate);
-                        return false;
-                    }
-                    catch (error) {
-                        if (isMissingFileError(error))
-                            return true;
-                        throw error;
-                    }
-                }
-                finally {
-                    let cleanupError;
-                    if (closed === false) {
-                        try {
-                            yield handle.close();
-                        }
-                        catch (error) {
-                            cleanupError = error;
-                        }
-                    }
-                    try {
-                        yield fs_1.default.promises.unlink(original);
-                    }
-                    catch (error) {
-                        if (isMissingFileError(error) === false)
-                            cleanupError !== null && cleanupError !== void 0 ? cleanupError : (cleanupError = error);
-                    }
-                    if (cleanupError !== undefined) {
-                        throw new URIError(`Error on TypiaGenerateWizard.generate(): unable to clean filesystem case probe ${original}: ${formatUnknownError(cleanupError)}`);
-                    }
-                }
-            }
-            throw new URIError(`Error on TypiaGenerateWizard.generate(): unable to reserve a filesystem case probe at ${directory}.`);
-        });
-    }
-    FileSystemIdentity.probeDirectory = probeDirectory;
-    /**
-     * Builds the key that decides whether two paths are the same filesystem
-     * object.
-     *
-     * The identity is read from `fs.BigIntStats` rather than `fs.Stats`, because
-     * `fs.Stats.ino` is a JavaScript number. An NTFS file ID is `(sequenceNumber
-     * << 48) | mftRecordIndex` and routinely exceeds `Number.MAX_SAFE_INTEGER` —
-     * in a 4000-directory probe, 1879 of them did — where the spacing between
-     * representable doubles is 8 or more. Two entries sharing a sequence number
-     * with MFT record indices within that spacing round to one double. The
-     * traversal callers would then treat a distinct directory or file as already
-     * visited and skip it with no diagnostic, and the overwrite guard would
-     * refuse a legitimate output (samchon/typia#2269).
-     *
-     * A filesystem that reports no inode at all keeps the canonical path
-     * fallback, which is the only identity available there.
-     *
-     * @param stat Stats read with `{ bigint: true }`.
-     * @param realpath Canonical path of the same object.
-     * @returns Key that is equal for two paths only when they are one object.
-     */
-    function identityKey(stat, realpath) {
-        // `BigInt(0)` rather than `0n`: this package compiles at ES2016, where a
-        // BigInt literal is a syntax error, while the constructor and the `bigint`
-        // type are fine.
-        return stat.ino === BigInt(0)
-            ? `path:${path_1.default.normalize(realpath)}`
-            : `inode:${stat.dev}:${stat.ino}`;
-    }
-    FileSystemIdentity.identityKey = identityKey;
-    function alternateCase(name) {
-        let changed = false;
-        let output = "";
-        for (const character of name) {
-            if (character >= "a" && character <= "z") {
-                output += character.toUpperCase();
-                changed = true;
-            }
-            else if (character >= "A" && character <= "Z") {
-                output += character.toLowerCase();
-                changed = true;
-            }
-            else
-                output += character;
-        }
-        return changed ? output : undefined;
-    }
-    function isAlreadyExistsError(error) {
-        return (typeof error === "object" &&
-            error !== null &&
-            "code" in error &&
-            error.code === "EEXIST");
-    }
-    function isMissingFileError(error) {
-        return (typeof error === "object" &&
-            error !== null &&
-            "code" in error &&
-            error.code === "ENOENT");
-    }
-    function formatUnknownError(error) {
-        return error instanceof Error ? error.message : String(error);
-    }
-})(FileSystemIdentity || (exports.FileSystemIdentity = FileSystemIdentity = {}));
-const TS_PATTERN = /\.[cm]?tsx?$/;
-const DTS_PATTERN = /\.d\.[cm]?tsx?$/;
-//# sourceMappingURL=FileSystemIdentity.js.map