typia 15.0.1 → 15.1.0

package/lib/basic.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = assert;
+exports.assertGuard = assertGuard;
+exports.is = is;
+exports.shallow = shallow;
+exports.validate = validate;
+exports.assertEquals = assertEquals;
+exports.assertGuardEquals = assertGuardEquals;
+exports.equals = equals;
+exports.validateEquals = validateEquals;
+exports.random = random;
+exports.createAssert = createAssert;
+exports.createAssertGuard = createAssertGuard;
+exports.createIs = createIs;
+exports.createShallow = createShallow;
+exports.createValidate = createValidate;
+exports.createAssertEquals = createAssertEquals;
+exports.createAssertGuardEquals = createAssertGuardEquals;
+exports.createEquals = createEquals;
+exports.createValidateEquals = createValidateEquals;
+exports.createRandom = createRandom;
+const NoTransformConfigurationError_1 = require("./transformers/NoTransformConfigurationError");
+/** @internal */
+function assert() {
+    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("assert");
+}
+/** @internal */
+function assertGuard() {
+    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("assertGuard");
+}
+/** @internal */
+function is() {
+    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("is");
+}
+/** @internal */
+function shallow() {
+    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("shallow");
+}
+/** @internal */
+function validate() {
+    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("validate");
+}
+/** @internal */
+function assertEquals() {
+    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("assertEquals");
+}
+/** @internal */
+function assertGuardEquals() {
+    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("assertGuardEquals");
+}
+/** @internal */
+function equals() {
+    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("equals");
+}
+/** @internal */
+function validateEquals() {
+    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("validateEquals");
+}
+/** @internal */
+function random() {
+    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("random");
+}
+/** @internal */
+function createAssert() {
+    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("createAssert");
+}
+/** @internal */
+function createAssertGuard() {
+    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("createAssertGuard");
+}
+/** @internal */
+function createIs() {
+    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("createIs");
+}
+/** @internal */
+function createShallow() {
+    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("createShallow");
+}
+/** @internal */
+function createValidate() {
+    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("createValidate");
+}
+/** @internal */
+function createAssertEquals() {
+    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("createAssertEquals");
+}
+/** @internal */
+function createAssertGuardEquals() {
+    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("createAssertGuardEquals");
+}
+/** @internal */
+function createEquals() {
+    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("createEquals");
+}
+/** @internal */
+function createValidateEquals() {
+    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("createValidateEquals");
+}
+/** @internal */
+function createRandom() {
+    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("createRandom");
+}
+//# sourceMappingURL=basic.js.map

package/lib/basic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"basic.js","sourceRoot":"","sources":["../src/basic.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAQA,gGAA6F;AAqE7F,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,QAAQ,CAAC,CAAC;AAC1C,CAAC;AAgED,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,aAAa,CAAC,CAAC;AAC/C,CAAC;AA8CD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,IAAI,CAAC,CAAC;AACtC,CAAC;AAoED,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,SAAS,CAAC,CAAC;AAC3C,CAAC;AAwDD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,UAAU,CAAC,CAAC;AAC5C,CAAC;AA+DD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,cAAc,CAAC,CAAC;AAChD,CAAC;AAwDD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,mBAAmB,CAAC,CAAC;AACrD,CAAC;AA4CD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,QAAQ,CAAC,CAAC;AAC1C,CAAC;AAsDD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,gBAAgB,CAAC,CAAC;AAClD,CAAC;AAqCD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,QAAQ,CAAC,CAAC;AAC1C,CAAC;AA6CD,gBAAgB;AAChB;IAIE,IAAA,6DAA6B,EAAC,cAAc,CAAC,CAAC;AAChD,CAAC;AAoDD,gBAAgB;AAChB;IAIE,IAAA,6DAA6B,EAAC,mBAAmB,CAAC,CAAC;AACrD,CAAC;AA4BD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,UAAU,CAAC,CAAC;AAC5C,CAAC;AAkCD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,eAAe,CAAC,CAAC;AACjD,CAAC;AA+BD,gBAAgB;AAChB;IAEE,IAAA,6DAA6B,EAAC,gBAAgB,CAAC,CAAC;AAClD,CAAC;AA2CD,gBAAgB;AAChB;IAIE,IAAA,6DAA6B,EAAC,oBAAoB,CAAC,CAAC;AACtD,CAAC;AAoDD,gBAAgB;AAChB;IAIE,IAAA,6DAA6B,EAAC,yBAAyB,CAAC,CAAC;AAC3D,CAAC;AA4BD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,cAAc,CAAC,CAAC;AAChD,CAAC;AAiCD,gBAAgB;AAChB;IAEE,IAAA,6DAA6B,EAAC,sBAAsB,CAAC,CAAC;AACxD,CAAC;AAkCD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,cAAc,CAAC,CAAC;AAChD,CAAC"}

package/lib/basic.mjs

@@ -0,0 +1,86 @@
+import { NoTransformConfigurationError } from "./transformers/NoTransformConfigurationError.mjs";
+//#region src/basic.ts
+/** @internal */
+function assert() {
+	NoTransformConfigurationError("assert");
+}
+/** @internal */
+function assertGuard() {
+	NoTransformConfigurationError("assertGuard");
+}
+/** @internal */
+function is() {
+	NoTransformConfigurationError("is");
+}
+/** @internal */
+function shallow() {
+	NoTransformConfigurationError("shallow");
+}
+/** @internal */
+function validate() {
+	NoTransformConfigurationError("validate");
+}
+/** @internal */
+function assertEquals() {
+	NoTransformConfigurationError("assertEquals");
+}
+/** @internal */
+function assertGuardEquals() {
+	NoTransformConfigurationError("assertGuardEquals");
+}
+/** @internal */
+function equals() {
+	NoTransformConfigurationError("equals");
+}
+/** @internal */
+function validateEquals() {
+	NoTransformConfigurationError("validateEquals");
+}
+/** @internal */
+function random() {
+	NoTransformConfigurationError("random");
+}
+/** @internal */
+function createAssert() {
+	NoTransformConfigurationError("createAssert");
+}
+/** @internal */
+function createAssertGuard() {
+	NoTransformConfigurationError("createAssertGuard");
+}
+/** @internal */
+function createIs() {
+	NoTransformConfigurationError("createIs");
+}
+/** @internal */
+function createShallow() {
+	NoTransformConfigurationError("createShallow");
+}
+/** @internal */
+function createValidate() {
+	NoTransformConfigurationError("createValidate");
+}
+/** @internal */
+function createAssertEquals() {
+	NoTransformConfigurationError("createAssertEquals");
+}
+/** @internal */
+function createAssertGuardEquals() {
+	NoTransformConfigurationError("createAssertGuardEquals");
+}
+/** @internal */
+function createEquals() {
+	NoTransformConfigurationError("createEquals");
+}
+/** @internal */
+function createValidateEquals() {
+	NoTransformConfigurationError("createValidateEquals");
+}
+/** @internal */
+function createRandom() {
+	NoTransformConfigurationError("createRandom");
+}
+//#endregion
+export { assert, assertEquals, assertGuard, assertGuardEquals, createAssert, createAssertEquals, createAssertGuard, createAssertGuardEquals, createEquals, createIs, createRandom, createShallow, createValidate, createValidateEquals, equals, is, random, shallow, validate, validateEquals };
+
+//# sourceMappingURL=basic.mjs.map

