@mionjs/run-types 0.8.8 → 0.13.0

package/.dist/esm/index.js

@@ -1,209 +0,0 @@
-import { __ΩAnyClass, __ΩAnyFunction, __ΩAnyParameterListRunType, __ΩCustomVλl, __ΩDKAnnotation, __ΩDeepPartial, __ΩDeepRequired, __ΩFormatAnnotation, __ΩJitCode, __ΩJitCompilerOpts, __ΩJitFn, __ΩJitFnID, __ΩMockOperation, __ΩMockOptions, __ΩMutable, __ΩPartialRunTypeOptions, __ΩRunType, __ΩRunTypeAnnotation, __ΩRunTypeChildAccessor, __ΩRunTypeFamily, __ΩRunTypeOptions, __ΩRunTypeVisitor, __ΩSrcCollection, __ΩSrcMember, __ΩSrcType, __ΩStrNumber, __ΩSubKind } from "./src/types.js";
-import { CodeTypes, JitFunctions, __ΩCodeType, __ΩJitFnSettings, jitArgs, jitArgsWithOptions, jitBinaryDeserializerArgs, jitBinarySerializerArgs, jitDefaultArgs, jitDefaultArgsWithOptions, jitDefaultBinaryDeserializerArgs, jitDefaultBinarySerializerArgs, jitDefaultErrorArgs, jitErrorArgs, jitFunctionList, jitFunctionsById, jitSerializationFunctions, jitValidationFunctions } from "./src/constants.functions.js";
-import { ReflectionKindName, ReflectionSubKind, ReflectionSubNames, __ΩAnyKindName, getReflectionName } from "./src/constants.kind.js";
-import { JIT_STACK_TRACE_MESSAGE, MAX_UNION_ITEMS, maxStackErrorMessage, nativeUtilityStringTypes, nonSerializableClasses, nonSerializableGlobals, validPropertyNameRegExp } from "./src/constants.js";
-import { reflectFunction, runType } from "./src/createRunType.js";
-import { createFromBinaryFn, createIsTypeFn, createMockTypeFn, createPrepareForJsonFn, createRestoreFromJsonFn, createStringifyJsonFn, createToBinaryFn, createToJavascriptFn, createTypeErrorsFn } from "./src/createRunTypeFunctions.js";
-import { __ΩTypeFormat } from "./src/formats.runtype.js";
-import { computeDeepkitFormatID, createTypeId } from "./src/lib/typeId.js";
-import { getParsedAnnotationOptions, getRunTypeAnnotations, getTypeToObject } from "./src/lib/dkProxy.js";
-import { BaseRunTypeFormat } from "./src/lib/baseRunTypeFormat.js";
-import { AtomicRunType, BaseRunType, CollectionRunType, MemberRunType } from "./src/lib/baseRunTypes.js";
-import { defaultIgnoreFormatProps, dependenciesToLiteral, getFormatAnnotation, getFormatterFromCache, getFormatterKey, getFormatterParams, getRunTypeFormat, getRunTypeTransformer, getToLiteralFn, initFormatAnnotations, paramsToLiteral, registerFormatter } from "./src/lib/formats.js";
-import { hasArguments, hasExtends, hasExtendsArguments, hasImplements, hasIndexType, hasMembers, hasParameters, hasReturn, hasType, hasTypeArguments, hasTypeParameters, hasTypes, isAnyFunctionRunType, isAnyRunType, isArrayRunType, isAtomicRunType, isBigIntRunType, isBooleanRunType, isCallSignatureRunType, isChildAccessorType, isClassRunType, isCollectionRunType, isConstructor, isDateRunType, isEnumMemberRunType, isEnumRunType, isFormatParamMeta, isFunctionParamsRunType, isFunctionRunType, isIndexSignatureRunType, isInterfaceRunType, isIntersectionRunType, isJitErrorsCompiler, isLiteralRunType, isMemberRunType, isMethodSignatureRunType, isNativeUtilityStringTypes, isNeverRunType, isNonSerializableClass, isNonSerializableObject, isNullRunType, isNumberRunType, isObjectLiteralRunType, isObjectRunType, isParameterRunType, isPromiseRunType, isPropertyRunType, isPropertySignatureRunType, isRegexpRunType, isRunType, isStringRunType, isSymbolRunType, isTupleMemberRunType, isTupleRunType, isUndefinedRunType, isUnionRunType, isUnknownRunType, isVoidRunType } from "./src/lib/guards.js";
-import { BaseFnCompiler, JitErrorsFnCompiler, JitFnCompiler, MockJitCompiler, createJitCompiler, printClosure } from "./src/lib/jitFnCompiler.js";
-import { getJITFnName, getJitFnSettings, getJitFunctionCompiler, registerJitFunctionCompiler } from "./src/lib/jitFnsRegistry.js";
-import { anyValuesList, defaultMockOptions, emailLocalPartSymbols, mockObjectList, mockRegExpsList, stringCharSet } from "./src/mocking/constants.mock.js";
-import { getMockCompiler, setMockCompiler } from "./src/mocking/mockRegistry.js";
-import { mockType } from "./src/mocking/mockType.js";
-import { mockAny, mockBigInt, mockBoolean, mockDate, mockNumber, mockRecursiveEmptyArray, mockRegExp, mockString, mockSymbol, random, randomItem } from "./src/mocking/mockUtils.js";
-import { cpf_asJSONString, cpf_formatErr, cpf_getUnknownKeysFromArray, cpf_hasUnknownKeysFromArray, cpf_newRunTypeErr, cpf_safeIterableKey, cpf_sanitizeCompiledFn } from "./src/run-types-pure-fns.js";
-export {
-  AtomicRunType,
-  BaseFnCompiler,
-  BaseRunType,
-  BaseRunTypeFormat,
-  CodeTypes,
-  CollectionRunType,
-  JIT_STACK_TRACE_MESSAGE,
-  JitErrorsFnCompiler,
-  JitFnCompiler,
-  JitFunctions,
-  MAX_UNION_ITEMS,
-  MemberRunType,
-  MockJitCompiler,
-  ReflectionKindName,
-  ReflectionSubKind,
-  ReflectionSubNames,
-  __ΩAnyClass,
-  __ΩAnyFunction,
-  __ΩAnyKindName,
-  __ΩAnyParameterListRunType,
-  __ΩCodeType,
-  __ΩCustomVλl,
-  __ΩDKAnnotation,
-  __ΩDeepPartial,
-  __ΩDeepRequired,
-  __ΩFormatAnnotation,
-  __ΩJitCode,
-  __ΩJitCompilerOpts,
-  __ΩJitFn,
-  __ΩJitFnID,
-  __ΩJitFnSettings,
-  __ΩMockOperation,
-  __ΩMockOptions,
-  __ΩMutable,
-  __ΩPartialRunTypeOptions,
-  __ΩRunType,
-  __ΩRunTypeAnnotation,
-  __ΩRunTypeChildAccessor,
-  __ΩRunTypeFamily,
-  __ΩRunTypeOptions,
-  __ΩRunTypeVisitor,
-  __ΩSrcCollection,
-  __ΩSrcMember,
-  __ΩSrcType,
-  __ΩStrNumber,
-  __ΩSubKind,
-  __ΩTypeFormat,
-  anyValuesList,
-  computeDeepkitFormatID,
-  cpf_asJSONString,
-  cpf_formatErr,
-  cpf_getUnknownKeysFromArray,
-  cpf_hasUnknownKeysFromArray,
-  cpf_newRunTypeErr,
-  cpf_safeIterableKey,
-  cpf_sanitizeCompiledFn,
-  createFromBinaryFn,
-  createIsTypeFn,
-  createJitCompiler,
-  createMockTypeFn,
-  createPrepareForJsonFn,
-  createRestoreFromJsonFn,
-  createStringifyJsonFn,
-  createToBinaryFn,
-  createToJavascriptFn,
-  createTypeErrorsFn,
-  createTypeId,
-  defaultIgnoreFormatProps,
-  defaultMockOptions,
-  dependenciesToLiteral,
-  emailLocalPartSymbols,
-  getFormatAnnotation,
-  getFormatterFromCache,
-  getFormatterKey,
-  getFormatterParams,
-  getJITFnName,
-  getJitFnSettings,
-  getJitFunctionCompiler,
-  getMockCompiler,
-  getParsedAnnotationOptions,
-  getReflectionName,
-  getRunTypeAnnotations,
-  getRunTypeFormat,
-  getRunTypeTransformer,
-  getToLiteralFn,
-  getTypeToObject,
-  hasArguments,
-  hasExtends,
-  hasExtendsArguments,
-  hasImplements,
-  hasIndexType,
-  hasMembers,
-  hasParameters,
-  hasReturn,
-  hasType,
-  hasTypeArguments,
-  hasTypeParameters,
-  hasTypes,
-  initFormatAnnotations,
-  isAnyFunctionRunType,
-  isAnyRunType,
-  isArrayRunType,
-  isAtomicRunType,
-  isBigIntRunType,
-  isBooleanRunType,
-  isCallSignatureRunType,
-  isChildAccessorType,
-  isClassRunType,
-  isCollectionRunType,
-  isConstructor,
-  isDateRunType,
-  isEnumMemberRunType,
-  isEnumRunType,
-  isFormatParamMeta,
-  isFunctionParamsRunType,
-  isFunctionRunType,
-  isIndexSignatureRunType,
-  isInterfaceRunType,
-  isIntersectionRunType,
-  isJitErrorsCompiler,
-  isLiteralRunType,
-  isMemberRunType,
-  isMethodSignatureRunType,
-  isNativeUtilityStringTypes,
-  isNeverRunType,
-  isNonSerializableClass,
-  isNonSerializableObject,
-  isNullRunType,
-  isNumberRunType,
-  isObjectLiteralRunType,
-  isObjectRunType,
-  isParameterRunType,
-  isPromiseRunType,
-  isPropertyRunType,
-  isPropertySignatureRunType,
-  isRegexpRunType,
-  isRunType,
-  isStringRunType,
-  isSymbolRunType,
-  isTupleMemberRunType,
-  isTupleRunType,
-  isUndefinedRunType,
-  isUnionRunType,
-  isUnknownRunType,
-  isVoidRunType,
-  jitArgs,
-  jitArgsWithOptions,
-  jitBinaryDeserializerArgs,
-  jitBinarySerializerArgs,
-  jitDefaultArgs,
-  jitDefaultArgsWithOptions,
-  jitDefaultBinaryDeserializerArgs,
-  jitDefaultBinarySerializerArgs,
-  jitDefaultErrorArgs,
-  jitErrorArgs,
-  jitFunctionList,
-  jitFunctionsById,
-  jitSerializationFunctions,
-  jitValidationFunctions,
-  maxStackErrorMessage,
-  mockAny,
-  mockBigInt,
-  mockBoolean,
-  mockDate,
-  mockNumber,
-  mockObjectList,
-  mockRecursiveEmptyArray,
-  mockRegExp,
-  mockRegExpsList,
-  mockString,
-  mockSymbol,
-  mockType,
-  nativeUtilityStringTypes,
-  nonSerializableClasses,
-  nonSerializableGlobals,
-  paramsToLiteral,
-  printClosure,
-  random,
-  randomItem,
-  reflectFunction,
-  registerFormatter,
-  registerJitFunctionCompiler,
-  runType,
-  setMockCompiler,
-  stringCharSet,
-  validPropertyNameRegExp
-};
-//# sourceMappingURL=index.js.map

