@keetanetwork/anchor 0.0.21 → 0.0.23

package/lib/utils/asn1.js

@@ -1,1506 +1,8 @@
-import * as __typia_transform__assertGuard from "typia/lib/internal/_assertGuard.js";
-import * as __typia_transform__accessExpressionAsString from "typia/lib/internal/_accessExpressionAsString.js";
 import { lib as KeetaNetLib } from '@keetanetwork/keetanet-client';
-import { isReferenceSchema } from './asn1.generated.js';
-import { EncryptedContainer } from '../encrypted-container.js';
-import { Buffer, bufferToArrayBuffer } from './buffer.js';
-import { checkHashWithOID } from './external.js';
-const KeetaNetAccount = KeetaNetLib.Account;
-import { assert, createAssert, createIs } from 'typia';
 const ASN1 = KeetaNetLib.Utils.ASN1;
 const ASN1toJS = ASN1.ASN1toJS;
 const JStoASN1 = ASN1.JStoASN1;
 const BufferStorageASN1 = ASN1.BufferStorageASN1;
 const ValidateASN1 = ASN1.ValidateASN1;
-const ASN1CheckUtilities = ASN1.ASN1CheckUtilities;
-const { isASN1ContextTag, isASN1Struct, isASN1String, isASN1Date, isASN1BitString, isASN1Set } = ASN1CheckUtilities;
-const assertStructFieldSchemaMap = (() => { const _ip0 = input => {
-    const array = input;
-    const top = input[0];
-    if (0 === input.length)
-        return true;
-    const arrayPredicators = [
-        [
-            top => null !== top && undefined !== top && ("function" === typeof top || "bigint" === typeof top || (Array.isArray(top) && (_it0(top) || false) || "object" === typeof top && null !== top && _iu0(top))),
-            entire => entire.every(elem => null !== elem && undefined !== elem && ("function" === typeof elem || "bigint" === typeof elem || (Array.isArray(elem) && (_it0(elem) || false) || "object" === typeof elem && null !== elem && _iu0(elem))))
-        ],
-        [
-            top => null !== top && undefined !== top && ("function" === typeof top || "bigint" === typeof top || (Array.isArray(top) && (_it0(top) || false) || "object" === typeof top && null !== top && _iu0(top))),
-            entire => entire.every(elem => null !== elem && undefined !== elem && ("function" === typeof elem || "bigint" === typeof elem || (Array.isArray(elem) && (_it0(elem) || false) || "object" === typeof elem && null !== elem && _iu0(elem))))
-        ]
-    ];
-    const passed = arrayPredicators.filter(pred => pred[0](top));
-    if (1 === passed.length)
-        return passed[0][1](array);
-    else if (1 < passed.length)
-        for (const pred of passed)
-            if (array.every(value => true === pred[0](value)))
-                return pred[1](array);
-    return false;
-}; const _ap1 = (input, _path, _exceptionable = true) => {
-    const array = input;
-    const top = input[0];
-    if (0 === input.length)
-        return true;
-    const arrayPredicators = [
-        [
-            top => null !== top && undefined !== top && ("function" === typeof top || "bigint" === typeof top || (Array.isArray(top) && (_at0(top, _path, false && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "createAssert",
-                path: _path,
-                expected: "readonly [Schema, ...Schema[]]",
-                value: top
-            }, _errorFactory)) || "object" === typeof top && null !== top && _au0(top, _path, false && _exceptionable))),
-            entire => entire.every((elem, _index9) => (null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "createAssert",
-                path: _path + "[" + _index9 + "]",
-                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                value: elem
-            }, _errorFactory)) && (undefined !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "createAssert",
-                path: _path + "[" + _index9 + "]",
-                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                value: elem
-            }, _errorFactory)) && ("function" === typeof elem || "bigint" === typeof elem || (Array.isArray(elem) && (_at0(elem, _path + "[" + _index9 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "createAssert",
-                path: _path + "[" + _index9 + "]",
-                expected: "readonly [Schema, ...Schema[]]",
-                value: elem
-            }, _errorFactory)) || "object" === typeof elem && null !== elem && _au0(elem, _path + "[" + _index9 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "createAssert",
-                path: _path + "[" + _index9 + "]",
-                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                value: elem
-            }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "createAssert",
-                path: _path + "[" + _index9 + "]",
-                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                value: elem
-            }, _errorFactory)))
-        ],
-        [
-            top => null !== top && undefined !== top && ("function" === typeof top || "bigint" === typeof top || (Array.isArray(top) && (_at0(top, _path, false && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "createAssert",
-                path: _path,
-                expected: "readonly [Schema, ...Schema[]]",
-                value: top
-            }, _errorFactory)) || "object" === typeof top && null !== top && _au0(top, _path, false && _exceptionable))),
-            entire => entire.every((elem, _index10) => (null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "createAssert",
-                path: _path + "[" + _index10 + "]",
-                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                value: elem
-            }, _errorFactory)) && (undefined !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "createAssert",
-                path: _path + "[" + _index10 + "]",
-                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                value: elem
-            }, _errorFactory)) && ("function" === typeof elem || "bigint" === typeof elem || (Array.isArray(elem) && (_at0(elem, _path + "[" + _index10 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "createAssert",
-                path: _path + "[" + _index10 + "]",
-                expected: "readonly [Schema, ...Schema[]]",
-                value: elem
-            }, _errorFactory)) || "object" === typeof elem && null !== elem && _au0(elem, _path + "[" + _index10 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "createAssert",
-                path: _path + "[" + _index10 + "]",
-                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                value: elem
-            }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "createAssert",
-                path: _path + "[" + _index10 + "]",
-                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                value: elem
-            }, _errorFactory)))
-        ]
-    ];
-    const passed = arrayPredicators.filter(pred => pred[0](top));
-    if (1 === passed.length)
-        return passed[0][1](array);
-    else if (1 < passed.length)
-        for (const pred of passed)
-            if (array.every(value => true === pred[0](value)))
-                return pred[1](array);
-    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
-        method: "createAssert",
-        path: _path,
-        expected: "(Array<ValidateASN1.Schema> | ReadonlyArray<ValidateASN1.Schema>)",
-        value: input
-    }, _errorFactory);
-}; const _io0 = input => Object.keys(input).every(key => {
-    const value = input[key];
-    if (undefined === value)
-        return true;
-    return null !== value && undefined !== value && ("function" === typeof value || "bigint" === typeof value || (Array.isArray(value) && (_it0(value) || false) || "object" === typeof value && null !== value && _iu1(value)));
-}); const _io1 = input => Array.isArray(input.choice) && (_ip0(input.choice) || false); const _io2 = input => null !== input.sequenceOf && undefined !== input.sequenceOf && ("function" === typeof input.sequenceOf || "bigint" === typeof input.sequenceOf || (Array.isArray(input.sequenceOf) && (_it0(input.sequenceOf) || false) || "object" === typeof input.sequenceOf && null !== input.sequenceOf && _iu0(input.sequenceOf))); const _io3 = input => null !== input.optional && undefined !== input.optional && ("function" === typeof input.optional || "bigint" === typeof input.optional || (Array.isArray(input.optional) && (_it0(input.optional) || false) || "object" === typeof input.optional && null !== input.optional && _iu0(input.optional))); const _io4 = input => "context" === input.type && ("explicit" === input.kind || "implicit" === input.kind) && (null !== input.contains && undefined !== input.contains && ("function" === typeof input.contains || "bigint" === typeof input.contains || (Array.isArray(input.contains) && (_it0(input.contains) || false) || "object" === typeof input.contains && null !== input.contains && _iu0(input.contains)))) && "number" === typeof input.value; const _io5 = input => "oid" === input.type && "string" === typeof input.oid; const _io6 = input => "string" === input.type && "printable" === input.kind; const _io7 = input => "string" === input.type && "ia5" === input.kind; const _io8 = input => "string" === input.type && "utf8" === input.kind; const _io9 = input => "date" === input.type && "utc" === input.kind; const _io10 = input => "date" === input.type && "general" === input.kind; const _io11 = input => "struct" === input.type && (Array.isArray(input.fieldNames) && input.fieldNames.every(elem => "string" === typeof elem)) && ("object" === typeof input.contains && null !== input.contains && false === Array.isArray(input.contains) && _io12(input.contains)); const _io12 = input => Object.keys(input).every(key => {
-    const value = input[key];
-    if (undefined === value)
-        return true;
-    return null !== value && undefined !== value && ("function" === typeof value || "bigint" === typeof value || (Array.isArray(value) && (_it0(value) || false) || "object" === typeof value && null !== value && _iu0(value)));
-}); const _io13 = input => null !== input.optional && undefined !== input.optional && ("function" === typeof input.optional || "bigint" === typeof input.optional || (Array.isArray(input.optional) && (_it0(input.optional) || false) || "object" === typeof input.optional && null !== input.optional && _iu0(input.optional))); const _iu0 = input => (() => {
-    if (undefined !== input.choice)
-        return _io1(input);
-    else if (undefined !== input.sequenceOf)
-        return _io2(input);
-    else if (undefined !== input.optional)
-        return _io3(input);
-    else if ("context" === input.type)
-        return _io4(input);
-    else if ("oid" === input.type)
-        return _io5(input);
-    else if ("general" === input.kind)
-        return _io10(input);
-    else if ("utc" === input.kind)
-        return _io9(input);
-    else if ("utf8" === input.kind)
-        return _io8(input);
-    else if ("ia5" === input.kind)
-        return _io7(input);
-    else if ("printable" === input.kind)
-        return _io6(input);
-    else if ("struct" === input.type)
-        return _io11(input);
-    else
-        return false;
-})(); const _iu1 = input => (() => {
-    if (undefined !== input.choice)
-        return _io1(input);
-    else if (undefined !== input.sequenceOf)
-        return _io2(input);
-    else if ("context" === input.type)
-        return _io4(input);
-    else if ("oid" === input.type)
-        return _io5(input);
-    else if ("general" === input.kind)
-        return _io10(input);
-    else if ("utc" === input.kind)
-        return _io9(input);
-    else if ("utf8" === input.kind)
-        return _io8(input);
-    else if ("ia5" === input.kind)
-        return _io7(input);
-    else if ("printable" === input.kind)
-        return _io6(input);
-    else if ("struct" === input.type)
-        return _io11(input);
-    else
-        return (() => {
-            if (_io3(input))
-                return _io3(input);
-            if (_io13(input))
-                return _io13(input);
-            return false;
-        })();
-})(); const _it0 = input => null !== input[0] && undefined !== input[0] && ("function" === typeof input[0] || "bigint" === typeof input[0] || (Array.isArray(input[0]) && (_it0(input[0]) || false) || "object" === typeof input[0] && null !== input[0] && _iu0(input[0]))) && (Array.isArray(input.slice(1)) && input.slice(1).every(elem => null !== elem && undefined !== elem && ("function" === typeof elem || "bigint" === typeof elem || (Array.isArray(elem) && (_it0(elem) || false) || "object" === typeof elem && null !== elem && _iu0(elem))))); const _ao0 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every(key => {
-    const value = input[key];
-    if (undefined === value)
-        return true;
-    return (null !== value || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-        method: "createAssert",
-        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
-        expected: "(__type | __type.o1 | __type.o10 | __type.o12 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-        value: value
-    }, _errorFactory)) && (undefined !== value || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-        method: "createAssert",
-        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
-        expected: "(__type | __type.o1 | __type.o10 | __type.o12 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-        value: value
-    }, _errorFactory)) && ("function" === typeof value || "bigint" === typeof value || (Array.isArray(value) && (_at0(value, _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key), true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-        method: "createAssert",
-        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
-        expected: "readonly [Schema, ...Schema[]]",
-        value: value
-    }, _errorFactory)) || "object" === typeof value && null !== value && _au1(value, _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key), true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-        method: "createAssert",
-        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
-        expected: "(__type | __type.o1 | __type.o10 | __type.o12 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-        value: value
-    }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-        method: "createAssert",
-        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
-        expected: "(__type | __type.o1 | __type.o10 | __type.o12 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-        value: value
-    }, _errorFactory));
-}); const _ao1 = (input, _path, _exceptionable = true) => (Array.isArray(input.choice) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".choice",
-    expected: "(Array<ValidateASN1.Schema> | ReadonlyArray<ValidateASN1.Schema>)",
-    value: input.choice
-}, _errorFactory)) && (_ap1(input.choice, _path + ".choice", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".choice",
-    expected: "Array<ValidateASN1.Schema> | ReadonlyArray<ValidateASN1.Schema>",
-    value: input.choice
-}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".choice",
-    expected: "(Array<ValidateASN1.Schema> | ReadonlyArray<ValidateASN1.Schema>)",
-    value: input.choice
-}, _errorFactory); const _ao2 = (input, _path, _exceptionable = true) => (null !== input.sequenceOf || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".sequenceOf",
-    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-    value: input.sequenceOf
-}, _errorFactory)) && (undefined !== input.sequenceOf || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".sequenceOf",
-    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-    value: input.sequenceOf
-}, _errorFactory)) && ("function" === typeof input.sequenceOf || "bigint" === typeof input.sequenceOf || (Array.isArray(input.sequenceOf) && (_at0(input.sequenceOf, _path + ".sequenceOf", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".sequenceOf",
-    expected: "readonly [Schema, ...Schema[]]",
-    value: input.sequenceOf
-}, _errorFactory)) || "object" === typeof input.sequenceOf && null !== input.sequenceOf && _au0(input.sequenceOf, _path + ".sequenceOf", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".sequenceOf",
-    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-    value: input.sequenceOf
-}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".sequenceOf",
-    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-    value: input.sequenceOf
-}, _errorFactory)); const _ao3 = (input, _path, _exceptionable = true) => (null !== input.optional || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".optional",
-    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-    value: input.optional
-}, _errorFactory)) && (undefined !== input.optional || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".optional",
-    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-    value: input.optional
-}, _errorFactory)) && ("function" === typeof input.optional || "bigint" === typeof input.optional || (Array.isArray(input.optional) && (_at0(input.optional, _path + ".optional", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".optional",
-    expected: "readonly [Schema, ...Schema[]]",
-    value: input.optional
-}, _errorFactory)) || "object" === typeof input.optional && null !== input.optional && _au0(input.optional, _path + ".optional", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".optional",
-    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-    value: input.optional
-}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".optional",
-    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-    value: input.optional
-}, _errorFactory)); const _ao4 = (input, _path, _exceptionable = true) => ("context" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".type",
-    expected: "\"context\"",
-    value: input.type
-}, _errorFactory)) && ("explicit" === input.kind || "implicit" === input.kind || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".kind",
-    expected: "(\"explicit\" | \"implicit\")",
-    value: input.kind
-}, _errorFactory)) && ((null !== input.contains || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".contains",
-    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-    value: input.contains
-}, _errorFactory)) && (undefined !== input.contains || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".contains",
-    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-    value: input.contains
-}, _errorFactory)) && ("function" === typeof input.contains || "bigint" === typeof input.contains || (Array.isArray(input.contains) && (_at0(input.contains, _path + ".contains", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".contains",
-    expected: "readonly [Schema, ...Schema[]]",
-    value: input.contains
-}, _errorFactory)) || "object" === typeof input.contains && null !== input.contains && _au0(input.contains, _path + ".contains", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".contains",
-    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-    value: input.contains
-}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".contains",
-    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-    value: input.contains
-}, _errorFactory))) && ("number" === typeof input.value || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".value",
-    expected: "number",
-    value: input.value
-}, _errorFactory)); const _ao5 = (input, _path, _exceptionable = true) => ("oid" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".type",
-    expected: "\"oid\"",
-    value: input.type
-}, _errorFactory)) && ("string" === typeof input.oid || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".oid",
-    expected: "string",
-    value: input.oid
-}, _errorFactory)); const _ao6 = (input, _path, _exceptionable = true) => ("string" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".type",
-    expected: "\"string\"",
-    value: input.type
-}, _errorFactory)) && ("printable" === input.kind || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".kind",
-    expected: "\"printable\"",
-    value: input.kind
-}, _errorFactory)); const _ao7 = (input, _path, _exceptionable = true) => ("string" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".type",
-    expected: "\"string\"",
-    value: input.type
-}, _errorFactory)) && ("ia5" === input.kind || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".kind",
-    expected: "\"ia5\"",
-    value: input.kind
-}, _errorFactory)); const _ao8 = (input, _path, _exceptionable = true) => ("string" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".type",
-    expected: "\"string\"",
-    value: input.type
-}, _errorFactory)) && ("utf8" === input.kind || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".kind",
-    expected: "\"utf8\"",
-    value: input.kind
-}, _errorFactory)); const _ao9 = (input, _path, _exceptionable = true) => ("date" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".type",
-    expected: "\"date\"",
-    value: input.type
-}, _errorFactory)) && ("utc" === input.kind || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".kind",
-    expected: "\"utc\"",
-    value: input.kind
-}, _errorFactory)); const _ao10 = (input, _path, _exceptionable = true) => ("date" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".type",
-    expected: "\"date\"",
-    value: input.type
-}, _errorFactory)) && ("general" === input.kind || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".kind",
-    expected: "\"general\"",
-    value: input.kind
-}, _errorFactory)); const _ao11 = (input, _path, _exceptionable = true) => ("struct" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".type",
-    expected: "\"struct\"",
-    value: input.type
-}, _errorFactory)) && ((Array.isArray(input.fieldNames) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".fieldNames",
-    expected: "Array<string>",
-    value: input.fieldNames
-}, _errorFactory)) && input.fieldNames.every((elem, _index11) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".fieldNames[" + _index11 + "]",
-    expected: "string",
-    value: elem
-}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".fieldNames",
-    expected: "Array<string>",
-    value: input.fieldNames
-}, _errorFactory)) && (("object" === typeof input.contains && null !== input.contains && false === Array.isArray(input.contains) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".contains",
-    expected: "__type.o11",
-    value: input.contains
-}, _errorFactory)) && _ao12(input.contains, _path + ".contains", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".contains",
-    expected: "__type.o11",
-    value: input.contains
-}, _errorFactory)); const _ao12 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every(key => {
-    const value = input[key];
-    if (undefined === value)
-        return true;
-    return (null !== value || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-        method: "createAssert",
-        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
-        expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-        value: value
-    }, _errorFactory)) && (undefined !== value || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-        method: "createAssert",
-        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
-        expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-        value: value
-    }, _errorFactory)) && ("function" === typeof value || "bigint" === typeof value || (Array.isArray(value) && (_at0(value, _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key), true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-        method: "createAssert",
-        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
-        expected: "readonly [Schema, ...Schema[]]",
-        value: value
-    }, _errorFactory)) || "object" === typeof value && null !== value && _au0(value, _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key), true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-        method: "createAssert",
-        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
-        expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-        value: value
-    }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-        method: "createAssert",
-        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
-        expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-        value: value
-    }, _errorFactory));
-}); const _ao13 = (input, _path, _exceptionable = true) => (null !== input.optional || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".optional",
-    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-    value: input.optional
-}, _errorFactory)) && (undefined !== input.optional || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".optional",
-    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-    value: input.optional
-}, _errorFactory)) && ("function" === typeof input.optional || "bigint" === typeof input.optional || (Array.isArray(input.optional) && (_at0(input.optional, _path + ".optional", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".optional",
-    expected: "readonly [Schema, ...Schema[]]",
-    value: input.optional
-}, _errorFactory)) || "object" === typeof input.optional && null !== input.optional && _au0(input.optional, _path + ".optional", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".optional",
-    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-    value: input.optional
-}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".optional",
-    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-    value: input.optional
-}, _errorFactory)); const _au0 = (input, _path, _exceptionable = true) => (() => {
-    if (undefined !== input.choice)
-        return _ao1(input, _path, true && _exceptionable);
-    else if (undefined !== input.sequenceOf)
-        return _ao2(input, _path, true && _exceptionable);
-    else if (undefined !== input.optional)
-        return _ao3(input, _path, true && _exceptionable);
-    else if ("context" === input.type)
-        return _ao4(input, _path, true && _exceptionable);
-    else if ("oid" === input.type)
-        return _ao5(input, _path, true && _exceptionable);
-    else if ("general" === input.kind)
-        return _ao10(input, _path, true && _exceptionable);
-    else if ("utc" === input.kind)
-        return _ao9(input, _path, true && _exceptionable);
-    else if ("utf8" === input.kind)
-        return _ao8(input, _path, true && _exceptionable);
-    else if ("ia5" === input.kind)
-        return _ao7(input, _path, true && _exceptionable);
-    else if ("printable" === input.kind)
-        return _ao6(input, _path, true && _exceptionable);
-    else if ("struct" === input.type)
-        return _ao11(input, _path, true && _exceptionable);
-    else
-        return __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "createAssert",
-            path: _path,
-            expected: "(__type | __type.o1 | __type.o2 | __type.o3 | __type.o4 | __type.o9 | __type.o8 | __type.o7 | __type.o6 | __type.o5 | __type.o10)",
-            value: input
-        }, _errorFactory);
-})(); const _au1 = (input, _path, _exceptionable = true) => (() => {
-    if (undefined !== input.choice)
-        return _ao1(input, _path, true && _exceptionable);
-    else if (undefined !== input.sequenceOf)
-        return _ao2(input, _path, true && _exceptionable);
-    else if ("context" === input.type)
-        return _ao4(input, _path, true && _exceptionable);
-    else if ("oid" === input.type)
-        return _ao5(input, _path, true && _exceptionable);
-    else if ("general" === input.kind)
-        return _ao10(input, _path, true && _exceptionable);
-    else if ("utc" === input.kind)
-        return _ao9(input, _path, true && _exceptionable);
-    else if ("utf8" === input.kind)
-        return _ao8(input, _path, true && _exceptionable);
-    else if ("ia5" === input.kind)
-        return _ao7(input, _path, true && _exceptionable);
-    else if ("printable" === input.kind)
-        return _ao6(input, _path, true && _exceptionable);
-    else if ("struct" === input.type)
-        return _ao11(input, _path, true && _exceptionable);
-    else
-        return _ao3(input, _path, false && _exceptionable) || _ao13(input, _path, false && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-            method: "createAssert",
-            path: _path,
-            expected: "(__type.o2 | __type.o12)",
-            value: input
-        }, _errorFactory);
-})(); const _at0 = (input, _path, _exceptionable = true) => (null !== input[0] || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + "[0]",
-    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-    value: input[0]
-}, _errorFactory)) && (undefined !== input[0] || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + "[0]",
-    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-    value: input[0]
-}, _errorFactory)) && ("function" === typeof input[0] || "bigint" === typeof input[0] || (Array.isArray(input[0]) && (_at0(input[0], _path + "[0]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + "[0]",
-    expected: "readonly [Schema, ...Schema[]]",
-    value: input[0]
-}, _errorFactory)) || "object" === typeof input[0] && null !== input[0] && _au0(input[0], _path + "[0]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + "[0]",
-    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-    value: input[0]
-}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + "[0]",
-    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-    value: input[0]
-}, _errorFactory)) && ((Array.isArray(input.slice(1)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path,
-    expected: "...(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-    value: input.slice(1)
-}, _errorFactory)) && input.slice(1).every((elem, _index12) => (null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + "[" + (1 + _index12) + "]",
-    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-    value: elem
-}, _errorFactory)) && (undefined !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + "[" + (1 + _index12) + "]",
-    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-    value: elem
-}, _errorFactory)) && ("function" === typeof elem || "bigint" === typeof elem || (Array.isArray(elem) && (_at0(elem, _path + "[" + (1 + _index12) + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + "[" + (1 + _index12) + "]",
-    expected: "readonly [Schema, ...Schema[]]",
-    value: elem
-}, _errorFactory)) || "object" === typeof elem && null !== elem && _au0(elem, _path + "[" + (1 + _index12) + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + "[" + (1 + _index12) + "]",
-    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-    value: elem
-}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + "[" + (1 + _index12) + "]",
-    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-    value: elem
-}, _errorFactory))) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path,
-    expected: "...(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-    value: input.slice(1)
-}, _errorFactory)); const __is = input => "object" === typeof input && null !== input && false === Array.isArray(input) && _io0(input); let _errorFactory; return (input, errorFactory) => {
-    if (false === __is(input)) {
-        _errorFactory = errorFactory;
-        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input && false === Array.isArray(input) || __typia_transform__assertGuard._assertGuard(true, {
-            method: "createAssert",
-            path: _path + "",
-            expected: "StructFieldSchemaMap",
-            value: input
-        }, _errorFactory)) && _ao0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
-            method: "createAssert",
-            path: _path + "",
-            expected: "StructFieldSchemaMap",
-            value: input
-        }, _errorFactory))(input, "$input", true);
-    }
-    return input;
-}; })();
-const structSchemaGuard = (() => { const _ip0 = input => {
-    const array = input;
-    const top = input[0];
-    if (0 === input.length)
-        return true;
-    const arrayPredicators = [
-        [
-            top => null !== top && undefined !== top && ("function" === typeof top || "bigint" === typeof top || (Array.isArray(top) && (_it0(top) || false) || "object" === typeof top && null !== top && _iu0(top))),
-            entire => entire.every(elem => null !== elem && undefined !== elem && ("function" === typeof elem || "bigint" === typeof elem || (Array.isArray(elem) && (_it0(elem) || false) || "object" === typeof elem && null !== elem && _iu0(elem))))
-        ],
-        [
-            top => null !== top && undefined !== top && ("function" === typeof top || "bigint" === typeof top || (Array.isArray(top) && (_it0(top) || false) || "object" === typeof top && null !== top && _iu0(top))),
-            entire => entire.every(elem => null !== elem && undefined !== elem && ("function" === typeof elem || "bigint" === typeof elem || (Array.isArray(elem) && (_it0(elem) || false) || "object" === typeof elem && null !== elem && _iu0(elem))))
-        ]
-    ];
-    const passed = arrayPredicators.filter(pred => pred[0](top));
-    if (1 === passed.length)
-        return passed[0][1](array);
-    else if (1 < passed.length)
-        for (const pred of passed)
-            if (array.every(value => true === pred[0](value)))
-                return pred[1](array);
-    return false;
-}; const _io0 = input => "struct" === input.type && (Array.isArray(input.fieldNames) && input.fieldNames.every(elem => "string" === typeof elem)) && ("object" === typeof input.contains && null !== input.contains && false === Array.isArray(input.contains) && _io1(input.contains)); const _io1 = input => Object.keys(input).every(key => {
-    const value = input[key];
-    if (undefined === value)
-        return true;
-    return null !== value && undefined !== value && ("function" === typeof value || "bigint" === typeof value || (Array.isArray(value) && (_it0(value) || false) || "object" === typeof value && null !== value && _iu0(value)));
-}); const _io2 = input => Array.isArray(input.choice) && (_ip0(input.choice) || false); const _io3 = input => null !== input.sequenceOf && undefined !== input.sequenceOf && ("function" === typeof input.sequenceOf || "bigint" === typeof input.sequenceOf || (Array.isArray(input.sequenceOf) && (_it0(input.sequenceOf) || false) || "object" === typeof input.sequenceOf && null !== input.sequenceOf && _iu0(input.sequenceOf))); const _io4 = input => null !== input.optional && undefined !== input.optional && ("function" === typeof input.optional || "bigint" === typeof input.optional || (Array.isArray(input.optional) && (_it0(input.optional) || false) || "object" === typeof input.optional && null !== input.optional && _iu0(input.optional))); const _io5 = input => "context" === input.type && ("explicit" === input.kind || "implicit" === input.kind) && (null !== input.contains && undefined !== input.contains && ("function" === typeof input.contains || "bigint" === typeof input.contains || (Array.isArray(input.contains) && (_it0(input.contains) || false) || "object" === typeof input.contains && null !== input.contains && _iu0(input.contains)))) && "number" === typeof input.value; const _io6 = input => "oid" === input.type && "string" === typeof input.oid; const _io7 = input => "string" === input.type && "printable" === input.kind; const _io8 = input => "string" === input.type && "ia5" === input.kind; const _io9 = input => "string" === input.type && "utf8" === input.kind; const _io10 = input => "date" === input.type && "utc" === input.kind; const _io11 = input => "date" === input.type && "general" === input.kind; const _iu0 = input => (() => {
-    if (undefined !== input.choice)
-        return _io2(input);
-    else if (undefined !== input.sequenceOf)
-        return _io3(input);
-    else if (undefined !== input.optional)
-        return _io4(input);
-    else if ("context" === input.type)
-        return _io5(input);
-    else if ("oid" === input.type)
-        return _io6(input);
-    else if ("general" === input.kind)
-        return _io11(input);
-    else if ("utc" === input.kind)
-        return _io10(input);
-    else if ("utf8" === input.kind)
-        return _io9(input);
-    else if ("ia5" === input.kind)
-        return _io8(input);
-    else if ("printable" === input.kind)
-        return _io7(input);
-    else if ("struct" === input.type)
-        return _io0(input);
-    else
-        return false;
-})(); const _it0 = input => null !== input[0] && undefined !== input[0] && ("function" === typeof input[0] || "bigint" === typeof input[0] || (Array.isArray(input[0]) && (_it0(input[0]) || false) || "object" === typeof input[0] && null !== input[0] && _iu0(input[0]))) && (Array.isArray(input.slice(1)) && input.slice(1).every(elem => null !== elem && undefined !== elem && ("function" === typeof elem || "bigint" === typeof elem || (Array.isArray(elem) && (_it0(elem) || false) || "object" === typeof elem && null !== elem && _iu0(elem))))); return input => "object" === typeof input && null !== input && _io0(input); })();
-const structSchemaCache = new WeakMap();
-function defaultPrintValue(value) {
-    try {
-        return (JSON.stringify(value));
-    }
-    catch {
-        return (String(value));
-    }
-}
-function isOptionalSchema(candidate) {
-    return (typeof candidate === 'object' && candidate !== null && 'optional' in candidate);
-}
-function isStructSchema(candidate) {
-    return (structSchemaGuard(candidate));
-}
-function ensureStructContains(schema) {
-    if (!schema.contains) {
-        return ({});
-    }
-    return (assertStructFieldSchemaMap(schema.contains));
-}
-function isPlainObject(value) {
-    return (typeof value === 'object' && value !== null && !Array.isArray(value));
-}
-function getFieldNames(schema) {
-    return (Array.isArray(schema.fieldNames) && schema.fieldNames.length > 0
-        ? [...schema.fieldNames]
-        : Object.keys(ensureStructContains(schema)));
-}
-export function contextualizeStructSchema(schema) {
-    if (!isStructSchema(schema)) {
-        return (schema);
-    }
-    const cached = structSchemaCache.get(schema);
-    if (cached) {
-        return (cached);
-    }
-    const fieldNames = getFieldNames(schema);
-    const structContains = ensureStructContains(schema);
-    const contextualizedContains = {};
-    function wrapWithExplicitContext(index, innerSchema) {
-        if (typeof innerSchema === 'object' && innerSchema !== null && 'type' in innerSchema && innerSchema.type === 'context') {
-            return (innerSchema);
-        }
-        return ({
-            type: 'context',
-            kind: 'explicit',
-            value: index,
-            contains: contextualizeStructSchema(innerSchema)
-        });
-    }
-    for (const [index, fieldName] of fieldNames.entries()) {
-        const fieldSchema = structContains[fieldName];
-        if (!fieldSchema) {
-            continue;
-        }
-        if (isOptionalSchema(fieldSchema)) {
-            contextualizedContains[fieldName] = {
-                optional: wrapWithExplicitContext(index, fieldSchema.optional)
-            };
-            continue;
-        }
-        contextualizedContains[fieldName] = wrapWithExplicitContext(index, fieldSchema);
-    }
-    const contextualized = {
-        type: 'struct',
-        fieldNames,
-        contains: contextualizedContains
-    };
-    structSchemaCache.set(schema, contextualized);
-    return (contextualized);
-}
-function resolveSchema(schema) {
-    let current = schema;
-    while (typeof current === 'function') {
-        current = current();
-    }
-    return (current);
-}
-function prepareContextValue(schema, value, prepare) {
-    if (value === undefined) {
-        return (value);
-    }
-    if (isASN1ContextTag(value)) {
-        const preparedContains = prepare(schema.contains, value.contains);
-        if (preparedContains !== value.contains) {
-            return ({
-                type: 'context',
-                kind: value.kind,
-                value: value.value,
-                contains: preparedContains
-            });
-        }
-        return (value);
-    }
-    const contains = prepare(schema.contains, value);
-    return ({
-        type: 'context',
-        kind: schema.kind,
-        value: schema.value,
-        contains
-    });
-}
-function prepareStructValue(schema, value) {
-    const structContains = schema.contains ?? {};
-    const fieldNames = getFieldNames(schema);
-    if (isASN1Struct(value)) {
-        const preparedContains = {};
-        for (const [fieldName, fieldValue] of Object.entries(value.contains ?? {})) {
-            const fieldSchema = structContains[fieldName];
-            if (!fieldSchema) {
-                preparedContains[fieldName] = fieldValue;
-                continue;
-            }
-            const innerSchema = isOptionalSchema(fieldSchema) ? fieldSchema.optional : fieldSchema;
-            // eslint-disable-next-line @typescript-eslint/no-use-before-define
-            preparedContains[fieldName] = prepareValueForSchema(innerSchema, fieldValue);
-        }
-        return ({
-            type: 'struct',
-            fieldNames: value.fieldNames ?? fieldNames,
-            contains: preparedContains
-        });
-    }
-    if (!isPlainObject(value)) {
-        return (value);
-    }
-    const preparedContains = {};
-    for (const fieldName of fieldNames) {
-        const fieldSchema = structContains[fieldName];
-        if (!fieldSchema) {
-            continue;
-        }
-        const fieldValue = value[fieldName];
-        if (fieldValue === undefined) {
-            if (!isOptionalSchema(fieldSchema)) {
-                preparedContains[fieldName] = fieldValue;
-            }
-            continue;
-        }
-        const innerSchema = isOptionalSchema(fieldSchema) ? fieldSchema.optional : fieldSchema;
-        // eslint-disable-next-line @typescript-eslint/no-use-before-define
-        preparedContains[fieldName] = prepareValueForSchema(innerSchema, fieldValue);
-    }
-    return ({
-        type: 'struct',
-        fieldNames,
-        contains: preparedContains
-    });
-}
-function prepareValueForSchema(schema, value) {
-    const resolved = resolveSchema(schema);
-    if (value === undefined || value === null) {
-        return (value);
-    }
-    if (Array.isArray(resolved)) {
-        if (!Array.isArray(value)) {
-            return (value);
-        }
-        const result = [];
-        for (let i = 0; i < resolved.length; i++) {
-            result.push(prepareValueForSchema((() => { const _ip0 = input => {
-                const array = input;
-                const top = input[0];
-                if (0 === input.length)
-                    return true;
-                const arrayPredicators = [
-                    [
-                        top => null !== top && undefined !== top && ("function" === typeof top || "bigint" === typeof top || (Array.isArray(top) && (_it0(top) || false) || "object" === typeof top && null !== top && _iu0(top))),
-                        entire => entire.every(elem => null !== elem && undefined !== elem && ("function" === typeof elem || "bigint" === typeof elem || (Array.isArray(elem) && (_it0(elem) || false) || "object" === typeof elem && null !== elem && _iu0(elem))))
-                    ],
-                    [
-                        top => null !== top && undefined !== top && ("function" === typeof top || "bigint" === typeof top || (Array.isArray(top) && (_it0(top) || false) || "object" === typeof top && null !== top && _iu0(top))),
-                        entire => entire.every(elem => null !== elem && undefined !== elem && ("function" === typeof elem || "bigint" === typeof elem || (Array.isArray(elem) && (_it0(elem) || false) || "object" === typeof elem && null !== elem && _iu0(elem))))
-                    ]
-                ];
-                const passed = arrayPredicators.filter(pred => pred[0](top));
-                if (1 === passed.length)
-                    return passed[0][1](array);
-                else if (1 < passed.length)
-                    for (const pred of passed)
-                        if (array.every(value => true === pred[0](value)))
-                            return pred[1](array);
-                return false;
-            }; const _ap1 = (input, _path, _exceptionable = true) => {
-                const array = input;
-                const top = input[0];
-                if (0 === input.length)
-                    return true;
-                const arrayPredicators = [
-                    [
-                        top => null !== top && undefined !== top && ("function" === typeof top || "bigint" === typeof top || (Array.isArray(top) && (_at0(top, _path, false && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                            method: "assert",
-                            path: _path,
-                            expected: "readonly [Schema, ...Schema[]]",
-                            value: top
-                        }, _errorFactory)) || "object" === typeof top && null !== top && _au0(top, _path, false && _exceptionable))),
-                        entire => entire.every((elem, _index9) => (null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                            method: "assert",
-                            path: _path + "[" + _index9 + "]",
-                            expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                            value: elem
-                        }, _errorFactory)) && (undefined !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                            method: "assert",
-                            path: _path + "[" + _index9 + "]",
-                            expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                            value: elem
-                        }, _errorFactory)) && ("function" === typeof elem || "bigint" === typeof elem || (Array.isArray(elem) && (_at0(elem, _path + "[" + _index9 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                            method: "assert",
-                            path: _path + "[" + _index9 + "]",
-                            expected: "readonly [Schema, ...Schema[]]",
-                            value: elem
-                        }, _errorFactory)) || "object" === typeof elem && null !== elem && _au0(elem, _path + "[" + _index9 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                            method: "assert",
-                            path: _path + "[" + _index9 + "]",
-                            expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                            value: elem
-                        }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                            method: "assert",
-                            path: _path + "[" + _index9 + "]",
-                            expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                            value: elem
-                        }, _errorFactory)))
-                    ],
-                    [
-                        top => null !== top && undefined !== top && ("function" === typeof top || "bigint" === typeof top || (Array.isArray(top) && (_at0(top, _path, false && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                            method: "assert",
-                            path: _path,
-                            expected: "readonly [Schema, ...Schema[]]",
-                            value: top
-                        }, _errorFactory)) || "object" === typeof top && null !== top && _au0(top, _path, false && _exceptionable))),
-                        entire => entire.every((elem, _index10) => (null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                            method: "assert",
-                            path: _path + "[" + _index10 + "]",
-                            expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                            value: elem
-                        }, _errorFactory)) && (undefined !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                            method: "assert",
-                            path: _path + "[" + _index10 + "]",
-                            expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                            value: elem
-                        }, _errorFactory)) && ("function" === typeof elem || "bigint" === typeof elem || (Array.isArray(elem) && (_at0(elem, _path + "[" + _index10 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                            method: "assert",
-                            path: _path + "[" + _index10 + "]",
-                            expected: "readonly [Schema, ...Schema[]]",
-                            value: elem
-                        }, _errorFactory)) || "object" === typeof elem && null !== elem && _au0(elem, _path + "[" + _index10 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                            method: "assert",
-                            path: _path + "[" + _index10 + "]",
-                            expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                            value: elem
-                        }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                            method: "assert",
-                            path: _path + "[" + _index10 + "]",
-                            expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                            value: elem
-                        }, _errorFactory)))
-                    ]
-                ];
-                const passed = arrayPredicators.filter(pred => pred[0](top));
-                if (1 === passed.length)
-                    return passed[0][1](array);
-                else if (1 < passed.length)
-                    for (const pred of passed)
-                        if (array.every(value => true === pred[0](value)))
-                            return pred[1](array);
-                return __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                    method: "assert",
-                    path: _path,
-                    expected: "(Array<ValidateASN1.Schema> | ReadonlyArray<ValidateASN1.Schema>)",
-                    value: input
-                }, _errorFactory);
-            }; const _io0 = input => Array.isArray(input.choice) && (_ip0(input.choice) || false); const _io1 = input => null !== input.sequenceOf && undefined !== input.sequenceOf && ("function" === typeof input.sequenceOf || "bigint" === typeof input.sequenceOf || (Array.isArray(input.sequenceOf) && (_it0(input.sequenceOf) || false) || "object" === typeof input.sequenceOf && null !== input.sequenceOf && _iu0(input.sequenceOf))); const _io2 = input => null !== input.optional && undefined !== input.optional && ("function" === typeof input.optional || "bigint" === typeof input.optional || (Array.isArray(input.optional) && (_it0(input.optional) || false) || "object" === typeof input.optional && null !== input.optional && _iu0(input.optional))); const _io3 = input => "context" === input.type && ("explicit" === input.kind || "implicit" === input.kind) && (null !== input.contains && undefined !== input.contains && ("function" === typeof input.contains || "bigint" === typeof input.contains || (Array.isArray(input.contains) && (_it0(input.contains) || false) || "object" === typeof input.contains && null !== input.contains && _iu0(input.contains)))) && "number" === typeof input.value; const _io4 = input => "oid" === input.type && "string" === typeof input.oid; const _io5 = input => "string" === input.type && "printable" === input.kind; const _io6 = input => "string" === input.type && "ia5" === input.kind; const _io7 = input => "string" === input.type && "utf8" === input.kind; const _io8 = input => "date" === input.type && "utc" === input.kind; const _io9 = input => "date" === input.type && "general" === input.kind; const _io10 = input => "struct" === input.type && (Array.isArray(input.fieldNames) && input.fieldNames.every(elem => "string" === typeof elem)) && ("object" === typeof input.contains && null !== input.contains && false === Array.isArray(input.contains) && _io11(input.contains)); const _io11 = input => Object.keys(input).every(key => {
-                const value = input[key];
-                if (undefined === value)
-                    return true;
-                return null !== value && undefined !== value && ("function" === typeof value || "bigint" === typeof value || (Array.isArray(value) && (_it0(value) || false) || "object" === typeof value && null !== value && _iu0(value)));
-            }); const _iu0 = input => (() => {
-                if (undefined !== input.choice)
-                    return _io0(input);
-                else if (undefined !== input.sequenceOf)
-                    return _io1(input);
-                else if (undefined !== input.optional)
-                    return _io2(input);
-                else if ("context" === input.type)
-                    return _io3(input);
-                else if ("oid" === input.type)
-                    return _io4(input);
-                else if ("general" === input.kind)
-                    return _io9(input);
-                else if ("utc" === input.kind)
-                    return _io8(input);
-                else if ("utf8" === input.kind)
-                    return _io7(input);
-                else if ("ia5" === input.kind)
-                    return _io6(input);
-                else if ("printable" === input.kind)
-                    return _io5(input);
-                else if ("struct" === input.type)
-                    return _io10(input);
-                else
-                    return false;
-            })(); const _it0 = input => null !== input[0] && undefined !== input[0] && ("function" === typeof input[0] || "bigint" === typeof input[0] || (Array.isArray(input[0]) && (_it0(input[0]) || false) || "object" === typeof input[0] && null !== input[0] && _iu0(input[0]))) && (Array.isArray(input.slice(1)) && input.slice(1).every(elem => null !== elem && undefined !== elem && ("function" === typeof elem || "bigint" === typeof elem || (Array.isArray(elem) && (_it0(elem) || false) || "object" === typeof elem && null !== elem && _iu0(elem))))); const _ao0 = (input, _path, _exceptionable = true) => (Array.isArray(input.choice) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".choice",
-                expected: "(Array<ValidateASN1.Schema> | ReadonlyArray<ValidateASN1.Schema>)",
-                value: input.choice
-            }, _errorFactory)) && (_ap1(input.choice, _path + ".choice", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".choice",
-                expected: "Array<ValidateASN1.Schema> | ReadonlyArray<ValidateASN1.Schema>",
-                value: input.choice
-            }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".choice",
-                expected: "(Array<ValidateASN1.Schema> | ReadonlyArray<ValidateASN1.Schema>)",
-                value: input.choice
-            }, _errorFactory); const _ao1 = (input, _path, _exceptionable = true) => (null !== input.sequenceOf || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".sequenceOf",
-                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                value: input.sequenceOf
-            }, _errorFactory)) && (undefined !== input.sequenceOf || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".sequenceOf",
-                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                value: input.sequenceOf
-            }, _errorFactory)) && ("function" === typeof input.sequenceOf || "bigint" === typeof input.sequenceOf || (Array.isArray(input.sequenceOf) && (_at0(input.sequenceOf, _path + ".sequenceOf", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".sequenceOf",
-                expected: "readonly [Schema, ...Schema[]]",
-                value: input.sequenceOf
-            }, _errorFactory)) || "object" === typeof input.sequenceOf && null !== input.sequenceOf && _au0(input.sequenceOf, _path + ".sequenceOf", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".sequenceOf",
-                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                value: input.sequenceOf
-            }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".sequenceOf",
-                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                value: input.sequenceOf
-            }, _errorFactory)); const _ao2 = (input, _path, _exceptionable = true) => (null !== input.optional || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".optional",
-                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                value: input.optional
-            }, _errorFactory)) && (undefined !== input.optional || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".optional",
-                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                value: input.optional
-            }, _errorFactory)) && ("function" === typeof input.optional || "bigint" === typeof input.optional || (Array.isArray(input.optional) && (_at0(input.optional, _path + ".optional", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".optional",
-                expected: "readonly [Schema, ...Schema[]]",
-                value: input.optional
-            }, _errorFactory)) || "object" === typeof input.optional && null !== input.optional && _au0(input.optional, _path + ".optional", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".optional",
-                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                value: input.optional
-            }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".optional",
-                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                value: input.optional
-            }, _errorFactory)); const _ao3 = (input, _path, _exceptionable = true) => ("context" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".type",
-                expected: "\"context\"",
-                value: input.type
-            }, _errorFactory)) && ("explicit" === input.kind || "implicit" === input.kind || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".kind",
-                expected: "(\"explicit\" | \"implicit\")",
-                value: input.kind
-            }, _errorFactory)) && ((null !== input.contains || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".contains",
-                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                value: input.contains
-            }, _errorFactory)) && (undefined !== input.contains || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".contains",
-                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                value: input.contains
-            }, _errorFactory)) && ("function" === typeof input.contains || "bigint" === typeof input.contains || (Array.isArray(input.contains) && (_at0(input.contains, _path + ".contains", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".contains",
-                expected: "readonly [Schema, ...Schema[]]",
-                value: input.contains
-            }, _errorFactory)) || "object" === typeof input.contains && null !== input.contains && _au0(input.contains, _path + ".contains", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".contains",
-                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                value: input.contains
-            }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".contains",
-                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                value: input.contains
-            }, _errorFactory))) && ("number" === typeof input.value || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".value",
-                expected: "number",
-                value: input.value
-            }, _errorFactory)); const _ao4 = (input, _path, _exceptionable = true) => ("oid" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".type",
-                expected: "\"oid\"",
-                value: input.type
-            }, _errorFactory)) && ("string" === typeof input.oid || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".oid",
-                expected: "string",
-                value: input.oid
-            }, _errorFactory)); const _ao5 = (input, _path, _exceptionable = true) => ("string" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".type",
-                expected: "\"string\"",
-                value: input.type
-            }, _errorFactory)) && ("printable" === input.kind || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".kind",
-                expected: "\"printable\"",
-                value: input.kind
-            }, _errorFactory)); const _ao6 = (input, _path, _exceptionable = true) => ("string" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".type",
-                expected: "\"string\"",
-                value: input.type
-            }, _errorFactory)) && ("ia5" === input.kind || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".kind",
-                expected: "\"ia5\"",
-                value: input.kind
-            }, _errorFactory)); const _ao7 = (input, _path, _exceptionable = true) => ("string" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".type",
-                expected: "\"string\"",
-                value: input.type
-            }, _errorFactory)) && ("utf8" === input.kind || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".kind",
-                expected: "\"utf8\"",
-                value: input.kind
-            }, _errorFactory)); const _ao8 = (input, _path, _exceptionable = true) => ("date" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".type",
-                expected: "\"date\"",
-                value: input.type
-            }, _errorFactory)) && ("utc" === input.kind || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".kind",
-                expected: "\"utc\"",
-                value: input.kind
-            }, _errorFactory)); const _ao9 = (input, _path, _exceptionable = true) => ("date" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".type",
-                expected: "\"date\"",
-                value: input.type
-            }, _errorFactory)) && ("general" === input.kind || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".kind",
-                expected: "\"general\"",
-                value: input.kind
-            }, _errorFactory)); const _ao10 = (input, _path, _exceptionable = true) => ("struct" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".type",
-                expected: "\"struct\"",
-                value: input.type
-            }, _errorFactory)) && ((Array.isArray(input.fieldNames) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".fieldNames",
-                expected: "Array<string>",
-                value: input.fieldNames
-            }, _errorFactory)) && input.fieldNames.every((elem, _index11) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".fieldNames[" + _index11 + "]",
-                expected: "string",
-                value: elem
-            }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".fieldNames",
-                expected: "Array<string>",
-                value: input.fieldNames
-            }, _errorFactory)) && (("object" === typeof input.contains && null !== input.contains && false === Array.isArray(input.contains) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".contains",
-                expected: "__type.o11",
-                value: input.contains
-            }, _errorFactory)) && _ao11(input.contains, _path + ".contains", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + ".contains",
-                expected: "__type.o11",
-                value: input.contains
-            }, _errorFactory)); const _ao11 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every(key => {
-                const value = input[key];
-                if (undefined === value)
-                    return true;
-                return (null !== value || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                    method: "assert",
-                    path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
-                    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                    value: value
-                }, _errorFactory)) && (undefined !== value || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                    method: "assert",
-                    path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
-                    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                    value: value
-                }, _errorFactory)) && ("function" === typeof value || "bigint" === typeof value || (Array.isArray(value) && (_at0(value, _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key), true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                    method: "assert",
-                    path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
-                    expected: "readonly [Schema, ...Schema[]]",
-                    value: value
-                }, _errorFactory)) || "object" === typeof value && null !== value && _au0(value, _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key), true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                    method: "assert",
-                    path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
-                    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                    value: value
-                }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                    method: "assert",
-                    path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
-                    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                    value: value
-                }, _errorFactory));
-            }); const _au0 = (input, _path, _exceptionable = true) => (() => {
-                if (undefined !== input.choice)
-                    return _ao0(input, _path, true && _exceptionable);
-                else if (undefined !== input.sequenceOf)
-                    return _ao1(input, _path, true && _exceptionable);
-                else if (undefined !== input.optional)
-                    return _ao2(input, _path, true && _exceptionable);
-                else if ("context" === input.type)
-                    return _ao3(input, _path, true && _exceptionable);
-                else if ("oid" === input.type)
-                    return _ao4(input, _path, true && _exceptionable);
-                else if ("general" === input.kind)
-                    return _ao9(input, _path, true && _exceptionable);
-                else if ("utc" === input.kind)
-                    return _ao8(input, _path, true && _exceptionable);
-                else if ("utf8" === input.kind)
-                    return _ao7(input, _path, true && _exceptionable);
-                else if ("ia5" === input.kind)
-                    return _ao6(input, _path, true && _exceptionable);
-                else if ("printable" === input.kind)
-                    return _ao5(input, _path, true && _exceptionable);
-                else if ("struct" === input.type)
-                    return _ao10(input, _path, true && _exceptionable);
-                else
-                    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                        method: "assert",
-                        path: _path,
-                        expected: "(__type | __type.o1 | __type.o2 | __type.o3 | __type.o4 | __type.o9 | __type.o8 | __type.o7 | __type.o6 | __type.o5 | __type.o10)",
-                        value: input
-                    }, _errorFactory);
-            })(); const _at0 = (input, _path, _exceptionable = true) => (null !== input[0] || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + "[0]",
-                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                value: input[0]
-            }, _errorFactory)) && (undefined !== input[0] || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + "[0]",
-                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                value: input[0]
-            }, _errorFactory)) && ("function" === typeof input[0] || "bigint" === typeof input[0] || (Array.isArray(input[0]) && (_at0(input[0], _path + "[0]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + "[0]",
-                expected: "readonly [Schema, ...Schema[]]",
-                value: input[0]
-            }, _errorFactory)) || "object" === typeof input[0] && null !== input[0] && _au0(input[0], _path + "[0]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + "[0]",
-                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                value: input[0]
-            }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + "[0]",
-                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                value: input[0]
-            }, _errorFactory)) && ((Array.isArray(input.slice(1)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path,
-                expected: "...(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                value: input.slice(1)
-            }, _errorFactory)) && input.slice(1).every((elem, _index12) => (null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + "[" + (1 + _index12) + "]",
-                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                value: elem
-            }, _errorFactory)) && (undefined !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + "[" + (1 + _index12) + "]",
-                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                value: elem
-            }, _errorFactory)) && ("function" === typeof elem || "bigint" === typeof elem || (Array.isArray(elem) && (_at0(elem, _path + "[" + (1 + _index12) + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + "[" + (1 + _index12) + "]",
-                expected: "readonly [Schema, ...Schema[]]",
-                value: elem
-            }, _errorFactory)) || "object" === typeof elem && null !== elem && _au0(elem, _path + "[" + (1 + _index12) + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + "[" + (1 + _index12) + "]",
-                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                value: elem
-            }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path + "[" + (1 + _index12) + "]",
-                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                value: elem
-            }, _errorFactory))) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "assert",
-                path: _path,
-                expected: "...(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                value: input.slice(1)
-            }, _errorFactory)); const __is = input => null !== input && undefined !== input && ("function" === typeof input || "bigint" === typeof input || (Array.isArray(input) && (_it0(input) || false) || "object" === typeof input && null !== input && _iu0(input))); let _errorFactory; return (input, errorFactory) => {
-                if (false === __is(input)) {
-                    _errorFactory = errorFactory;
-                    ((input, _path, _exceptionable = true) => (null !== input || __typia_transform__assertGuard._assertGuard(true, {
-                        method: "assert",
-                        path: _path + "",
-                        expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                        value: input
-                    }, _errorFactory)) && (undefined !== input || __typia_transform__assertGuard._assertGuard(true, {
-                        method: "assert",
-                        path: _path + "",
-                        expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                        value: input
-                    }, _errorFactory)) && ("function" === typeof input || "bigint" === typeof input || (Array.isArray(input) && (_at0(input, _path + "", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                        method: "assert",
-                        path: _path + "",
-                        expected: "readonly [Schema, ...Schema[]]",
-                        value: input
-                    }, _errorFactory)) || "object" === typeof input && null !== input && _au0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
-                        method: "assert",
-                        path: _path + "",
-                        expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                        value: input
-                    }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(true, {
-                        method: "assert",
-                        path: _path + "",
-                        expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
-                        value: input
-                    }, _errorFactory)))(input, "$input", true);
-                }
-                return input;
-            }; })()(resolved[i]), value[i]));
-        }
-        return (result);
-    }
-    if (typeof resolved === 'object' && resolved !== null) {
-        if ('optional' in resolved) {
-            if (value === undefined) {
-                return (undefined);
-            }
-            return (prepareValueForSchema(resolved.optional, value));
-        }
-        if ('sequenceOf' in resolved) {
-            if (!Array.isArray(value)) {
-                return (value);
-            }
-            return (value.map(item => prepareValueForSchema(resolved.sequenceOf, item)));
-        }
-        if ('choice' in resolved) {
-            const choices = Array.isArray(resolved.choice)
-                ? resolved.choice
-                : Array.from(resolved.choice);
-            for (const choiceSchema of choices) {
-                const preparedChoice = prepareValueForSchema(choiceSchema, value);
-                if (preparedChoice !== value) {
-                    return (preparedChoice);
-                }
-            }
-            return (value);
-        }
-        if ('type' in resolved) {
-            switch (resolved.type) {
-                case 'context':
-                    return (prepareContextValue(resolved, value, prepareValueForSchema));
-                case 'struct':
-                    return (prepareStructValue(resolved, value));
-                default:
-                    return (value);
-            }
-        }
-    }
-    return (value);
-}
-export function encodeValueBySchema(schema, value, options) {
-    const contextualized = contextualizeStructSchema(schema);
-    try {
-        const preparedUnknown = prepareValueForSchema(contextualized, value);
-        // XXX:TODO Fix depth issue
-        // @ts-ignore
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/consistent-type-assertions
-        return (ValidateASN1.againstSchema(preparedUnknown, contextualized));
-    }
-    catch (err) {
-        const printer = options?.valuePrinter ?? defaultPrintValue;
-        const prefix = options?.attributeName ? `Attribute ${options.attributeName}: ` : '';
-        const message = err instanceof Error ? err.message : String(err);
-        throw (new Error(`${prefix}${message} (value: ${printer(value)})`));
-    }
-}
-export function normalizeDecodedASN1(input, principals) {
-    if (input === undefined || input === null) {
-        return (input);
-    }
-    if (Array.isArray(input)) {
-        return (input.map(function (childInput) {
-            return (normalizeDecodedASN1(childInput, principals));
-        }));
-    }
-    if (input instanceof Date) {
-        return (input);
-    }
-    if (Buffer.isBuffer(input) || input instanceof ArrayBuffer) {
-        return (input);
-    }
-    if (isASN1ContextTag(input)) {
-        return (normalizeDecodedASN1(input.contains, principals));
-    }
-    if (isASN1String(input)) {
-        return (normalizeDecodedASN1(input.value, principals));
-    }
-    if (isASN1Date(input)) {
-        return (input.date);
-    }
-    if (isASN1BitString(input)) {
-        return (input.value);
-    }
-    if (isASN1Struct(input)) {
-        const contains = input.contains ?? {};
-        const orderedNames = Array.isArray(input.fieldNames) && input.fieldNames.length > 0
-            ? input.fieldNames
-            : Object.keys(contains);
-        const result = {};
-        for (const fieldName of orderedNames) {
-            if (!Object.prototype.hasOwnProperty.call(contains, fieldName)) {
-                continue;
-            }
-            const fieldValue = contains[fieldName];
-            if (fieldValue !== undefined) {
-                result[fieldName] = normalizeDecodedASN1(fieldValue, principals);
-            }
-        }
-        if (isReferenceSchema(input)) {
-            const url = input.contains.external.contains.url.value;
-            const mimeType = input.contains.external.contains.contentType.value;
-            const encryptionAlgoOID = input.contains.encryptionAlgorithm?.oid;
-            const digestInfo = input.contains.digest.contains;
-            let cachedValue = null;
-            result['$blob'] = async function (additionalPrincipals) {
-                /*
-                 * If we already have the cached value, return it
-                 */
-                if (cachedValue) {
-                    return (cachedValue);
-                }
-                /*
-                 * Fetch the remote data
-                 */
-                const result = await fetch(url);
-                if (!result.ok) {
-                    throw (new Error(`Failed to fetch remote data from ${url}: ${result.status} ${result.statusText}`));
-                }
-                const dataBlob = await result.blob();
-                let data = await dataBlob.arrayBuffer();
-                /*
-                 * Sometimes people like to encode the data
-                 * in a JSON base64 string, check to see if
-                 * that's the case -- hopefully this doesn't
-                 * conflict with any legitimate use case
-                 */
-                if (dataBlob.type === 'application/json') {
-                    try {
-                        const asJSON = JSON.parse(Buffer.from(data).toString('utf-8'));
-                        if (isPlainObject(asJSON)) {
-                            if (Object.keys(asJSON).length === 2) {
-                                if ('data' in asJSON && typeof asJSON.data === 'string' && 'mimeType' in asJSON && typeof asJSON.mimeType === 'string') {
-                                    data = bufferToArrayBuffer(Buffer.from(asJSON.data, 'base64'));
-                                }
-                            }
-                        }
-                    }
-                    catch {
-                        /* Ignored */
-                    }
-                }
-                /*
-                 * Decrypt the data, if encrypted
-                 */
-                if (encryptionAlgoOID) {
-                    switch (encryptionAlgoOID) {
-                        case '1.3.6.1.4.1.62675.2':
-                        case 'KeetaEncryptedContainerV1': {
-                            const container = EncryptedContainer.fromEncryptedBuffer(data, [
-                                ...principals,
-                                ...(additionalPrincipals ?? [])
-                            ]);
-                            data = await container.getPlaintext();
-                            break;
-                        }
-                        default:
-                            throw (new Error(`Unsupported encryption algorithm OID: ${encryptionAlgoOID}`));
-                    }
-                }
-                /*
-                 * Compute and verify the hash (of the plain text)
-                 */
-                if (!Buffer.isBuffer(digestInfo.digest)) {
-                    throw (new TypeError('Digest value is not a buffer'));
-                }
-                const validHash = await checkHashWithOID(data, {
-                    digest: digestInfo.digest,
-                    digestAlgorithm: digestInfo.digestAlgorithm
-                });
-                if (validHash !== true) {
-                    throw (validHash);
-                }
-                const blob = new Blob([data], { type: mimeType });
-                cachedValue = blob;
-                return (blob);
-            };
-        }
-        return (result);
-    }
-    if (isASN1Set(input)) {
-        return ({
-            name: normalizeDecodedASN1(input.name, principals),
-            value: normalizeDecodedASN1(input.value, principals)
-        });
-    }
-    if (isPlainObject(input)) {
-        const result = {};
-        for (const [key, value] of Object.entries(input)) {
-            result[key] = normalizeDecodedASN1(value, principals);
-        }
-        return (result);
-    }
-    return (input);
-}
 export { ASN1toJS, JStoASN1, BufferStorageASN1, ValidateASN1 };
 //# sourceMappingURL=asn1.js.map