package/lib/basic.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"basic.mjs","names":[],"sources":["../src/basic.ts"],"sourcesContent":["import {\n  IRandomGenerator,\n  IValidation,\n  Resolved,\n  StandardSchemaV1,\n} from \"@typia/interface\";\n\nimport { TypeGuardError } from \"./TypeGuardError\";\nimport { NoTransformConfigurationError } from \"./transformers/NoTransformConfigurationError\";\n\n/* -----------------------------------------------------------\n    BASIC VALIDATORS\n----------------------------------------------------------- */\n/**\n * Asserts type `T`.\n *\n * Performs runtime type checking against compile-time type `T`. Stops at first\n * mismatch and throws {@link TypeGuardError} containing:\n *\n * - `path`: Property path where error occurred (e.g., `\"input.user.age\"`)\n * - `expected`: Expected type string (e.g., `\"number & ExclusiveMinimum<19>\"`)\n * - `value`: Actual value that failed validation\n *\n * Related functions:\n *\n * - {@link is} — Returns `boolean` instead of throwing\n * - {@link validate} — Collects all errors instead of stopping at first\n * - {@link assertGuard} — Type guard with no return value (narrows type only)\n * - {@link assertEquals} — Also rejects properties not defined in `T`\n *\n * @template T Target type to validate against\n *\n * @param input Value to assert\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n *\n * @returns The input value typed as `T`\n *\n * @throws {TypeGuardError} When input doesn't conform to type `T`\n */\nexport function assert<T>(\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): T;\n\n/**\n * Asserts type `T`.\n *\n * Performs runtime type checking against compile-time type `T`. Stops at first\n * mismatch and throws {@link TypeGuardError} containing:\n *\n * - `path`: Property path where error occurred (e.g., `\"input.user.age\"`)\n * - `expected`: Expected type string (e.g., `\"number & ExclusiveMinimum<19>\"`)\n * - `value`: Actual value that failed validation\n *\n * Related functions:\n *\n * - {@link is} — Returns `boolean` instead of throwing\n * - {@link validate} — Collects all errors instead of stopping at first\n * - {@link assertGuard} — Type guard with no return value (narrows type only)\n * - {@link assertEquals} — Also rejects properties not defined in `T`\n *\n * @template T Target type to validate against\n *\n * @param input Value to assert\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n *\n * @returns The input value typed as `T`\n *\n * @throws {TypeGuardError} When input doesn't conform to type `T`\n */\nexport function assert<T>(\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): T;\n\n/** @internal */\nexport function assert(): never {\n  NoTransformConfigurationError(\"assert\");\n}\n\n/**\n * Asserts type `T` as assertion guard.\n *\n * Unlike {@link assert}, returns nothing (`asserts input is T`). After this\n * call, TypeScript narrows `input` to type `T` in subsequent code. Useful when\n * you need type narrowing with runtime validation but don't need the return\n * value.\n *\n * Throws {@link TypeGuardError} on first mismatch with `path`, `expected`, and\n * `value`.\n *\n * Related functions:\n *\n * - {@link assert} — Same validation but returns the input value\n * - {@link is} — Returns `boolean` instead of throwing\n * - {@link validate} — Collects all errors instead of throwing\n * - {@link assertGuardEquals} — Also rejects properties not defined in `T`\n *\n * @template T Target type to validate against\n *\n * @param input Value to assert (narrowed to `T` after call)\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n *\n * @throws {TypeGuardError} When input doesn't conform to type `T`\n */\nexport function assertGuard<T>(\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): asserts input is T;\n\n/**\n * Asserts type `T` as assertion guard.\n *\n * Unlike {@link assert}, returns nothing (`asserts input is T`). After this\n * call, TypeScript narrows `input` to type `T` in subsequent code. Useful when\n * you need type narrowing with runtime validation but don't need the return\n * value.\n *\n * Throws {@link TypeGuardError} on first mismatch with `path`, `expected`, and\n * `value`.\n *\n * Related functions:\n *\n * - {@link assert} — Same validation but returns the input value\n * - {@link is} — Returns `boolean` instead of throwing\n * - {@link validate} — Collects all errors instead of throwing\n * - {@link assertGuardEquals} — Also rejects properties not defined in `T`\n *\n * @template T Target type to validate against\n *\n * @param input Value to assert (narrowed to `T` after call)\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n *\n * @throws {TypeGuardError} When input doesn't conform to type `T`\n */\nexport function assertGuard<T>(\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): asserts input is T;\n\n/** @internal */\nexport function assertGuard(): never {\n  NoTransformConfigurationError(\"assertGuard\");\n}\n\n/**\n * Tests type `T`.\n *\n * Performs runtime type checking without throwing exceptions. Acts as\n * TypeScript type guard, narrowing the input type in conditional branches when\n * result is `true`.\n *\n * Related functions:\n *\n * - {@link assert} — Throws {@link TypeGuardError} with detailed error info on\n *   mismatch\n * - {@link validate} — Returns all errors without throwing\n * - {@link equals} — Also rejects properties not defined in `T`\n *\n * @template T Target type to check\n *\n * @param input Value to test\n *\n * @returns `true` if valid, `false` otherwise (type predicate `input is T`)\n */\nexport function is<T>(input: T): input is T;\n\n/**\n * Tests type `T`.\n *\n * Performs runtime type checking without throwing exceptions. Acts as\n * TypeScript type guard, narrowing the input type in conditional branches when\n * result is `true`.\n *\n * Related functions:\n *\n * - {@link assert} — Throws {@link TypeGuardError} with detailed error info on\n *   mismatch\n * - {@link validate} — Returns all errors without throwing\n * - {@link equals} — Also rejects properties not defined in `T`\n *\n * @template T Target type to check\n *\n * @param input Value to test\n *\n * @returns `true` if valid, `false` otherwise (type predicate `input is T`)\n */\nexport function is<T>(input: unknown): input is T;\n\n/** @internal */\nexport function is(): never {\n  NoTransformConfigurationError(\"is\");\n}\n\n/**\n * Tests type `T` up to a limited depth.\n *\n * Like {@link is}, but only descends into nested objects, arrays, and tuples\n * until the depth budget `_N` is exhausted; beyond that point a value is\n * accepted as long as it is an `object` (or `null` where the type permits).\n * Useful for **discrimination** rather than full validation — when you only\n * need to know which branch of a union an input belongs to, paying for a deep\n * structural check of every leaf is wasteful.\n *\n * Because the check is shallow past depth `_N`, a `true` result is **not** a\n * guarantee that the whole value conforms to `T`. The name `shallow` reflects\n * this: only the discriminating, near-surface part of the type is verified. For\n * a full guarantee, use {@link is}.\n *\n * Related functions:\n *\n * - {@link is} — Full-depth check, returns a sound type guard\n * - {@link assert} — Throws {@link TypeGuardError} with detailed error info on\n *   mismatch\n * - {@link validate} — Returns all errors without throwing\n *\n * @template T Target type to check\n * @template _N Maximum depth to descend before accepting a value structurally.\n *   Must be a non-negative integer literal. Defaults to `2`.\n *\n * @param input Value to test\n *\n * @returns `true` if valid up to depth `_N`, `false` otherwise (type predicate\n *   `input is T`)\n */\nexport function shallow<T, _N extends number = 2>(input: T): input is T;\n\n/**\n * Tests type `T` up to a limited depth.\n *\n * Like {@link is}, but only descends into nested objects, arrays, and tuples\n * until the depth budget `_N` is exhausted; beyond that point a value is\n * accepted as long as it is an `object` (or `null` where the type permits).\n * Useful for **discrimination** rather than full validation — when you only\n * need to know which branch of a union an input belongs to, paying for a deep\n * structural check of every leaf is wasteful.\n *\n * Because the check is shallow past depth `_N`, a `true` result is **not** a\n * guarantee that the whole value conforms to `T`. The name `shallow` reflects\n * this: only the discriminating, near-surface part of the type is verified. For\n * a full guarantee, use {@link is}.\n *\n * Related functions:\n *\n * - {@link is} — Full-depth check, returns a sound type guard\n * - {@link assert} — Throws {@link TypeGuardError} with detailed error info on\n *   mismatch\n * - {@link validate} — Returns all errors without throwing\n *\n * @template T Target type to check\n * @template _N Maximum depth to descend before accepting a value structurally.\n *   Must be a non-negative integer literal. Defaults to `2`.\n *\n * @param input Value to test\n *\n * @returns `true` if valid up to depth `_N`, `false` otherwise (type predicate\n *   `input is T`)\n */\nexport function shallow<T, _N extends number = 2>(input: unknown): input is T;\n\n/** @internal */\nexport function shallow(): never {\n  NoTransformConfigurationError(\"shallow\");\n}\n\n/**\n * Validates type `T`.\n *\n * Unlike {@link assert} which throws on first error, this function continues\n * checking and collects all type mismatches into {@link IValidation.errors}\n * array. Never throws.\n *\n * Return structure:\n *\n * - `success: true` → `data` contains validated input as `T`\n * - `success: false` → `errors` array of {@link IValidation.IError} with `path`,\n *   `expected`, `value`\n *\n * Related functions:\n *\n * - {@link assert} — Throws on first error instead of collecting all\n * - {@link is} — Simple boolean check\n * - {@link validateEquals} — Also rejects properties not defined in `T`\n *\n * @template T Target type to validate against\n *\n * @param input Value to validate\n *\n * @returns {@link IValidation} <T> containing either `data` or `errors`\n */\nexport function validate<T>(input: T): IValidation<T>;\n\n/**\n * Validates type `T`.\n *\n * Unlike {@link assert} which throws on first error, this function continues\n * checking and collects all type mismatches into {@link IValidation.errors}\n * array. Never throws.\n *\n * Return structure:\n *\n * - `success: true` → `data` contains validated input as `T`\n * - `success: false` → `errors` array of {@link IValidation.IError} with `path`,\n *   `expected`, `value`\n *\n * Related functions:\n *\n * - {@link assert} — Throws on first error instead of collecting all\n * - {@link is} — Simple boolean check\n * - {@link validateEquals} — Also rejects properties not defined in `T`\n *\n * @template T Target type to validate against\n *\n * @param input Value to validate\n *\n * @returns {@link IValidation} <T> containing either `data` or `errors`\n */\nexport function validate<T>(input: unknown): IValidation<T>;\n\n/** @internal */\nexport function validate(): never {\n  NoTransformConfigurationError(\"validate\");\n}\n\n/* -----------------------------------------------------------\n    STRICT VALIDATORS\n----------------------------------------------------------- */\n/**\n * Asserts type `T` with strict equality.\n *\n * Stricter than {@link assert}: also fails when input contains any property not\n * defined in type `T`. For extra property errors, `expected` will be\n * `\"undefined\"`.\n *\n * Related functions:\n *\n * - {@link assert} — Allows extra properties\n * - {@link equals} — Boolean result without throwing\n * - {@link validateEquals} — Collects all errors without throwing\n * - {@link assertGuardEquals} — Type guard version with no return value\n *\n * @template T Target type for exact match\n *\n * @param input Value to validate\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n *\n * @returns The input value typed as `T`\n *\n * @throws {TypeGuardError} When type mismatch or extra property detected\n */\nexport function assertEquals<T>(\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): T;\n\n/**\n * Asserts type `T` with strict equality.\n *\n * Stricter than {@link assert}: also fails when input contains any property not\n * defined in type `T`. For extra property errors, `expected` will be\n * `\"undefined\"`.\n *\n * Related functions:\n *\n * - {@link assert} — Allows extra properties\n * - {@link equals} — Boolean result without throwing\n * - {@link validateEquals} — Collects all errors without throwing\n * - {@link assertGuardEquals} — Type guard version with no return value\n *\n * @template T Target type for exact match\n *\n * @param input Value to validate\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n *\n * @returns The input value typed as `T`\n *\n * @throws {TypeGuardError} When type mismatch or extra property detected\n */\nexport function assertEquals<T>(\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): T;\n\n/** @internal */\nexport function assertEquals(): never {\n  NoTransformConfigurationError(\"assertEquals\");\n}\n\n/**\n * Asserts type `T` with strict equality as assertion guard.\n *\n * Combines {@link assertGuard} with strict equality checking. Returns nothing\n * but narrows input to type `T`. Also fails when input contains properties not\n * in `T`.\n *\n * Related functions:\n *\n * - {@link assertGuard} — Allows extra properties\n * - {@link assertEquals} — Returns value instead of type guard\n * - {@link equals} — Boolean result without throwing\n * - {@link validateEquals} — Collects all errors without throwing\n *\n * @template T Target type for exact match\n *\n * @param input Value to assert (narrowed to `T` after call)\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n *\n * @throws {TypeGuardError} When type mismatch or extra property detected\n */\nexport function assertGuardEquals<T>(\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): asserts input is T;\n\n/**\n * Asserts type `T` with strict equality as assertion guard.\n *\n * Combines {@link assertGuard} with strict equality checking. Returns nothing\n * but narrows input to type `T`. Also fails when input contains properties not\n * in `T`.\n *\n * Related functions:\n *\n * - {@link assertGuard} — Allows extra properties\n * - {@link assertEquals} — Returns value instead of type guard\n * - {@link equals} — Boolean result without throwing\n * - {@link validateEquals} — Collects all errors without throwing\n *\n * @template T Target type for exact match\n *\n * @param input Value to assert (narrowed to `T` after call)\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n *\n * @throws {TypeGuardError} When type mismatch or extra property detected\n */\nexport function assertGuardEquals<T>(\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): asserts input is T;\n\n/** @internal */\nexport function assertGuardEquals(): never {\n  NoTransformConfigurationError(\"assertGuardEquals\");\n}\n\n/**\n * Tests type `T` with strict equality.\n *\n * Stricter than {@link is}: also returns `false` when input contains any\n * property not defined in type `T`. Useful for detecting unexpected data or\n * typos.\n *\n * Related functions:\n *\n * - {@link is} — Allows extra properties\n * - {@link assertEquals} — Throws with detailed error info on mismatch\n * - {@link validateEquals} — Returns all errors without throwing\n *\n * @template T Target type for exact match\n *\n * @param input Value to test\n *\n * @returns `true` if valid, `false` otherwise (type predicate `input is T`)\n */\nexport function equals<T>(input: T): input is T;\n\n/**\n * Tests type `T` with strict equality.\n *\n * Stricter than {@link is}: also returns `false` when input contains any\n * property not defined in type `T`. Useful for detecting unexpected data or\n * typos.\n *\n * Related functions:\n *\n * - {@link is} — Allows extra properties\n * - {@link assertEquals} — Throws with detailed error info on mismatch\n * - {@link validateEquals} — Returns all errors without throwing\n *\n * @template T Target type for exact match\n *\n * @param input Value to test\n *\n * @returns `true` if valid, `false` otherwise (type predicate `input is T`)\n */\nexport function equals<T>(input: unknown): input is T;\n\n/** @internal */\nexport function equals(): never {\n  NoTransformConfigurationError(\"equals\");\n}\n\n/**\n * Validates type `T` with strict equality.\n *\n * Combines {@link validate} with strict equality checking. Collects all errors\n * including extra property violations into {@link IValidation.errors} array.\n *\n * Return structure:\n *\n * - `success: true` → `data` contains validated input as `T`\n * - `success: false` → `errors` array with `path`, `expected`, `value` for each\n *   mismatch\n *\n * Related functions:\n *\n * - {@link validate} — Allows extra properties\n * - {@link assertEquals} — Throws on first error\n * - {@link equals} — Simple boolean check\n *\n * @template T Target type for exact match\n *\n * @param input Value to validate\n *\n * @returns {@link IValidation} <T> containing either `data` or `errors`\n */\nexport function validateEquals<T>(input: T): IValidation<T>;\n\n/**\n * Validates type `T` with strict equality.\n *\n * Combines {@link validate} with strict equality checking. Collects all errors\n * including extra property violations into {@link IValidation.errors} array.\n *\n * Return structure:\n *\n * - `success: true` → `data` contains validated input as `T`\n * - `success: false` → `errors` array with `path`, `expected`, `value` for each\n *   mismatch\n *\n * Related functions:\n *\n * - {@link validate} — Allows extra properties\n * - {@link assertEquals} — Throws on first error\n * - {@link equals} — Simple boolean check\n *\n * @template T Target type for exact match\n *\n * @param input Value to validate\n *\n * @returns {@link IValidation} <T> containing either `data` or `errors`\n */\nexport function validateEquals<T>(input: unknown): IValidation<T>;\n\n/** @internal */\nexport function validateEquals(): never {\n  NoTransformConfigurationError(\"validateEquals\");\n}\n\n/* -----------------------------------------------------------\n    RANDOM\n----------------------------------------------------------- */\n/**\n * Generates random data of type `T`.\n *\n * Creates random instance conforming to compile-time type `T`. Generates only\n * primitive data; methods in `T` are ignored. If `T` has `toJSON()` method,\n * generates its return type instead.\n *\n * @template T Type of data to generate\n *\n * @param generator Custom random generator implementing {@link IRandomGenerator}\n *\n * @returns Randomly generated data as `Resolved<T>`\n *\n * @danger You must configure the generic argument `T`\n */\nexport function random(generator?: Partial<IRandomGenerator>): never;\n\n/**\n * Generates random data of type `T`.\n *\n * Creates random instance conforming to compile-time type `T`. Generates only\n * primitive data; methods in `T` are ignored. If `T` has `toJSON()` method,\n * generates its return type instead.\n *\n * @template T Type of data to generate\n *\n * @param generator Custom random generator implementing {@link IRandomGenerator}\n *\n * @returns Randomly generated data as `Resolved<T>`\n */\nexport function random<T>(generator?: Partial<IRandomGenerator>): Resolved<T>;\n\n/** @internal */\nexport function random(): never {\n  NoTransformConfigurationError(\"random\");\n}\n\n/* -----------------------------------------------------------\n    FACTORY FUNCTIONS\n----------------------------------------------------------- */\n/**\n * Creates reusable {@link assert} function.\n *\n * Returns a function that can be called multiple times without recompilation.\n * Useful when the same type validation is needed repeatedly.\n *\n * @template T Target type to validate against\n *\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n *\n * @returns Reusable assert function `(input: unknown, errorFactory?) => T`\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createAssert(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assert} function.\n *\n * Returns a function that can be called multiple times without recompilation.\n * Useful when the same type validation is needed repeatedly.\n *\n * @template T Target type to validate against\n *\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n *\n * @returns Reusable assert function `(input: unknown, errorFactory?) => T`,\n *   whose own `errorFactory` overrides this one for that single call\n */\nexport function createAssert<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n) => T;\n\n/** @internal */\nexport function createAssert<T>(): (\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n) => T {\n  NoTransformConfigurationError(\"createAssert\");\n}\n\n/**\n * Creates reusable {@link assertGuard} function.\n *\n * Returns a reusable type guard assertion function.\n *\n * TypeScript requirement: You must declare the variable type explicitly. `const\n * fn: AssertionGuard<T> = createAssertGuard<T>()` — otherwise compile error.\n * That annotation is one parameter wide, so it also hides the call-time\n * `errorFactory`; annotate with `(input: unknown, errorFactory?: (props:\n * TypeGuardError.IProps) => Error) => asserts input is T` when you need it.\n *\n * @template T Target type to validate against\n *\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n *\n * @returns Reusable assertion guard function\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertGuard(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertGuard} function.\n *\n * Returns a reusable type guard assertion function.\n *\n * TypeScript requirement: You must declare the variable type explicitly. `const\n * fn: AssertionGuard<T> = createAssertGuard<T>()` — otherwise compile error.\n * That annotation is one parameter wide, so it also hides the call-time\n * `errorFactory`; annotate with `(input: unknown, errorFactory?: (props:\n * TypeGuardError.IProps) => Error) => asserts input is T` when you need it.\n *\n * @template T Target type to validate against\n *\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n *\n * @returns Reusable assertion guard function, whose own `errorFactory`\n *   overrides this one for that single call\n */\nexport function createAssertGuard<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n) => asserts input is T;\n\n/** @internal */\nexport function createAssertGuard<T>(): (\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n) => asserts input is T {\n  NoTransformConfigurationError(\"createAssertGuard\");\n}\n\n/**\n * Creates reusable {@link is} function.\n *\n * Returns a type guard function that can be called multiple times without\n * recompilation.\n *\n * @template T Target type to check\n *\n * @returns Reusable type guard function `(input: unknown) => input is T`\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createIs(): never;\n\n/**\n * Creates reusable {@link is} function.\n *\n * Returns a type guard function that can be called multiple times without\n * recompilation.\n *\n * @template T Target type to check\n *\n * @returns Reusable type guard function `(input: unknown) => input is T`\n */\nexport function createIs<T>(): (input: unknown) => input is T;\n\n/** @internal */\nexport function createIs<T>(): (input: unknown) => input is T {\n  NoTransformConfigurationError(\"createIs\");\n}\n\n/**\n * Creates reusable {@link shallow} function.\n *\n * Returns a depth-limited type guard function that can be called multiple times\n * without recompilation.\n *\n * @template T Target type to check\n * @template _N Maximum depth to descend before accepting a value structurally.\n *   Must be a non-negative integer literal. Defaults to `2`.\n *\n * @returns Reusable type guard function `(input: unknown) => input is T`\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createShallow(): never;\n\n/**\n * Creates reusable {@link shallow} function.\n *\n * Returns a depth-limited type guard function that can be called multiple times\n * without recompilation.\n *\n * @template T Target type to check\n * @template _N Maximum depth to descend before accepting a value structurally.\n *   Must be a non-negative integer literal. Defaults to `2`.\n *\n * @returns Reusable type guard function `(input: unknown) => input is T`\n */\nexport function createShallow<T, _N extends number = 2>(): (\n  input: unknown,\n) => input is T;\n\n/** @internal */\nexport function createShallow<T>(): (input: unknown) => input is T {\n  NoTransformConfigurationError(\"createShallow\");\n}\n\n/**\n * Creates reusable {@link validate} function.\n *\n * Returns a validation function that can be called multiple times without\n * recompilation. Also implements {@link StandardSchemaV1} interface for\n * interoperability.\n *\n * @template T Target type to validate against\n *\n * @returns Reusable validate function `(input: unknown) => IValidation<T>`\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createValidate(): never;\n\n/**\n * Creates reusable {@link validate} function.\n *\n * Returns a validation function that can be called multiple times without\n * recompilation. Also implements {@link StandardSchemaV1} interface for\n * interoperability.\n *\n * @template T Target type to validate against\n *\n * @returns Reusable validate function `(input: unknown) => IValidation<T>`\n */\nexport function createValidate<T>(): ((input: unknown) => IValidation<T>) &\n  StandardSchemaV1<T, T>;\n\n/** @internal */\nexport function createValidate(): ((input: unknown) => IValidation) &\n  StandardSchemaV1<unknown, unknown> {\n  NoTransformConfigurationError(\"createValidate\");\n}\n\n/**\n * Creates reusable {@link assertEquals} function.\n *\n * Returns a strict assertion function that rejects superfluous properties. Can\n * be called multiple times without recompilation.\n *\n * @template T Target type for exact match\n *\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n *\n * @returns Reusable assertEquals function `(input: unknown, errorFactory?) =>\n *   T`\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertEquals(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertEquals} function.\n *\n * Returns a strict assertion function that rejects superfluous properties. Can\n * be called multiple times without recompilation.\n *\n * @template T Target type for exact match\n *\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n *\n * @returns Reusable assertEquals function `(input: unknown, errorFactory?) =>\n *   T`, whose own `errorFactory` overrides this one for that single call\n */\nexport function createAssertEquals<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n) => T;\n\n/** @internal */\nexport function createAssertEquals<T>(): (\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n) => T {\n  NoTransformConfigurationError(\"createAssertEquals\");\n}\n\n/**\n * Creates reusable {@link assertGuardEquals} function.\n *\n * Returns a strict assertion guard that rejects superfluous properties.\n *\n * TypeScript requirement: You must declare the variable type explicitly. `const\n * fn: AssertionGuard<T> = createAssertGuardEquals<T>()` — otherwise compile\n * error. That annotation is one parameter wide, so it also hides the call-time\n * `errorFactory`; annotate with `(input: unknown, errorFactory?: (props:\n * TypeGuardError.IProps) => Error) => asserts input is T` when you need it.\n *\n * @template T Target type for exact match\n *\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n *\n * @returns Reusable assertion guard function\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertGuardEquals(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertGuardEquals} function.\n *\n * Returns a strict assertion guard that rejects superfluous properties.\n *\n * TypeScript requirement: You must declare the variable type explicitly. `const\n * fn: AssertionGuard<T> = createAssertGuardEquals<T>()` — otherwise compile\n * error. That annotation is one parameter wide, so it also hides the call-time\n * `errorFactory`; annotate with `(input: unknown, errorFactory?: (props:\n * TypeGuardError.IProps) => Error) => asserts input is T` when you need it.\n *\n * @template T Target type for exact match\n *\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n *\n * @returns Reusable assertion guard function, whose own `errorFactory`\n *   overrides this one for that single call\n */\nexport function createAssertGuardEquals<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n) => asserts input is T;\n\n/** @internal */\nexport function createAssertGuardEquals<T>(): (\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n) => asserts input is T {\n  NoTransformConfigurationError(\"createAssertGuardEquals\");\n}\n\n/**\n * Creates reusable {@link equals} function.\n *\n * Returns a strict type guard that rejects superfluous properties. Can be\n * called multiple times without recompilation.\n *\n * @template T Target type for exact match\n *\n * @returns Reusable type guard function `(input: unknown) => input is T`\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createEquals(): never;\n\n/**\n * Creates reusable {@link equals} function.\n *\n * Returns a strict type guard that rejects superfluous properties. Can be\n * called multiple times without recompilation.\n *\n * @template T Target type for exact match\n *\n * @returns Reusable type guard function `(input: unknown) => input is T`\n */\nexport function createEquals<T>(): (input: unknown) => input is T;\n\n/** @internal */\nexport function createEquals<T>(): (input: unknown) => input is T {\n  NoTransformConfigurationError(\"createEquals\");\n}\n\n/**\n * Creates reusable {@link validateEquals} function.\n *\n * Returns a strict validation function that rejects superfluous properties.\n * Also implements {@link StandardSchemaV1} interface for interoperability.\n *\n * @template T Target type for exact match\n *\n * @returns Reusable validateEquals function `(input: unknown) =>\n *   IValidation<T>`\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createValidateEquals(): never;\n\n/**\n * Creates reusable {@link validateEquals} function.\n *\n * Returns a strict validation function that rejects superfluous properties.\n * Also implements {@link StandardSchemaV1} interface for interoperability.\n *\n * @template T Target type for exact match\n *\n * @returns Reusable validateEquals function `(input: unknown) =>\n *   IValidation<T>`\n */\nexport function createValidateEquals<T>(): ((\n  input: unknown,\n) => IValidation<T>) &\n  StandardSchemaV1<T, T>;\n\n/** @internal */\nexport function createValidateEquals(): ((input: unknown) => IValidation) &\n  StandardSchemaV1<unknown, unknown> {\n  NoTransformConfigurationError(\"createValidateEquals\");\n}\n\n/**\n * Creates reusable {@link random} function.\n *\n * Returns a random data generator that can be called multiple times without\n * recompilation.\n *\n * @template T Type of data to generate\n *\n * @param generator Custom random generator implementing {@link IRandomGenerator}\n *\n * @returns Reusable random function `() => Resolved<T>`\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createRandom(generator?: Partial<IRandomGenerator>): never;\n\n/**\n * Creates reusable {@link random} function.\n *\n * Returns a random data generator that can be called multiple times without\n * recompilation.\n *\n * @template T Type of data to generate\n *\n * @param generator Custom random generator implementing {@link IRandomGenerator}\n *\n * @returns Reusable random function `() => Resolved<T>`\n */\nexport function createRandom<T>(\n  generator?: Partial<IRandomGenerator>,\n): () => Resolved<T>;\n\n/** @internal */\nexport function createRandom(): never {\n  NoTransformConfigurationError(\"createRandom\");\n}\n"],"mappings":";;;AA8EA,SAAgB,SAAgB;CAC9B,8BAA8B,QAAQ;AACxC;;AAiEA,SAAgB,cAAqB;CACnC,8BAA8B,aAAa;AAC7C;;AA+CA,SAAgB,KAAY;CAC1B,8BAA8B,IAAI;AACpC;;AAqEA,SAAgB,UAAiB;CAC/B,8BAA8B,SAAS;AACzC;;AAyDA,SAAgB,WAAkB;CAChC,8BAA8B,UAAU;AAC1C;;AAgEA,SAAgB,eAAsB;CACpC,8BAA8B,cAAc;AAC9C;;AAyDA,SAAgB,oBAA2B;CACzC,8BAA8B,mBAAmB;AACnD;;AA6CA,SAAgB,SAAgB;CAC9B,8BAA8B,QAAQ;AACxC;;AAuDA,SAAgB,iBAAwB;CACtC,8BAA8B,gBAAgB;AAChD;;AAsCA,SAAgB,SAAgB;CAC9B,8BAA8B,QAAQ;AACxC;;AA8CA,SAAgB,eAGT;CACL,8BAA8B,cAAc;AAC9C;;AAqDA,SAAgB,oBAGQ;CACtB,8BAA8B,mBAAmB;AACnD;;AA6BA,SAAgB,WAA8C;CAC5D,8BAA8B,UAAU;AAC1C;;AAmCA,SAAgB,gBAAmD;CACjE,8BAA8B,eAAe;AAC/C;;AAgCA,SAAgB,iBACqB;CACnC,8BAA8B,gBAAgB;AAChD;;AA4CA,SAAgB,qBAGT;CACL,8BAA8B,oBAAoB;AACpD;;AAqDA,SAAgB,0BAGQ;CACtB,8BAA8B,yBAAyB;AACzD;;AA6BA,SAAgB,eAAkD;CAChE,8BAA8B,cAAc;AAC9C;;AAkCA,SAAgB,uBACqB;CACnC,8BAA8B,sBAAsB;AACtD;;AAmCA,SAAgB,eAAsB;CACpC,8BAA8B,cAAc;AAC9C"}