package/.dist/esm/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;"}

package/.dist/esm/src/constants.d.ts

@@ -1,8 +0,0 @@
-export declare const nonSerializableClasses: (ErrorConstructor | AggregateErrorConstructor | WeakMapConstructor | WeakSetConstructor | DataViewConstructor | ArrayBufferConstructor | SharedArrayBufferConstructor | Float32ArrayConstructor | Float64ArrayConstructor | Int8ArrayConstructor | Int16ArrayConstructor | Int32ArrayConstructor | Uint8ArrayConstructor | Uint8ClampedArrayConstructor | Uint16ArrayConstructor | Uint32ArrayConstructor | BigInt64ArrayConstructor | BigUint64ArrayConstructor)[];
-export declare const nonSerializableGlobals: string[];
-export declare const nativeUtilityStringTypes: string[];
-export declare const validPropertyNameRegExp: RegExp;
-export declare const maxStackErrorMessage = "Max compilation nested level reached, either you have a very deeply nested type or there is an error related to circular references un the types.";
-export declare const JIT_STACK_TRACE_MESSAGE = "\nJIT runType trace => ";
-export declare const MAX_UNION_ITEMS: number;
-//# sourceMappingURL=constants.d.ts.map

package/.dist/esm/src/constants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/constants.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,sBAAsB,qcA4BlC,CAAC;AAIF,eAAO,MAAM,sBAAsB,UAkClC,CAAC;AAGF,eAAO,MAAM,wBAAwB,UAA2D,CAAC;AAGjG,eAAO,MAAM,uBAAuB,QAA6B,CAAC;AAClE,eAAO,MAAM,oBAAoB,sJACsH,CAAC;AACxJ,eAAO,MAAM,uBAAuB,4BAA4B,CAAC;AACjE,eAAO,MAAM,eAAe,QAAc,CAAC"}