package/lib/compare.d.ts

@@ -1,4 +1,16 @@
 import { Atomic } from "@typia/interface";
+/**
+ * The partial form of `T` that `typia.compare.cover` matches against.
+ *
+ * Atomics, null, undefined and functions stay as they are, an array becomes an
+ * array of covered elements and every property of an object becomes optional
+ * and covered in turn.
+ *
+ * @evidence contracts/common.md#principled-implementation The mapped type keeps atomics, null, undefined and functions as they are, turns an array or tuple into an array of covered elements and an object into a record whose properties are optional and covered recursively. The array branch transforms element types without encoding the original tuple length; identical compared array lengths are enforced separately by the runtime transform.
+ * @evidence contracts/common.md#clear-and-simple-design One recursive conditional alias used by the `cover` signature.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A type-level description with no runtime effect; the transform decides what the call compares.
+ * @evidence contracts/common.md#meaningful-documentation A comment states what the alias describes and how it relates to the cover operation.
+ */
 export type Cover<T> = T extends Atomic.Type | null | undefined ? T : T extends (...args: any[]) => any ? T : T extends readonly (infer U)[] ? Cover<U>[] : T extends object ? {
     [K in keyof T]?: Cover<T[K]>;
 } : T;
@@ -12,8 +24,10 @@ export type Cover<T> = T extends Atomic.Type | null | undefined ? T : T extends
  * comparison.
  *
  * @template T Type of values to compare