package/.dist/esm/src/constants.functions.d.ts

@@ -1,386 +0,0 @@
-import { JitFnArgs } from '@mionjs/core';
-export declare const CodeTypes: {
-    readonly expression: "E";
-    readonly statement: "S";
-    readonly returnBlock: "RB";
-};
-export type CodeType = (typeof CodeTypes)[keyof typeof CodeTypes];
-export interface JitFnSettings {
-    id: string;
-    name: string;
-    import?: () => Promise<(...args: any[]) => any>;
-    jitArgs: JitFnArgs;
-    jitDefaultArgs: JitFnArgs;
-    returnName: string;
-    noInitialVλl?: true;
-    runTimeOptions?: Record<string, {
-        keyName: string;
-        type: 'boolean' | 'number' | 'string';
-        defaultValue: any;
-    }>;
-    formatShouldReplaceJitCode?: true;
-}
-export declare const jitArgs: {
-    readonly vλl: "v";
-};
-export declare const jitDefaultArgs: {
-    readonly vλl: "";
-};
-export declare const jitErrorArgs: {
-    readonly vλl: "v";
-    readonly pλth: "pth";
-    readonly εrr: "er";
-};
-export declare const jitDefaultErrorArgs: {
-    readonly vλl: "";
-    readonly pλth: "[]";
-    readonly εrr: "[]";
-};
-export declare const jitArgsWithOptions: {
-    readonly vλl: "v";
-    readonly θpts: "opts";
-};
-export declare const jitDefaultArgsWithOptions: {
-    readonly vλl: "";
-    readonly θpts: "{}";
-};
-export declare const jitBinarySerializerArgs: {
-    readonly vλl: "v";
-    readonly sεr: "Ser";
-};
-export declare const jitBinaryDeserializerArgs: {
-    readonly vλl: "ret";
-    readonly dεs: "Des";
-};
-export declare const jitDefaultBinarySerializerArgs: {
-    readonly vλl: "";
-    readonly sεr: "";
-};
-export declare const jitDefaultBinaryDeserializerArgs: {
-    readonly vλl: "";
-    readonly dεs: "";
-};
-export declare const jitValidationFunctions: {
-    readonly isType: {
-        readonly id: "is";
-        readonly name: "isType";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly typeErrors: {
-        readonly id: "te";
-        readonly name: "typeErrors";
-        readonly jitArgs: {
-            readonly vλl: "v";
-            readonly pλth: "pth";
-            readonly εrr: "er";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-            readonly pλth: "[]";
-            readonly εrr: "[]";
-        };
-        readonly returnName: "er";
-    };
-};
-export declare const jitSerializationFunctions: {
-    readonly prepareForJson: {
-        readonly id: "tj";
-        readonly name: "prepareForJson";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly restoreFromJson: {
-        readonly id: "fj";
-        readonly name: "restoreFromJson";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly stringifyJson: {
-        readonly id: "sj";
-        readonly name: "stringifyJson";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly toJSCode: {
-        readonly id: "tc";
-        readonly name: "toJSCode";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly toBinary: {
-        readonly id: "tBi";
-        readonly name: "toBinary";
-        readonly jitArgs: {
-            readonly vλl: "v";
-            readonly sεr: "Ser";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-            readonly sεr: "";
-        };
-        readonly returnName: "Ser";
-        readonly formatShouldReplaceJitCode: true;
-    };
-    readonly fromBinary: {
-        readonly id: "fBi";
-        readonly name: "fromBinary";
-        readonly jitArgs: {
-            readonly vλl: "ret";
-            readonly dεs: "Des";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-            readonly dεs: "";
-        };
-        readonly returnName: "ret";
-        readonly noInitialVλl: true;
-        readonly formatShouldReplaceJitCode: true;
-    };
-    readonly format: {
-        readonly id: "fmt";
-        readonly name: "format";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-};
-export declare const JitFunctions: {
-    readonly unknownKeyErrors: {
-        readonly id: "uk";
-        readonly name: "unknownKeyErrors";
-        readonly jitArgs: {
-            readonly vλl: "v";
-            readonly pλth: "pth";
-            readonly εrr: "er";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-            readonly pλth: "[]";
-            readonly εrr: "[]";
-        };
-        readonly returnName: "er";
-    };
-    readonly hasUnknownKeys: {
-        readonly id: "hk";
-        readonly name: "hasUnknownKeys";
-        readonly jitArgs: {
-            readonly vλl: "v";
-            readonly θpts: "opts";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-            readonly θpts: "{}";
-        };
-        readonly runTimeOptions: {
-            readonly checkNonJitProps: {
-                readonly keyName: "checkNonJitProps";
-                readonly type: "boolean";
-                readonly defaultValue: false;
-            };
-        };
-        readonly returnName: "v";
-    };
-    readonly stripUnknownKeys: {
-        readonly id: "sk";
-        readonly name: "stripUnknownKeys";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly unknownKeysToUndefined: {
-        readonly id: "ku";
-        readonly name: "unknownKeysToUndefined";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly aux: {
-        readonly id: "aux";
-        readonly name: "aux";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly mock: {
-        readonly id: "mock";
-        readonly name: "mockType";
-        readonly import: () => Promise<((...args: any[]) => any) | typeof import('./mocking/mockType.ts').mockType>;
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly pureFunction: {
-        readonly id: "pf";
-        readonly name: "pureFunction";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly prepareForJson: {
-        readonly id: "tj";
-        readonly name: "prepareForJson";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly restoreFromJson: {
-        readonly id: "fj";
-        readonly name: "restoreFromJson";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly stringifyJson: {
-        readonly id: "sj";
-        readonly name: "stringifyJson";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly toJSCode: {
-        readonly id: "tc";
-        readonly name: "toJSCode";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly toBinary: {
-        readonly id: "tBi";
-        readonly name: "toBinary";
-        readonly jitArgs: {
-            readonly vλl: "v";
-            readonly sεr: "Ser";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-            readonly sεr: "";
-        };
-        readonly returnName: "Ser";
-        readonly formatShouldReplaceJitCode: true;
-    };
-    readonly fromBinary: {
-        readonly id: "fBi";
-        readonly name: "fromBinary";
-        readonly jitArgs: {
-            readonly vλl: "ret";
-            readonly dεs: "Des";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-            readonly dεs: "";
-        };
-        readonly returnName: "ret";
-        readonly noInitialVλl: true;
-        readonly formatShouldReplaceJitCode: true;
-    };
-    readonly format: {
-        readonly id: "fmt";
-        readonly name: "format";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly isType: {
-        readonly id: "is";
-        readonly name: "isType";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly typeErrors: {
-        readonly id: "te";
-        readonly name: "typeErrors";
-        readonly jitArgs: {
-            readonly vλl: "v";
-            readonly pλth: "pth";
-            readonly εrr: "er";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-            readonly pλth: "[]";
-            readonly εrr: "[]";
-        };
-        readonly returnName: "er";
-    };
-};
-export declare const jitFunctionList: JitFnSettings[];
-export declare const jitFunctionsById: {
-    [k: string]: JitFnSettings;
-};
-export declare type __ΩCodeType = any[];
-export declare type __ΩJitFnSettings = any[];
-//# sourceMappingURL=constants.functions.d.ts.map

package/.dist/esm/src/constants.functions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.functions.d.ts","sourceRoot":"","sources":["../../../src/constants.functions.ts"],"names":[],"mappings":"AAOA,OAAO,EAAC,KAAK,SAAS,EAAmB,MAAM,cAAc,CAAC;AAG9D,eAAO,MAAM,SAAS;;;;CAIZ,CAAC;AACX,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC;AAElE,MAAM,WAAW,aAAa;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IAIb,MAAM,CAAC,EAAE,MAAM,OAAO,CAAC,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC,CAAC;IAChD,OAAO,EAAE,SAAS,CAAC;IACnB,cAAc,EAAE,SAAS,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;IAOnB,YAAY,CAAC,EAAE,IAAI,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,SAAS,GAAG,QAAQ,GAAG,QAAQ,CAAC;QAAC,YAAY,EAAE,GAAG,CAAA;KAAC,CAAC,CAAC;IAK7G,0BAA0B,CAAC,EAAE,IAAI,CAAC;CACrC;AAID,eAAO,MAAM,OAAO;;CAAsB,CAAC;AAC3C,eAAO,MAAM,cAAc;;CAAqB,CAAC;AACjD,eAAO,MAAM,YAAY;;;;CAA8C,CAAC;AACxE,eAAO,MAAM,mBAAmB;;;;CAA4C,CAAC;AAC7E,eAAO,MAAM,kBAAkB;;;CAAoC,CAAC;AACpE,eAAO,MAAM,yBAAyB;;;CAAiC,CAAC;AACxE,eAAO,MAAM,uBAAuB;;;CAAkC,CAAC;AACvE,eAAO,MAAM,yBAAyB;;;CAAoC,CAAC;AAC3E,eAAO,MAAM,8BAA8B;;;CAA8B,CAAC;AAC1E,eAAO,MAAM,gCAAgC;;;CAA8B,CAAC;AAM5E,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAeG,CAAC;AAEvC,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DA,CAAC;AAEvC,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAjHY,GAAG,EAAE,KAAK,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyKZ,CAAC;AAEvC,eAAO,MAAM,eAAe,EAAE,aAAa,EAAgC,CAAC;AAC5E,eAAO,MAAM,gBAAgB;;CAA4D,CAAC"}