+ *
  * @param x Left value
  * @param y Right value
+ *
  * @returns Whether both values are equal by structure
  */
 export declare function equals<T>(x: T, y: T): boolean;
@@ -24,8 +38,10 @@ export declare function equals<T>(x: T, y: T): boolean;
  * tuples still require identical lengths and compare element-by-element.
  *
  * @template T Type of value to compare
+ *
  * @param x Full value
  * @param y Partial value to match
+ *
  * @returns Whether `x` covers `y`
  */
 export declare function cover<T>(x: T, y: Cover<T>): boolean;
@@ -49,8 +65,10 @@ export declare function cover<T>(x: T, y: Cover<T>): boolean;
  * ```
  *
  * @template T Type of values to compare
+ *
  * @param x Left value
  * @param y Right value
+ *
  * @returns Whether `x` precedes `y`
  */
 export declare function less<T>(x: T, y: T): boolean;
@@ -64,6 +82,7 @@ export declare function createEquals(): never;
  * Creates reusable {@link equals} function.
  *
  * @template T Type of values to compare
+ *
  * @returns Reusable equality function
  */
 export declare function createEquals<T>(): (x: T, y: T) => boolean;
@@ -77,6 +96,7 @@ export declare function createCover(): never;
  * Creates reusable {@link cover} function.
  *
  * @template T Type of value to compare
+ *
  * @returns Reusable cover function
  */
 export declare function createCover<T>(): (x: T, y: Cover<T>) => boolean;
@@ -90,6 +110,7 @@ export declare function createLess(): never;
  * Creates reusable {@link less} function.
  *
  * @template T Type of values to compare
+ *
  * @returns Reusable ordering function
  */
 export declare function createLess<T>(): (x: T, y: T) => boolean;

package/lib/compare.js.map

@@ -1 +1 @@
-{"version":3,"file":"compare.js","sourceRoot":"","sources":["../src/compare.ts"],"names":[],"mappings":";;;;;;;;AASA,gGAA6F;AA+B7F,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,gBAAgB,CAAC,CAAC;AAClD,CAAC;AAeD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,eAAe,CAAC,CAAC;AACjD,CAAC;AA+BD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,cAAc,CAAC,CAAC;AAChD,CAAC;AAoBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,sBAAsB,CAAC,CAAC;AACxD,CAAC;AAiBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,qBAAqB,CAAC,CAAC;AACvD,CAAC;AAiBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,oBAAoB,CAAC,CAAC;AACtD,CAAC"}
+{"version":3,"file":"compare.js","sourceRoot":"","sources":["../src/compare.ts"],"names":[],"mappings":";;;;;;;;AASA,gGAA6F;AA6C7F,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,gBAAgB,CAAC,CAAC;AAClD,CAAC;AAiBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,eAAe,CAAC,CAAC;AACjD,CAAC;AAiCD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,cAAc,CAAC,CAAC;AAChD,CAAC;AAqBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,sBAAsB,CAAC,CAAC;AACxD,CAAC;AAkBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,qBAAqB,CAAC,CAAC;AACvD,CAAC;AAkBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,oBAAoB,CAAC,CAAC;AACtD,CAAC"}

package/lib/compare.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"compare.mjs","names":[],"sources":["../src/compare.ts"],"sourcesContent":["/* ===========================================================\n    COMPARE\n      - EQUALS\n      - COVER\n      - LESS\n      - FACTORY FUNCTIONS\n=========================================================== */\nimport { Atomic } from \"@typia/interface\";\n\nimport { NoTransformConfigurationError } from \"./transformers/NoTransformConfigurationError\";\n\nexport type Cover<T> = T extends Atomic.Type | null | undefined\n  ? T\n  : T extends (...args: any[]) => any\n    ? T\n    : T extends readonly (infer U)[]\n      ? Cover<U>[]\n      : T extends object\n        ? { [K in keyof T]?: Cover<T[K]> }\n        : T;\n\n/* -----------------------------------------------------------\n    EQUALS\n----------------------------------------------------------- */\n/**\n * Compares two values of type `T`.\n *\n * Performs a type-directed deep equality comparison. Object properties are\n * compared by the declared structure of `T`; extra runtime properties are not\n * part of the comparison. When `T` (or a nested object type) declares an\n * `equals(y: T): boolean` method, that method is used instead of the structural\n * comparison.\n *\n * @template T Type of values to compare\n * @param x Left value\n * @param y Right value\n * @returns Whether both values are equal by structure\n */\nexport function equals<T>(x: T, y: T): boolean;\n\n/** @internal */\nexport function equals(): never {\n  NoTransformConfigurationError(\"compare.equals\");\n}\n\n/**\n * Compares whether `x` covers the defined structure of `y`.\n *\n * Object properties whose value is `undefined` in `y` are ignored. Arrays and\n * tuples still require identical lengths and compare element-by-element.\n *\n * @template T Type of value to compare\n * @param x Full value\n * @param y Partial value to match\n * @returns Whether `x` covers `y`\n */\nexport function cover<T>(x: T, y: Cover<T>): boolean;\n\n/** @internal */\nexport function cover(): never {\n  NoTransformConfigurationError(\"compare.cover\");\n}\n\n/* -----------------------------------------------------------\n    LESS\n----------------------------------------------------------- */\n/**\n * Tests whether `x` precedes `y`.\n *\n * Performs a type-directed lexicographic comparison: the properties of `T` are\n * walked in declaration order, depth-first, and the scalar leaves (`number` /\n * `boolean` / `string` / `bigint`) are compared one by one. The result is\n * decided by the first leaf where `x` and `y` differ; if every leaf is equal,\n * the result is `false` (equal is not \"less\"). When `T` (or a nested object\n * type) declares a `less(y: T): boolean` method, that method is used instead of\n * the structural comparison.\n *\n * The ordering is total and deterministic, so it composes into an\n * `Array.prototype.sort` comparator:\n *\n * ```ts\n * const cmp = (a: T, b: T): number =>\n *   typia.compare.less(a, b) ? -1 : typia.compare.less(b, a) ? 1 : 0;\n * ```\n *\n * @template T Type of values to compare\n * @param x Left value\n * @param y Right value\n * @returns Whether `x` precedes `y`\n */\nexport function less<T>(x: T, y: T): boolean;\n\n/** @internal */\nexport function less(): never {\n  NoTransformConfigurationError(\"compare.less\");\n}\n\n/* -----------------------------------------------------------\n    FACTORY FUNCTIONS\n----------------------------------------------------------- */\n/**\n * Creates reusable {@link equals} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createEquals(): never;\n\n/**\n * Creates reusable {@link equals} function.\n *\n * @template T Type of values to compare\n * @returns Reusable equality function\n */\nexport function createEquals<T>(): (x: T, y: T) => boolean;\n\n/** @internal */\nexport function createEquals(): never {\n  NoTransformConfigurationError(\"compare.createEquals\");\n}\n\n/**\n * Creates reusable {@link cover} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createCover(): never;\n\n/**\n * Creates reusable {@link cover} function.\n *\n * @template T Type of value to compare\n * @returns Reusable cover function\n */\nexport function createCover<T>(): (x: T, y: Cover<T>) => boolean;\n\n/** @internal */\nexport function createCover(): never {\n  NoTransformConfigurationError(\"compare.createCover\");\n}\n\n/**\n * Creates reusable {@link less} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createLess(): never;\n\n/**\n * Creates reusable {@link less} function.\n *\n * @template T Type of values to compare\n * @returns Reusable ordering function\n */\nexport function createLess<T>(): (x: T, y: T) => boolean;\n\n/** @internal */\nexport function createLess(): never {\n  NoTransformConfigurationError(\"compare.createLess\");\n}\n"],"mappings":";;;;;;;;;;;;AAyCA,SAAgB,SAAgB;CAC9B,8BAA8B,gBAAgB;AAChD;;AAgBA,SAAgB,QAAe;CAC7B,8BAA8B,eAAe;AAC/C;;AAgCA,SAAgB,OAAc;CAC5B,8BAA8B,cAAc;AAC9C;;AAqBA,SAAgB,eAAsB;CACpC,8BAA8B,sBAAsB;AACtD;;AAkBA,SAAgB,cAAqB;CACnC,8BAA8B,qBAAqB;AACrD;;AAkBA,SAAgB,aAAoB;CAClC,8BAA8B,oBAAoB;AACpD"}
+{"version":3,"file":"compare.mjs","names":[],"sources":["../src/compare.ts"],"sourcesContent":["/* ===========================================================\n    COMPARE\n      - EQUALS\n      - COVER\n      - LESS\n      - FACTORY FUNCTIONS\n=========================================================== */\nimport { Atomic } from \"@typia/interface\";\n\nimport { NoTransformConfigurationError } from \"./transformers/NoTransformConfigurationError\";\n\n/**\n * The partial form of `T` that `typia.compare.cover` matches against.\n *\n * Atomics, null, undefined and functions stay as they are, an array becomes an\n * array of covered elements and every property of an object becomes optional\n * and covered in turn.\n *\n * @evidence contracts/common.md#principled-implementation The mapped type keeps atomics, null, undefined and functions as they are, turns an array or tuple into an array of covered elements and an object into a record whose properties are optional and covered recursively. The array branch transforms element types without encoding the original tuple length; identical compared array lengths are enforced separately by the runtime transform.\n * @evidence contracts/common.md#clear-and-simple-design One recursive conditional alias used by the `cover` signature.\n * @evidence contracts/common.md#prohibited-implementation-shortcuts A type-level description with no runtime effect; the transform decides what the call compares.\n * @evidence contracts/common.md#meaningful-documentation A comment states what the alias describes and how it relates to the cover operation.\n */\nexport type Cover<T> = T extends Atomic.Type | null | undefined\n  ? T\n  : T extends (...args: any[]) => any\n    ? T\n    : T extends readonly (infer U)[]\n      ? Cover<U>[]\n      : T extends object\n        ? { [K in keyof T]?: Cover<T[K]> }\n        : T;\n\n/* -----------------------------------------------------------\n    EQUALS\n----------------------------------------------------------- */\n/**\n * Compares two values of type `T`.\n *\n * Performs a type-directed deep equality comparison. Object properties are\n * compared by the declared structure of `T`; extra runtime properties are not\n * part of the comparison. When `T` (or a nested object type) declares an\n * `equals(y: T): boolean` method, that method is used instead of the structural\n * comparison.\n *\n * @template T Type of values to compare\n *\n * @param x Left value\n * @param y Right value\n *\n * @returns Whether both values are equal by structure\n */\nexport function equals<T>(x: T, y: T): boolean;\n\n/** @internal */\nexport function equals(): never {\n  NoTransformConfigurationError(\"compare.equals\");\n}\n\n/**\n * Compares whether `x` covers the defined structure of `y`.\n *\n * Object properties whose value is `undefined` in `y` are ignored. Arrays and\n * tuples still require identical lengths and compare element-by-element.\n *\n * @template T Type of value to compare\n *\n * @param x Full value\n * @param y Partial value to match\n *\n * @returns Whether `x` covers `y`\n */\nexport function cover<T>(x: T, y: Cover<T>): boolean;\n\n/** @internal */\nexport function cover(): never {\n  NoTransformConfigurationError(\"compare.cover\");\n}\n\n/* -----------------------------------------------------------\n    LESS\n----------------------------------------------------------- */\n/**\n * Tests whether `x` precedes `y`.\n *\n * Performs a type-directed lexicographic comparison: the properties of `T` are\n * walked in declaration order, depth-first, and the scalar leaves (`number` /\n * `boolean` / `string` / `bigint`) are compared one by one. The result is\n * decided by the first leaf where `x` and `y` differ; if every leaf is equal,\n * the result is `false` (equal is not \"less\"). When `T` (or a nested object\n * type) declares a `less(y: T): boolean` method, that method is used instead of\n * the structural comparison.\n *\n * The ordering is total and deterministic, so it composes into an\n * `Array.prototype.sort` comparator:\n *\n * ```ts\n * const cmp = (a: T, b: T): number =>\n *   typia.compare.less(a, b) ? -1 : typia.compare.less(b, a) ? 1 : 0;\n * ```\n *\n * @template T Type of values to compare\n *\n * @param x Left value\n * @param y Right value\n *\n * @returns Whether `x` precedes `y`\n */\nexport function less<T>(x: T, y: T): boolean;\n\n/** @internal */\nexport function less(): never {\n  NoTransformConfigurationError(\"compare.less\");\n}\n\n/* -----------------------------------------------------------\n    FACTORY FUNCTIONS\n----------------------------------------------------------- */\n/**\n * Creates reusable {@link equals} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createEquals(): never;\n\n/**\n * Creates reusable {@link equals} function.\n *\n * @template T Type of values to compare\n *\n * @returns Reusable equality function\n */\nexport function createEquals<T>(): (x: T, y: T) => boolean;\n\n/** @internal */\nexport function createEquals(): never {\n  NoTransformConfigurationError(\"compare.createEquals\");\n}\n\n/**\n * Creates reusable {@link cover} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createCover(): never;\n\n/**\n * Creates reusable {@link cover} function.\n *\n * @template T Type of value to compare\n *\n * @returns Reusable cover function\n */\nexport function createCover<T>(): (x: T, y: Cover<T>) => boolean;\n\n/** @internal */\nexport function createCover(): never {\n  NoTransformConfigurationError(\"compare.createCover\");\n}\n\n/**\n * Creates reusable {@link less} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createLess(): never;\n\n/**\n * Creates reusable {@link less} function.\n *\n * @template T Type of values to compare\n *\n * @returns Reusable ordering function\n */\nexport function createLess<T>(): (x: T, y: T) => boolean;\n\n/** @internal */\nexport function createLess(): never {\n  NoTransformConfigurationError(\"compare.createLess\");\n}\n"],"mappings":";;;;;;;;;;;;AAuDA,SAAgB,SAAgB;CAC9B,8BAA8B,gBAAgB;AAChD;;AAkBA,SAAgB,QAAe;CAC7B,8BAA8B,eAAe;AAC/C;;AAkCA,SAAgB,OAAc;CAC5B,8BAA8B,cAAc;AAC9C;;AAsBA,SAAgB,eAAsB;CACpC,8BAA8B,sBAAsB;AACtD;;AAmBA,SAAgB,cAAqB;CACnC,8BAA8B,qBAAqB;AACrD;;AAmBA,SAAgB,aAAoB;CAClC,8BAA8B,oBAAoB;AACpD"}

package/lib/functional.d.ts

@@ -21,10 +21,13 @@ type FunctionalValidate<T extends (...args: any[]) => any> = T extends (this: in
  * - {@link assertEqualsFunction} — Also rejects extra properties
  *
  * @template T Target function type
+ *
  * @param func Function to wrap
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
+ *
  * @returns Wrapped function with same signature
+ *
  * @throws {TypeGuardError} When parameter or return value type mismatch
  */
 export declare function assertFunction<T extends (...args: any[]) => any>(func: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): T;
@@ -44,10 +47,13 @@ export declare function assertFunction<T extends (...args: any[]) => any>(func:
  * - {@link assertEqualsParameters} — Also rejects extra properties
  *
  * @template T Target function type
+ *
  * @param func Function to wrap
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
+ *
  * @returns Wrapped function with same signature
+ *
  * @throws {TypeGuardError} When parameter type mismatch
  */
 export declare function assertParameters<T extends (...args: any[]) => any>(func: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): T;
@@ -67,10 +73,13 @@ export declare function assertParameters<T extends (...args: any[]) => any>(func
  * - {@link assertEqualsReturn} — Also rejects extra properties
  *
  * @template T Target function type
+ *
  * @param func Function to wrap
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
+ *
  * @returns Wrapped function with same signature
+ *
  * @throws {TypeGuardError} When return value type mismatch
  */
 export declare function assertReturn<T extends (...args: any[]) => any>(func: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): T;
@@ -93,10 +102,13 @@ export declare function assertReturn<T extends (...args: any[]) => any>(func: T,
  * - {@link validateEqualsFunction} — Collects all errors instead of throwing
  *
  * @template T Target function type
+ *
  * @param func Function to wrap
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
+ *
  * @returns Wrapped function with same signature
+ *
  * @throws {TypeGuardError} When type mismatch or extra property detected
  */
 export declare function assertEqualsFunction<T extends (...args: any[]) => any>(func: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): T;
@@ -116,10 +128,13 @@ export declare function assertEqualsFunction<T extends (...args: any[]) => any>(
  * - {@link validateEqualsParameters} — Collects all errors instead of throwing
  *
  * @template T Target function type
+ *
  * @param func Function to wrap
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
+ *
  * @returns Wrapped function with same signature
+ *
  * @throws {TypeGuardError} When type mismatch or extra property detected
  */
 export declare function assertEqualsParameters<T extends (...args: any[]) => any>(func: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): T;
@@ -139,10 +154,13 @@ export declare function assertEqualsParameters<T extends (...args: any[]) => any
  * - {@link validateEqualsReturn} — Collects all errors instead of throwing
  *
  * @template T Target function type
+ *
  * @param func Function to wrap
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
+ *
  * @returns Wrapped function with same signature
+ *
  * @throws {TypeGuardError} When type mismatch or extra property detected
  */
 export declare function assertEqualsReturn<T extends (...args: any[]) => any>(func: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): T;
@@ -161,7 +179,9 @@ export declare function assertEqualsReturn<T extends (...args: any[]) => any>(fu
  * - {@link equalsFunction} — Also rejects extra properties
  *
  * @template T Target function type
+ *
  * @param func Function to wrap
+ *
  * @returns Wrapped function returning `Output | null`
  */
 export declare function isFunction<T extends (...args: any[]) => any>(func: T): FunctionalIs<T>;
@@ -180,7 +200,9 @@ export declare function isFunction<T extends (...args: any[]) => any>(func: T):
  * - {@link equalsParameters} — Also rejects extra properties
  *
  * @template T Target function type
+ *
  * @param func Function to wrap
+ *
  * @returns Wrapped function returning `Output | null`
  */
 export declare function isParameters<T extends (...args: any[]) => any>(func: T): FunctionalIs<T>;
@@ -199,7 +221,9 @@ export declare function isParameters<T extends (...args: any[]) => any>(func: T)
  * - {@link equalsReturn} — Also rejects extra properties
  *
  * @template T Target function type
+ *
  * @param func Function to wrap
+ *
  * @returns Wrapped function returning `Output | null`
  */
 export declare function isReturn<T extends (...args: any[]) => any>(func: T): FunctionalIs<T>;
@@ -218,7 +242,9 @@ export declare function isReturn<T extends (...args: any[]) => any>(func: T): Fu
  * - {@link validateEqualsFunction} — Returns all error details
  *
  * @template T Target function type
+ *
  * @param func Function to wrap
+ *
  * @returns Wrapped function returning `Output | null`
  */
 export declare function equalsFunction<T extends (...args: any[]) => any>(func: T): FunctionalIs<T>;
@@ -237,7 +263,9 @@ export declare function equalsFunction<T extends (...args: any[]) => any>(func:
  * - {@link validateEqualsParameters} — Returns all error details
  *
  * @template T Target function type
+ *
  * @param func Function to wrap
+ *
  * @returns Wrapped function returning `Output | null`
  */
 export declare function equalsParameters<T extends (...args: any[]) => any>(func: T): FunctionalIs<T>;
@@ -256,7 +284,9 @@ export declare function equalsParameters<T extends (...args: any[]) => any>(func
  * - {@link validateEqualsReturn} — Returns all error details
  *
  * @template T Target function type
+ *
  * @param func Function to wrap
+ *
  * @returns Wrapped function returning `Output | null`
  */
 export declare function equalsReturn<T extends (...args: any[]) => any>(func: T): FunctionalIs<T>;
@@ -279,7 +309,9 @@ export declare function equalsReturn<T extends (...args: any[]) => any>(func: T)
  * - {@link validateEqualsFunction} — Also rejects extra properties
  *
  * @template T Target function type
+ *
  * @param func Function to wrap
+ *
  * @returns Wrapped function returning {@link IValidation}
  */
 export declare function validateFunction<T extends (...args: any[]) => any>(func: T): FunctionalValidate<T>;
@@ -299,7 +331,9 @@ export declare function validateFunction<T extends (...args: any[]) => any>(func
  * - {@link validateEqualsParameters} — Also rejects extra properties
  *
  * @template T Target function type
+ *
  * @param func Function to wrap
+ *
  * @returns Wrapped function returning {@link IValidation}
  */
 export declare function validateParameters<T extends (...args: any[]) => any>(func: T): FunctionalValidate<T>;
@@ -319,7 +353,9 @@ export declare function validateParameters<T extends (...args: any[]) => any>(fu
  * - {@link validateEqualsReturn} — Also rejects extra properties
  *
  * @template T Target function type
+ *
  * @param func Function to wrap
+ *
  * @returns Wrapped function returning {@link IValidation}
  */
 export declare function validateReturn<T extends (...args: any[]) => any>(func: T): FunctionalValidate<T>;
@@ -342,7 +378,9 @@ export declare function validateReturn<T extends (...args: any[]) => any>(func:
  * - {@link assertEqualsFunction} — Throws on first error
  *
  * @template T Target function type
+ *
  * @param func Function to wrap
+ *
  * @returns Wrapped function returning {@link IValidation}
  */
 export declare function validateEqualsFunction<T extends (...args: any[]) => any>(func: T): FunctionalValidate<T>;
@@ -362,7 +400,9 @@ export declare function validateEqualsFunction<T extends (...args: any[]) => any
  * - {@link assertEqualsParameters} — Throws on first error
  *
  * @template T Target function type
+ *
  * @param func Function to wrap
+ *
  * @returns Wrapped function returning {@link IValidation}
  */
 export declare function validateEqualsParameters<T extends (...args: any[]) => any>(func: T): FunctionalValidate<T>;
@@ -382,7 +422,9 @@ export declare function validateEqualsParameters<T extends (...args: any[]) => a
  * - {@link assertEqualsReturn} — Throws on first error
  *
  * @template T Target function type
+ *
  * @param func Function to wrap
+ *
  * @returns Wrapped function returning {@link IValidation}
  */
 export declare function validateEqualsReturn<T extends (...args: any[]) => any>(func: T): FunctionalValidate<T>;

package/lib/functional.js.map

@@ -1 +1 @@
-{"version":3,"file":"functional.js","sourceRoot":"","sources":["../src/functional.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;AAGA,gGAA6F;AA0D7F,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,2BAA2B,CAAC,CAAC;AAC7D,CAAC;AA6BD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,6BAA6B,CAAC,CAAC;AAC/D,CAAC;AA6BD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,yBAAyB,CAAC,CAAC;AAC3D,CAAC;AAgCD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,iCAAiC,CAAC,CAAC;AACnE,CAAC;AA6BD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,mCAAmC,CAAC,CAAC;AACrE,CAAC;AA6BD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,+BAA+B,CAAC,CAAC;AACjE,CAAC;AA2BD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,uBAAuB,CAAC,CAAC;AACzD,CAAC;AAwBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,yBAAyB,CAAC,CAAC;AAC3D,CAAC;AAwBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,qBAAqB,CAAC,CAAC;AACvD,CAAC;AAwBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,2BAA2B,CAAC,CAAC;AAC7D,CAAC;AAwBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,6BAA6B,CAAC,CAAC;AAC/D,CAAC;AAwBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,yBAAyB,CAAC,CAAC;AAC3D,CAAC;AA+BD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,6BAA6B,CAAC,CAAC;AAC/D,CAAC;AAyBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,+BAA+B,CAAC,CAAC;AACjE,CAAC;AAyBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,2BAA2B,CAAC,CAAC;AAC7D,CAAC;AA4BD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,mCAAmC,CAAC,CAAC;AACrE,CAAC;AAyBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,qCAAqC,CAAC,CAAC;AACvE,CAAC;AAyBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,iCAAiC,CAAC,CAAC;AACnE,CAAC"}
+{"version":3,"file":"functional.js","sourceRoot":"","sources":["../src/functional.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;AAGA,gGAA6F;AA6D7F,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,2BAA2B,CAAC,CAAC;AAC7D,CAAC;AAgCD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,6BAA6B,CAAC,CAAC;AAC/D,CAAC;AAgCD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,yBAAyB,CAAC,CAAC;AAC3D,CAAC;AAmCD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,iCAAiC,CAAC,CAAC;AACnE,CAAC;AAgCD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,mCAAmC,CAAC,CAAC;AACrE,CAAC;AAgCD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,+BAA+B,CAAC,CAAC;AACjE,CAAC;AA6BD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,uBAAuB,CAAC,CAAC;AACzD,CAAC;AA0BD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,yBAAyB,CAAC,CAAC;AAC3D,CAAC;AA0BD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,qBAAqB,CAAC,CAAC;AACvD,CAAC;AA0BD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,2BAA2B,CAAC,CAAC;AAC7D,CAAC;AA0BD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,6BAA6B,CAAC,CAAC;AAC/D,CAAC;AA0BD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,yBAAyB,CAAC,CAAC;AAC3D,CAAC;AAiCD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,6BAA6B,CAAC,CAAC;AAC/D,CAAC;AA2BD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,+BAA+B,CAAC,CAAC;AACjE,CAAC;AA2BD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,2BAA2B,CAAC,CAAC;AAC7D,CAAC;AA8BD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,mCAAmC,CAAC,CAAC;AACrE,CAAC;AA2BD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,qCAAqC,CAAC,CAAC;AACvE,CAAC;AA2BD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,iCAAiC,CAAC,CAAC;AACnE,CAAC"}