@mionjs/run-types 0.8.10 → 0.13.2

package/.dist/esm/src/nodes/collection/unionDiscriminator.js

@@ -1,198 +0,0 @@
-import { getTotalComplexity, sortRunTypeByComplexity } from "../../lib/utils.js";
-import { isAnyRunType, isUnknownRunType } from "../../lib/guards.js";
-function __assignType(fn, args) {
-  fn.__type = args;
-  return fn;
-}
-const __ΩFlattenedProp = ["CollectionRunType", "unionItem", "unionIndex", "PropertyRunType", "prop", "typeID", "compiledName", "FlattenedProp", `P"w!4"P&'J4#"w$4%P&'J4&&4'Mw(y`];
-const __ΩSplitUnionResult = ["BaseRunType", "simpleItems", "CollectionRunType", "objectTypes", "anyItem", "SplitUnionResult", 'P"w!F4""w#F4$"w!4%8Mw&y'];
-function splitUnionItems(comp, urt, unionChildren) {
-  const unionItems = unionChildren || urt.getJitChildren(comp);
-  const objectTypes = [];
-  const simpleItems = [];
-  let anyItem;
-  unionItems.forEach(__assignType((unionItem) => {
-    if (isAnyRunType(unionItem) || isUnknownRunType(unionItem)) {
-      if (!anyItem)
-        anyItem = unionItem;
-      return;
-    }
-    const isObj = urt.isTypeWithProperties(unionItem);
-    if (!isObj)
-      return simpleItems.push(unionItem);
-    return objectTypes.push(unionItem);
-  }, ["unionItem", "", 'P"2!"/"']));
-  const sortedObjectTypes = sortUnreachableTypes(comp, objectTypes);
-  return { simpleItems, objectTypes: sortedObjectTypes, anyItem };
-}
-splitUnionItems.__type = ["JitFnCompiler", "comp", "UnionRunType", "urt", "BaseRunType", "unionChildren", () => __ΩSplitUnionResult, "splitUnionItems", `P"w!2""w#2$"w%F2&8n'/(`];
-function sortUnreachableTypes(comp, objectTypes) {
-  if (objectTypes.length <= 1)
-    return objectTypes;
-  const typePropsMap = (Map.Ω = [["CollectionRunType", '"w!'], ["P&'JD"]], /* @__PURE__ */ new Map());
-  objectTypes.forEach(__assignType((objType) => {
-    const props = objType.getJitChildren(comp);
-    const propTypeIDs = (Set.Ω = [["P&'J"]], /* @__PURE__ */ new Set());
-    props.forEach(__assignType((prop) => propTypeIDs.add(prop.getTypeID()), ["prop", "", 'P"2!"/"']));
-    typePropsMap.set(objType, propTypeIDs);
-  }, ["objType", "", 'P"2!"/"']));
-  const isSubsetOf = __assignType((smaller, larger) => {
-    const smallerProps = typePropsMap.get(smaller);
-    const largerProps = typePropsMap.get(larger);
-    if (smallerProps.size >= largerProps.size)
-      return false;
-    for (const typeID of smallerProps) {
-      if (!largerProps.has(typeID))
-        return false;
-    }
-    return true;
-  }, ["CollectionRunType", "smaller", "larger", "", 'P"w!2""w!2#)/$']);
-  const processed = (Set.Ω = [["CollectionRunType", '"w!']], /* @__PURE__ */ new Set());
-  const result = [];
-  for (let i = 0; i < objectTypes.length; i++) {
-    const current = objectTypes[i];
-    if (processed.has(current))
-      continue;
-    const relatedGroup = [current];
-    processed.add(current);
-    for (let j = 0; j < objectTypes.length; j++) {
-      if (i === j)
-        continue;
-      const other = objectTypes[j];
-      if (processed.has(other))
-        continue;
-      if (isSubsetOf(current, other) || isSubsetOf(other, current)) {
-        relatedGroup.push(other);
-        processed.add(other);
-      }
-    }
-    if (relatedGroup.length > 1) {
-      relatedGroup.sort(__assignType((a, b) => {
-        const aSize = typePropsMap.get(a).size;
-        const bSize = typePropsMap.get(b).size;
-        return bSize - aSize;
-      }, ["a", "b", "", 'P"2!"2""/#']));
-    }
-    result.push(...relatedGroup);
-  }
-  return result;
-}
-sortUnreachableTypes.__type = ["JitFnCompiler", "comp", "CollectionRunType", "objectTypes", "sortUnreachableTypes", 'P"w!2""w#F2$"w#F/%'];
-function markDiscriminators(comp, urt, unionItems) {
-  if (urt.hasDiscriminators !== void 0 && urt.hasObjectTypes !== void 0)
-    return;
-  const objectTypes = unionItems.filter(__assignType((item) => urt.isTypeWithProperties(item), ["item", "", 'P"2!"/"']));
-  const namedDiscriminators = getDiscriminatorProperties(comp, urt, objectTypes, initGetCompiledName());
-  const uniqueDiscriminators = getUniqueDiscriminatorProperties(comp, urt, objectTypes, initGetCompiledName());
-  urt.hasObjectTypes = !!objectTypes.length;
-  urt.hasDiscriminators = !!namedDiscriminators.length || !!uniqueDiscriminators.length;
-}
-markDiscriminators.__type = ["JitFnCompiler", "comp", "UnionRunType", "urt", "BaseRunType", "unionItems", "markDiscriminators", `P"w!2""w#2$"w%F2&"/'`];
-const __ΩPropUnionItemPair = ["PropertyRunType", "prop", "CollectionRunType", "unionItem", "PropUnionItemPair", 'P"w!4""w#4$Mw%y'];
-function getDiscriminatorProperties(comp, urt, unionTypes, getCompiledName) {
-  if (!unionTypes.length)
-    return [];
-  const propByName = (Map.Ω = [["P&'J"], [() => __ΩPropUnionItemPair, "n!F"]], /* @__PURE__ */ new Map());
-  unionTypes.forEach(__assignType((unionItem) => {
-    const props = unionItem.getJitChildren(comp);
-    props.forEach(__assignType((prop) => {
-      const name = prop.getChildVarName(comp);
-      const existing = propByName.get(name) || [];
-      propByName.set(name, [...existing, { prop, unionItem }]);
-    }, ["prop", "", 'P"2!"/"']));
-  }, ["unionItem", "", 'P"2!"/"']));
-  const propsOnAllTypes = Array.from(propByName.entries()).filter(__assignType(([, props]) => props.length === unionTypes.length, ["param0", "", 'P"2!"/"'])).map(__assignType(([key, props]) => ({
-    name: key,
-    props,
-    complexity: props.reduce(__assignType((acc, item) => acc + getTotalComplexity(comp, item.prop), ["acc", "item", "", 'P"2!"2""/#']), 0),
-    isUniqueType: props.every(__assignType((item) => {
-      const child = item;
-      const typeID = child.prop.getTypeID();
-      const isDiff = props.every(__assignType((otherItem) => child.prop === otherItem.prop || otherItem.prop.getTypeID() !== typeID, ["otherItem", "", 'P"2!"/"']));
-      return isDiff;
-    }, ["item", "", 'P"2!"/"']))
-  }), ["param0", "", 'P"2!"/"'])).filter(__assignType((item) => item.isUniqueType, ["item", "", 'P"2!"/"']));
-  const lessComplexProps = propsOnAllTypes.toSorted(__assignType((a, b) => a.complexity - b.complexity, ["a", "b", "", 'P"2!"2""/#']));
-  const lessComplex = lessComplexProps[0];
-  if (!lessComplex)
-    return [];
-  return lessComplex.props.map(__assignType((item) => {
-    item.prop.isUnionDiscriminator = true;
-    const unionIndex = urt.getUnionItemIndex(comp, item.unionItem);
-    const typeID = item.prop.getTypeID();
-    return {
-      unionItem: item.unionItem,
-      unionIndex,
-      prop: item.prop,
-      typeID,
-      compiledName: getCompiledName(comp, urt, typeID)
-    };
-  }, ["item", "", 'P"2!"/"']));
-}
-getDiscriminatorProperties.__type = ["JitFnCompiler", "comp", "UnionRunType", "urt", "CollectionRunType", "unionTypes", "propTypeID", "", "getCompiledName", () => __ΩFlattenedProp, "getDiscriminatorProperties", `P"w!2""w#2$"w%F2&P"w!2""w#2$P&'J2'&/(2)n*F/+`];
-function getUniqueDiscriminatorProperties(comp, urt, unionTypes, getCompiledName) {
-  if (!unionTypes.length)
-    return [];
-  const uniquePropByUnionItem = (Map.Ω = [["CollectionRunType", '"w!'], [() => __ΩPropUnionItemPair, "n!"]], /* @__PURE__ */ new Map());
-  unionTypes.forEach(__assignType((unionItem) => {
-    const props = unionItem.getJitChildren(comp);
-    props.forEach(__assignType((prop) => {
-      const typeID = prop.getTypeID();
-      const isUnique = unionTypes.every(__assignType((otherUnionItem) => {
-        if (otherUnionItem === unionItem)
-          return true;
-        const otherProps = otherUnionItem.getJitChildren(comp);
-        return otherProps.every(__assignType((otherProp) => otherProp.getTypeID() !== typeID, ["otherProp", "", 'P"2!"/"']));
-      }, ["otherUnionItem", "", 'P"2!"/"']));
-      if (isUnique) {
-        const existing = uniquePropByUnionItem.get(unionItem);
-        if (!existing) {
-          uniquePropByUnionItem.set(unionItem, {
-            prop,
-            unionItem
-          });
-          return;
-        }
-        const newItem = { prop, unionItem };
-        const lessComplex = [newItem, existing].toSorted(__assignType((a, b) => sortRunTypeByComplexity(comp, a.prop, b.prop), ["a", "b", "", 'P"2!"2""/#']))[0];
-        uniquePropByUnionItem.set(unionItem, lessComplex);
-      }
-    }, ["prop", "", 'P"2!"/"']));
-  }, ["unionItem", "", 'P"2!"/"']));
-  if (!uniquePropByUnionItem.size)
-    return [];
-  const uniqueProps = Array.from(uniquePropByUnionItem.values());
-  return uniqueProps.map(__assignType((item) => {
-    item.prop.isUnionDiscriminator = true;
-    const unionIndex = urt.getUnionItemIndex(comp, item.unionItem);
-    const typeID = item.prop.getTypeID();
-    return {
-      unionItem: item.unionItem,
-      unionIndex,
-      prop: item.prop,
-      typeID,
-      compiledName: getCompiledName(comp, urt, typeID)
-    };
-  }, ["item", "", 'P"2!"/"']));
-}
-getUniqueDiscriminatorProperties.__type = ["JitFnCompiler", "comp", "UnionRunType", "urt", "CollectionRunType", "unionTypes", "propTypeID", "", "getCompiledName", () => __ΩFlattenedProp, "getUniqueDiscriminatorProperties", `P"w!2""w#2$"w%F2&P"w!2""w#2$P&'J2'&/(2)n*F/+`];
-function initGetCompiledName() {
-  const typeIDs = (Map.Ω = [["P&'J"], ["'"]], /* @__PURE__ */ new Map());
-  return __assignType(function getCompiledName(comp, urt, typeID) {
-    const existingIndex = typeIDs.get(typeID);
-    if (existingIndex)
-      return comp.getLocalVarName("prop", urt) + `_${existingIndex}`;
-    const newIndex = typeIDs.size;
-    typeIDs.set(typeID, newIndex);
-    return comp.getLocalVarName("prop", urt) + `_${newIndex}`;
-  }, ["JitFnCompiler", "comp", "UnionRunType", "urt", "typeID", "getCompiledName", `P"w!2""w#2$P&'J2%&/&`]);
-}
-initGetCompiledName.__type = ["initGetCompiledName", 'P"/!'];
-export {
-  __ΩFlattenedProp,
-  __ΩSplitUnionResult,
-  markDiscriminators,
-  sortUnreachableTypes,
-  splitUnionItems
-};
-//# sourceMappingURL=unionDiscriminator.js.map

package/.dist/esm/src/nodes/collection/unionDiscriminator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"unionDiscriminator.js","sources":["../../../../../src/nodes/collection/unionDiscriminator.ts"],"sourcesContent":["import type {BaseRunType, CollectionRunType, MemberRunType} from '../../lib/baseRunTypes.ts';\nimport type {JitFnCompiler} from '../../lib/jitFnCompiler.ts';\nimport type {UnionRunType} from './union.ts';\nimport type {PropertyRunType} from '../member/property.ts';\nimport {getTotalComplexity, sortRunTypeByComplexity} from '../../lib/utils.ts';\nimport {isAnyRunType, isUnknownRunType} from '../../lib/guards.ts';\n\nexport type FlattenedProp = {\n    /** union item, parent of the property */\n    unionItem: CollectionRunType<any>;\n    /** index of the union item in the union */\n    unionIndex: string | number;\n    /** one property of the union item  */\n    prop: PropertyRunType;\n    /** typeID of the property */\n    typeID: string | number;\n    /** name of the property as it should be used in the code */\n    compiledName: string;\n};\n\nexport type SplitUnionResult = {\n    simpleItems: BaseRunType[];\n    objectTypes: CollectionRunType<any>[];\n    /** any or unknown type if present in the union, should be checked last */\n    anyItem?: BaseRunType;\n};\n\n/**\n * Split the union types in two groups: interface types and simple types\n * interface types are types that have properties, simple types are the rest (atomic types, tuples, etc)\n * If any or unknown types are present, they are extracted and returned separately as anyItem\n * so they can be checked last (any/unknown would match anything, so must be last resort)\n */\nexport function splitUnionItems(comp: JitFnCompiler, urt: UnionRunType, unionChildren?: BaseRunType[]): SplitUnionResult {\n    const unionItems = unionChildren || urt.getJitChildren(comp);\n    const objectTypes: CollectionRunType<any>[] = [];\n    const simpleItems: BaseRunType[] = [];\n    let anyItem: BaseRunType | undefined;\n\n    unionItems.forEach((unionItem) => {\n        // Extract any/unknown types to be checked last\n        if (isAnyRunType(unionItem) || isUnknownRunType(unionItem)) {\n            // Only keep the first any/unknown type (having multiple is redundant)\n            if (!anyItem) anyItem = unionItem;\n            return;\n        }\n        const isObj = urt.isTypeWithProperties(unionItem);\n        if (!isObj) return simpleItems.push(unionItem);\n        return objectTypes.push(unionItem as CollectionRunType<any>);\n    });\n\n    // Sort object types to prevent unreachable types (objects with more props should come first when they share same prop types)\n    const sortedObjectTypes = sortUnreachableTypes(comp, objectTypes);\n\n    return {simpleItems, objectTypes: sortedObjectTypes, anyItem};\n}\n\n/**\n * Sorts object types to prevent unreachable union types.\n * When two objects share the same properties (by typeID), the one with more properties must come first.\n * This ensures that at runtime, the more specific type is checked before the less specific one.\n * Objects that don't share properties with others maintain their relative order.\n */\nexport function sortUnreachableTypes(comp: JitFnCompiler, objectTypes: CollectionRunType<any>[]): CollectionRunType<any>[] {\n    if (objectTypes.length <= 1) return objectTypes;\n\n    // Get property typeIDs for each object type\n    const typePropsMap = new Map<CollectionRunType<any>, Set<string | number>>();\n    objectTypes.forEach((objType) => {\n        const props = objType.getJitChildren(comp) as PropertyRunType[];\n        const propTypeIDs = new Set<string | number>();\n        props.forEach((prop) => propTypeIDs.add(prop.getTypeID()));\n        typePropsMap.set(objType, propTypeIDs);\n    });\n\n    // Check if one object's props are a subset of another's (all props have same typeIDs)\n    const isSubsetOf = (smaller: CollectionRunType<any>, larger: CollectionRunType<any>): boolean => {\n        const smallerProps = typePropsMap.get(smaller)!;\n        const largerProps = typePropsMap.get(larger)!;\n        if (smallerProps.size >= largerProps.size) return false;\n        for (const typeID of smallerProps) {\n            if (!largerProps.has(typeID)) return false;\n        }\n        return true;\n    };\n\n    // Find groups of objects that share properties (one is subset of another)\n    const processed = new Set<CollectionRunType<any>>();\n    const result: CollectionRunType<any>[] = [];\n\n    for (let i = 0; i < objectTypes.length; i++) {\n        const current = objectTypes[i];\n        if (processed.has(current)) continue;\n\n        // Find all objects that are related (subset/superset) to current\n        const relatedGroup: CollectionRunType<any>[] = [current];\n        processed.add(current);\n\n        for (let j = 0; j < objectTypes.length; j++) {\n            if (i === j) continue;\n            const other = objectTypes[j];\n            if (processed.has(other)) continue;\n\n            // Check if current and other are related (one is subset of the other)\n            if (isSubsetOf(current, other) || isSubsetOf(other, current)) {\n                relatedGroup.push(other);\n                processed.add(other);\n            }\n        }\n\n        // Sort related group by number of properties (more props first)\n        if (relatedGroup.length > 1) {\n            relatedGroup.sort((a, b) => {\n                const aSize = typePropsMap.get(a)!.size;\n                const bSize = typePropsMap.get(b)!.size;\n                return bSize - aSize; // descending order (more props first)\n            });\n        }\n\n        result.push(...relatedGroup);\n    }\n\n    return result;\n}\n\n/**\n * Mark discriminator properties so they can be sorted and validate union more efficiently.\n * @param comp\n * @param urt\n */\nexport function markDiscriminators(comp: JitFnCompiler, urt: UnionRunType, unionItems: BaseRunType[]) {\n    if (urt.hasDiscriminators !== undefined && urt.hasObjectTypes !== undefined) return;\n    const objectTypes = unionItems.filter((item) => urt.isTypeWithProperties(item)) as CollectionRunType<any>[];\n    const namedDiscriminators = getDiscriminatorProperties(comp, urt, objectTypes, initGetCompiledName());\n    const uniqueDiscriminators = getUniqueDiscriminatorProperties(comp, urt, objectTypes, initGetCompiledName());\n    urt.hasObjectTypes = !!objectTypes.length;\n    urt.hasDiscriminators = !!namedDiscriminators.length || !!uniqueDiscriminators.length;\n}\n\ntype PropUnionItemPair = {prop: PropertyRunType; unionItem: CollectionRunType<any>};\n\n/**\n * Find a property with the same name in all the types of the union and that has different types.\n * It also marks those properties as discriminator properties so can be sorted later\n */\nfunction getDiscriminatorProperties(\n    comp: JitFnCompiler,\n    urt: UnionRunType,\n    unionTypes: CollectionRunType<any>[],\n    getCompiledName: (comp: JitFnCompiler, urt: UnionRunType, propTypeID: string | number) => string\n): FlattenedProp[] {\n    if (!unionTypes.length) return [];\n    const propByName = new Map<string | number, PropUnionItemPair[]>();\n    unionTypes.forEach((unionItem) => {\n        const props = unionItem.getJitChildren(comp) as PropertyRunType[];\n        props.forEach((prop) => {\n            const name = prop.getChildVarName(comp);\n            const existing = propByName.get(name) || [];\n            // index no needed now\n            propByName.set(name, [...existing, {prop, unionItem}]);\n        });\n    });\n    const propsOnAllTypes = Array.from(propByName.entries())\n        // filter all properties that are in all types\n        .filter(([, props]) => props.length === unionTypes.length)\n        // calculate complexity and check if all types are different in all props\n        .map(([key, props]) => ({\n            name: key,\n            props,\n            complexity: props.reduce((acc, item) => acc + getTotalComplexity(comp, item.prop), 0),\n            isUniqueType: props.every((item) => {\n                const child = item;\n                const typeID = child.prop.getTypeID();\n                const isDiff = props.every((otherItem) => child.prop === otherItem.prop || otherItem.prop.getTypeID() !== typeID);\n                return isDiff;\n            }),\n        }))\n        .filter((item) => item.isUniqueType);\n    const lessComplexProps = propsOnAllTypes.toSorted((a, b) => a.complexity - b.complexity);\n    const lessComplex = lessComplexProps[0];\n    if (!lessComplex) return [];\n    // we need to marks the property as discriminator so they can be sorted and checked first later\n    return lessComplex.props.map((item) => {\n        item.prop.isUnionDiscriminator = true;\n        const unionIndex = urt.getUnionItemIndex(comp, item.unionItem);\n        const typeID = item.prop.getTypeID();\n        return {\n            unionItem: item.unionItem,\n            unionIndex,\n            prop: item.prop,\n            typeID,\n            compiledName: getCompiledName(comp, urt, typeID),\n        };\n    });\n}\n\n/**\n * Get unique properties in the union as discriminators.\n * These properties can be of different name but are unique in the union so can act as discriminators.\n * It also marks those properties as discriminator properties so can be sorted later.\n * */\nfunction getUniqueDiscriminatorProperties(\n    comp: JitFnCompiler,\n    urt: UnionRunType,\n    unionTypes: CollectionRunType<any>[],\n    getCompiledName: (comp: JitFnCompiler, urt: UnionRunType, propTypeID: string | number) => string\n): FlattenedProp[] {\n    if (!unionTypes.length) return [];\n    const uniquePropByUnionItem = new Map<CollectionRunType<any>, PropUnionItemPair>();\n    unionTypes.forEach((unionItem) => {\n        const props = unionItem.getJitChildren(comp) as PropertyRunType[];\n        props.forEach((prop) => {\n            const typeID = prop.getTypeID();\n            const isUnique = unionTypes.every((otherUnionItem) => {\n                if (otherUnionItem === unionItem) return true;\n                const otherProps = otherUnionItem.getJitChildren(comp) as MemberRunType<any>[];\n                return otherProps.every((otherProp) => otherProp.getTypeID() !== typeID);\n            });\n            if (isUnique) {\n                const existing = uniquePropByUnionItem.get(unionItem);\n                if (!existing) {\n                    uniquePropByUnionItem.set(unionItem, {\n                        prop,\n                        unionItem,\n                    });\n                    return;\n                }\n                const newItem = {prop, unionItem};\n                const lessComplex = [newItem, existing].toSorted((a, b) => sortRunTypeByComplexity(comp, a.prop, b.prop))[0];\n                uniquePropByUnionItem.set(unionItem, lessComplex);\n            }\n        });\n    });\n    if (!uniquePropByUnionItem.size) return [];\n    const uniqueProps = Array.from(uniquePropByUnionItem.values());\n    return uniqueProps.map((item) => {\n        item.prop.isUnionDiscriminator = true;\n        const unionIndex = urt.getUnionItemIndex(comp, item.unionItem);\n        const typeID = item.prop.getTypeID();\n        return {\n            unionItem: item.unionItem,\n            unionIndex,\n            prop: item.prop,\n            typeID,\n            compiledName: getCompiledName(comp, urt, typeID),\n        };\n    });\n}\n\nfunction initGetCompiledName() {\n    const typeIDs = new Map<string | number, number>();\n    return function getCompiledName(comp: JitFnCompiler, urt: UnionRunType, typeID: string | number): string {\n        const existingIndex = typeIDs.get(typeID);\n        if (existingIndex) return comp.getLocalVarName('prop', urt) + `_${existingIndex}`;\n        const newIndex = typeIDs.size;\n        typeIDs.set(typeID, newIndex);\n        return comp.getLocalVarName('prop', urt) + `_${newIndex}`;\n    };\n}\n"],"names":[],"mappings":"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"}

package/.dist/esm/src/nodes/function/function.d.ts

@@ -1,35 +0,0 @@
-import { AnyFunction, SrcType, JitFn, JitCode, RunTypeOptions } from '../../types.ts';
-import { TypeFunction } from '@deepkit/type';
-import { BaseRunType } from '../../lib/baseRunTypes.ts';
-import { JitFnCompiler, JitErrorsFnCompiler } from '../../lib/jitFnCompiler.ts';
-import { FunctionParamsRunType } from '../collection/functionParams.ts';
-import { JitCompiledFn } from '@mionjs/core';
-export declare class FunctionRunType<CallType extends AnyFunction = TypeFunction> extends BaseRunType<CallType> {
-    parameterRunTypes: FunctionParamsRunType;
-    skipJit(comp: JitFnCompiler): boolean;
-    onCreated(deepkitType: SrcType): void;
-    getFamily(): 'F';
-    getFnName(): string | number;
-    createJitParamsFunction(jitFn: JitFn, opts?: RunTypeOptions): (...args: any[]) => any;
-    createJitCompiledParamsFunction(jitFn: JitFn, opts?: RunTypeOptions): JitCompiledFn;
-    createJitReturnFunction(jitFn: JitFn): (...args: any[]) => any;
-    createJitCompiledReturnFunction(jitFn: JitFn, opts?: RunTypeOptions): JitCompiledFn;
-    emitIsType(comp: JitFnCompiler): JitCode;
-    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode;
-    emitPrepareForJson(): JitCode;
-    emitRestoreFromJson(): JitCode;
-    emitHasUnknownKeys(): JitCode;
-    emitUnknownKeyErrors(): JitCode;
-    emitStripUnknownKeys(): JitCode;
-    emitUnknownKeysToUndefined(): JitCode;
-    getReturnType(): BaseRunType;
-    getResolvedReturnType(): BaseRunType;
-    getParameters(): FunctionParamsRunType;
-    getParameterNames(opts?: RunTypeOptions): string[];
-    hasReturnData(): boolean;
-    isAsync(): boolean;
-    returnIsPromise(): boolean;
-    mockReturn(ctx?: RunTypeOptions): Promise<any>;
-    mockParams(ctx?: RunTypeOptions): Promise<any[]>;
-}
-//# sourceMappingURL=function.d.ts.map

package/.dist/esm/src/nodes/function/function.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"function.d.ts","sourceRoot":"","sources":["../../../../../src/nodes/function/function.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,WAAW,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,cAAc,EAAC,MAAM,gBAAgB,CAAC;AACzF,OAAO,EAAiB,YAAY,EAAC,MAAM,eAAe,CAAC;AAC3D,OAAO,EAAC,WAAW,EAAC,MAAM,2BAA2B,CAAC;AAEtD,OAAO,EAAC,aAAa,EAAE,mBAAmB,EAAC,MAAM,4BAA4B,CAAC;AAG9E,OAAO,EAAC,qBAAqB,EAAC,MAAM,iCAAiC,CAAC;AACtE,OAAO,EAAC,aAAa,EAAC,MAAM,cAAc,CAAC;AAI3C,qBAAa,eAAe,CAAC,QAAQ,SAAS,WAAW,GAAG,YAAY,CAAE,SAAQ,WAAW,CAAC,QAAQ,CAAC;IAEnG,iBAAiB,EAAE,qBAAqB,CAA+B;IACvE,OAAO,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAIrC,SAAS,CAAC,WAAW,EAAE,OAAO,GAAG,IAAI;IAUrC,SAAS,IAAI,GAAG;IAGhB,SAAS,IAAI,MAAM,GAAG,MAAM;IAM5B,uBAAuB,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,cAAc,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG;IAGrF,+BAA+B,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,cAAc,GAAG,aAAa;IAUnF,uBAAuB,CAAC,KAAK,EAAE,KAAK,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG;IAI9D,+BAA+B,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,cAAc,GAAG,aAAa;IAOnF,UAAU,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAQxC,cAAc,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO;IAMlD,kBAAkB,IAAI,OAAO;IAG7B,mBAAmB,IAAI,OAAO;IAG9B,kBAAkB,IAAI,OAAO;IAG7B,oBAAoB,IAAI,OAAO;IAG/B,oBAAoB,IAAI,OAAO;IAG/B,0BAA0B,IAAI,OAAO;IAUrC,aAAa,IAAI,WAAW;IAI5B,qBAAqB,IAAI,WAAW;IAoBpC,aAAa,IAAI,qBAAqB;IAGtC,iBAAiB,CAAC,IAAI,CAAC,EAAE,cAAc,GAAG,MAAM,EAAE;IAQlD,aAAa,IAAI,OAAO;IAMxB,OAAO,IAAI,OAAO;IAMlB,eAAe,IAAI,OAAO;IAGpB,UAAU,CAAC,GAAG,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,GAAG,CAAC;IAI9C,UAAU,CAAC,GAAG,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;CAIzD"}

package/.dist/esm/src/nodes/function/function.js

@@ -1,159 +0,0 @@
-import { ReflectionKind, __ΩTypeFunction as ___TypeFunction } from "@deepkit/type";
-import { BaseRunType } from "../../lib/baseRunTypes.js";
-import { isAnyFunctionRunType, isPromiseRunType, isFunctionRunType } from "../../lib/guards.js";
-import { JitFnCompiler, JitErrorsFnCompiler } from "../../lib/jitFnCompiler.js";
-import { ReflectionSubKind } from "../../constants.kind.js";
-import { FunctionParamsRunType } from "../collection/functionParams.js";
-import { __ΩJitCompiledFn as ___JitCompiledFn } from "@mionjs/core";
-import { registerJitFunctionCompiler } from "../../lib/jitFnsRegistry.js";
-import { JitFunctions } from "../../constants.functions.js";
-function __assignType(fn, args) {
-  fn.__type = args;
-  return fn;
-}
-class FunctionRunType extends BaseRunType {
-  // parameterRunTypes.src must be set after FunctionRunType creation
-  parameterRunTypes = new FunctionParamsRunType();
-  skipJit(comp) {
-    if (!comp)
-      return true;
-    return comp.fnID !== JitFunctions.toJSCode.id;
-  }
-  onCreated(deepkitType) {
-    super.onCreated(deepkitType);
-    const paramsType = { ...deepkitType, subKind: ReflectionSubKind.params };
-    delete paramsType._typeId;
-    delete paramsType._formatId;
-    this.parameterRunTypes.onCreated(paramsType);
-  }
-  getFamily() {
-    return "F";
-  }
-  getFnName() {
-    const name = this.src.name;
-    if (!name)
-      return "";
-    if (typeof name === "symbol")
-      return name.toString();
-    return name;
-  }
-  createJitParamsFunction(jitFn, opts) {
-    return this.createJitCompiledParamsFunction(jitFn, opts).fn;
-  }
-  createJitCompiledParamsFunction(jitFn, opts) {
-    const start = opts?.paramsSlice?.start;
-    const end = opts?.paramsSlice?.end;
-    if (start && end) {
-      if (start < 0 || end > this.parameterRunTypes.getChildRunTypes().length)
-        throw new Error(`Invalid paramsSlice, start: ${start}, end: ${end}.`);
-      if (end <= start)
-        throw new Error(`Invalid paramsSlice, start: ${start}, end: ${end}`);
-    }
-    return this.parameterRunTypes.createJitCompiledFunction(jitFn.id, void 0, opts);
-  }
-  createJitReturnFunction(jitFn) {
-    return this.createJitCompiledReturnFunction(jitFn).fn;
-  }
-  createJitCompiledReturnFunction(jitFn, opts) {
-    return this.getResolvedReturnType().createJitCompiledFunction(jitFn.id, void 0, opts);
-  }
-  // ######## JIT functions (all throw error) ########
-  // can't know the types of the run type function parameters, neither the return type, so only compare function name and length
-  emitIsType(comp) {
-    const minLength = this.parameterRunTypes.totalRequiredParams(comp);
-    const totalParams = this.parameterRunTypes.getParamRunTypes(comp).length;
-    const hasOptional = totalParams > minLength;
-    const maxLength = this.parameterRunTypes.hasRestParameter(comp) || !hasOptional ? "" : ` && ${comp.vλl}.length <= ${totalParams}`;
-    return { code: `(typeof ${comp.vλl} === 'function' && ${comp.vλl}.length >= ${minLength} ${maxLength})`, type: "E" };
-  }
-  emitTypeErrors(comp) {
-    return { code: `if (!(${this.emitIsType(comp).code})) ${comp.callJitErr(this)};`, type: "S" };
-  }
-  /**
-   * json encode a function
-   */
-  emitPrepareForJson() {
-    throw new Error(`Compile function PrepareForJson not supported, call compileParams or compileReturn instead.`);
-  }
-  emitRestoreFromJson() {
-    throw new Error(`Compile function RestoreFromJson not supported, call compileParams or compileReturn instead.`);
-  }
-  emitHasUnknownKeys() {
-    return { code: "", type: "E" };
-  }
-  emitUnknownKeyErrors() {
-    return { code: "", type: "S" };
-  }
-  emitStripUnknownKeys() {
-    return { code: "", type: "S" };
-  }
-  emitUnknownKeysToUndefined() {
-    return { code: "", type: "S" };
-  }
-  // TODO: paramsSlice has been removed as options are not jet passed when building the run type. maybe we can pass it to the JitCompileOperation instead
-  // constructor() {
-  //     const start = opts?.paramsSlice?.start;
-  //     const end = opts?.paramsSlice?.end;
-  //     parameterRunTypes = src.parameters.slice(start, end).map((p) => visitor(p, parents, opts)) as ParameterRunType[];
-  // }
-  getReturnType() {
-    return this.src.return._rt;
-  }
-  /** returns the inner run-type when the handler returns Promise<T> (or nested Promise/function-return chains), or the plain return type otherwise */
-  getResolvedReturnType() {
-    let currentType = this;
-    while (true) {
-      if (isAnyFunctionRunType(currentType)) {
-        const returnType = currentType.getReturnType();
-        if (isPromiseRunType(returnType) || isFunctionRunType(returnType)) {
-          currentType = returnType;
-          continue;
-        }
-        return returnType;
-      }
-      const memberType = currentType.getMemberType();
-      if (isPromiseRunType(memberType) || isFunctionRunType(memberType)) {
-        currentType = memberType;
-        continue;
-      }
-      return memberType;
-    }
-  }
-  getParameters() {
-    return this.parameterRunTypes;
-  }
-  getParameterNames(opts) {
-    const start = opts?.paramsSlice?.start;
-    const end = opts?.paramsSlice?.end;
-    if (start || end) {
-      return this.src.parameters.slice(start, end).map(__assignType((p) => p.name, ["p", "", 'P"2!"/"']));
-    }
-    return this.src.parameters.map(__assignType((p) => p.name, ["p", "", 'P"2!"/"']));
-  }
-  hasReturnData() {
-    const returnKind = this.getReturnType().src.kind;
-    return returnKind !== ReflectionKind.void && returnKind !== ReflectionKind.never && returnKind !== ReflectionKind.undefined;
-  }
-  isAsync() {
-    const returnKind = this.getReturnType().src.kind;
-    return returnKind === ReflectionKind.promise || returnKind === ReflectionKind.any || returnKind === ReflectionKind.unknown;
-  }
-  returnIsPromise() {
-    return isPromiseRunType(this.getReturnType());
-  }
-  async mockReturn(ctx) {
-    await registerJitFunctionCompiler(JitFunctions.mock);
-    return this.getReturnType().mockType(ctx);
-  }
-  async mockParams(ctx) {
-    await registerJitFunctionCompiler(JitFunctions.mock);
-    return this.parameterRunTypes.mockType(ctx);
-  }
-  static __type = [() => ___TypeFunction, "CallType", () => BaseRunType, () => FunctionParamsRunType, "parameterRunTypes", function() {
-    return new FunctionParamsRunType();
-  }, () => JitFnCompiler, "comp", "skipJit", "SrcType", "deepkitType", "onCreated", "F", "getFamily", "getFnName", "JitFn", "jitFn", "RunTypeOptions", "opts", "args", "", "createJitParamsFunction", () => ___JitCompiledFn, "createJitCompiledParamsFunction", "createJitReturnFunction", () => ___JitCompiledFn, "createJitCompiledReturnFunction", () => JitFnCompiler, "JitCode", "emitIsType", () => JitErrorsFnCompiler, "emitTypeErrors", "emitPrepareForJson", "emitRestoreFromJson", "emitHasUnknownKeys", "emitUnknownKeyErrors", "emitStripUnknownKeys", "emitUnknownKeysToUndefined", () => BaseRunType, "getReturnType", () => BaseRunType, "getResolvedReturnType", () => FunctionParamsRunType, "getParameters", "getParameterNames", "hasReturnData", "isAsync", "returnIsPromise", "ctx", "mockReturn", "mockParams", "FunctionRunType", 'n!c"Pe"!7#P7$3%>&PP7\'2()0)P"w*2+$0,P.-0.PP&\'J0/P"w021"w2238P"@24"/506P"w021"w2238n708P"w021P"@24"/509P"w021"w2238n:0;PP7<2("w=0>PP7?2("w=0@P"w=0AP"w=0BP"w=0CP"w=0DP"w=0EP"w=0FPP7G0HPP7I0JPP7K0LP"w2238&F0MP)0NP)0OP)0PP"w22Q8"`0RP"w22Q8"F`0S5e!!6"wT'];
-}
-export {
-  FunctionRunType
-};
-//# sourceMappingURL=function.js.map

package/.dist/esm/src/nodes/function/function.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"function.js","sources":["../../../../../src/nodes/function/function.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\nimport type {AnyFunction, SrcType, JitFn, JitCode, RunTypeOptions} from '../../types.ts';\nimport {ReflectionKind, TypeFunction} from '@deepkit/type';\nimport {BaseRunType} from '../../lib/baseRunTypes.ts';\nimport {isAnyFunctionRunType, isFunctionRunType, isPromiseRunType} from '../../lib/guards.ts';\nimport {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';\nimport {PromiseRunType} from '../native/promise.ts';\nimport {ReflectionSubKind} from '../../constants.kind.ts';\nimport {FunctionParamsRunType} from '../collection/functionParams.ts';\nimport {JitCompiledFn} from '@mionjs/core';\nimport {registerJitFunctionCompiler} from '../../lib/jitFnsRegistry.ts';\nimport {JitFunctions} from '../../constants.functions.ts';\n\nexport class FunctionRunType<CallType extends AnyFunction = TypeFunction> extends BaseRunType<CallType> {\n    // parameterRunTypes.src must be set after FunctionRunType creation\n    parameterRunTypes: FunctionParamsRunType = new FunctionParamsRunType();\n    skipJit(comp: JitFnCompiler): boolean {\n        if (!comp) return true;\n        return comp.fnID !== JitFunctions.toJSCode.id;\n    }\n    onCreated(deepkitType: SrcType): void {\n        // here we are mapping parameters from TypeParameter[] to TypeTuple as TupleRunType() is the same functionality as ParameterRunType[]\n        super.onCreated(deepkitType);\n        // Create a synthetic type for parameters with its own subKind\n        // Explicitly exclude _typeId and _formatId so the params type gets its own cached IDs\n        const paramsType = {...deepkitType, subKind: ReflectionSubKind.params} as any;\n        delete paramsType._typeId;\n        delete paramsType._formatId;\n        this.parameterRunTypes.onCreated(paramsType);\n    }\n    getFamily(): 'F' {\n        return 'F';\n    }\n    getFnName(): string | number {\n        const name = (this.src as TypeFunction).name;\n        if (!name) return '';\n        if (typeof name === 'symbol') return name.toString();\n        return name;\n    }\n    createJitParamsFunction(jitFn: JitFn, opts?: RunTypeOptions): (...args: any[]) => any {\n        return this.createJitCompiledParamsFunction(jitFn, opts).fn;\n    }\n    createJitCompiledParamsFunction(jitFn: JitFn, opts?: RunTypeOptions): JitCompiledFn {\n        const start = opts?.paramsSlice?.start;\n        const end = opts?.paramsSlice?.end;\n        if (start && end) {\n            if (start < 0 || end > this.parameterRunTypes.getChildRunTypes().length)\n                throw new Error(`Invalid paramsSlice, start: ${start}, end: ${end}.`);\n            if (end <= start) throw new Error(`Invalid paramsSlice, start: ${start}, end: ${end}`);\n        }\n        return this.parameterRunTypes.createJitCompiledFunction(jitFn.id, undefined, opts);\n    }\n    createJitReturnFunction(jitFn: JitFn): (...args: any[]) => any {\n        return this.createJitCompiledReturnFunction(jitFn).fn;\n    }\n\n    createJitCompiledReturnFunction(jitFn: JitFn, opts?: RunTypeOptions): JitCompiledFn {\n        return this.getResolvedReturnType().createJitCompiledFunction(jitFn.id, undefined, opts);\n    }\n\n    // ######## JIT functions (all throw error) ########\n\n    // can't know the types of the run type function parameters, neither the return type, so only compare function name and length\n    emitIsType(comp: JitFnCompiler): JitCode {\n        const minLength = this.parameterRunTypes.totalRequiredParams(comp);\n        const totalParams = this.parameterRunTypes.getParamRunTypes(comp).length;\n        const hasOptional = totalParams > minLength;\n        const maxLength =\n            this.parameterRunTypes.hasRestParameter(comp) || !hasOptional ? '' : ` && ${comp.vλl}.length <= ${totalParams}`;\n        return {code: `(typeof ${comp.vλl} === 'function' && ${comp.vλl}.length >= ${minLength} ${maxLength})`, type: 'E'};\n    }\n    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {\n        return {code: `if (!(${this.emitIsType(comp).code})) ${comp.callJitErr(this)};`, type: 'S'};\n    }\n    /**\n     * json encode a function\n     */\n    emitPrepareForJson(): JitCode {\n        throw new Error(`Compile function PrepareForJson not supported, call compileParams or compileReturn instead.`);\n    }\n    emitRestoreFromJson(): JitCode {\n        throw new Error(`Compile function RestoreFromJson not supported, call compileParams or compileReturn instead.`);\n    }\n    emitHasUnknownKeys(): JitCode {\n        return {code: '', type: 'E'};\n    }\n    emitUnknownKeyErrors(): JitCode {\n        return {code: '', type: 'S'};\n    }\n    emitStripUnknownKeys(): JitCode {\n        return {code: '', type: 'S'};\n    }\n    emitUnknownKeysToUndefined(): JitCode {\n        return {code: '', type: 'S'};\n    }\n\n    // TODO: paramsSlice has been removed as options are not jet passed when building the run type. maybe we can pass it to the JitCompileOperation instead\n    // constructor() {\n    //     const start = opts?.paramsSlice?.start;\n    //     const end = opts?.paramsSlice?.end;\n    //     parameterRunTypes = src.parameters.slice(start, end).map((p) => visitor(p, parents, opts)) as ParameterRunType[];\n    // }\n    getReturnType(): BaseRunType {\n        return (this.src.return as SrcType)._rt as BaseRunType;\n    }\n    /** returns the inner run-type when the handler returns Promise<T> (or nested Promise/function-return chains), or the plain return type otherwise */\n    getResolvedReturnType(): BaseRunType {\n        let currentType: PromiseRunType | FunctionRunType<any> = this; // eslint-disable-line @typescript-eslint/no-this-alias\n        // eslint-disable-next-line no-constant-condition\n        while (true) {\n            if (isAnyFunctionRunType(currentType)) {\n                const returnType = currentType.getReturnType();\n                if (isPromiseRunType(returnType) || isFunctionRunType(returnType)) {\n                    currentType = returnType;\n                    continue;\n                }\n                return returnType;\n            }\n            const memberType = currentType.getMemberType();\n            if (isPromiseRunType(memberType) || isFunctionRunType(memberType)) {\n                currentType = memberType;\n                continue;\n            }\n            return memberType;\n        }\n    }\n    getParameters(): FunctionParamsRunType {\n        return this.parameterRunTypes;\n    }\n    getParameterNames(opts?: RunTypeOptions): string[] {\n        const start = opts?.paramsSlice?.start;\n        const end = opts?.paramsSlice?.end;\n        if (start || end) {\n            return this.src.parameters.slice(start, end).map((p) => p.name);\n        }\n        return this.src.parameters.map((p) => p.name);\n    }\n    hasReturnData(): boolean {\n        const returnKind = this.getReturnType().src.kind;\n        return (\n            returnKind !== ReflectionKind.void && returnKind !== ReflectionKind.never && returnKind !== ReflectionKind.undefined\n        );\n    }\n    isAsync(): boolean {\n        const returnKind = this.getReturnType().src.kind;\n        return (\n            returnKind === ReflectionKind.promise || returnKind === ReflectionKind.any || returnKind === ReflectionKind.unknown\n        );\n    }\n    returnIsPromise(): boolean {\n        return isPromiseRunType(this.getReturnType());\n    }\n    async mockReturn(ctx?: RunTypeOptions): Promise<any> {\n        await registerJitFunctionCompiler(JitFunctions.mock);\n        return this.getReturnType().mockType(ctx);\n    }\n    async mockParams(ctx?: RunTypeOptions): Promise<any[]> {\n        await registerJitFunctionCompiler(JitFunctions.mock);\n        return this.parameterRunTypes.mockType(ctx);\n    }\n}\n"],"names":["__ΩTypeFunction","__ΩJitCompiledFn"],"mappings":"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"}

package/.dist/esm/src/nodes/member/array.d.ts

@@ -1,25 +0,0 @@
-import { Type, TypeArray } from '@deepkit/type';
-import { JitCode } from '../../types.ts';
-import { JitFnCompiler, JitErrorsFnCompiler } from '../../lib/jitFnCompiler.ts';
-import { MemberRunType } from '../../lib/baseRunTypes.ts';
-export declare class ArrayRunType<T extends Type = TypeArray> extends MemberRunType<T> {
-    startIndex(comp: JitFnCompiler): number;
-    getChildVarName(comp: JitFnCompiler): string;
-    getChildLiteral(comp: JitFnCompiler): string;
-    useArrayAccessor(): true;
-    isOptional(): boolean;
-    emitIsType(comp: JitFnCompiler): JitCode;
-    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode;
-    emitPrepareForJson(comp: JitFnCompiler): JitCode;
-    emitRestoreFromJson(comp: JitFnCompiler): JitCode;
-    emitHasUnknownKeys(comp: JitFnCompiler): JitCode;
-    emitUnknownKeyErrors(comp: JitErrorsFnCompiler): JitCode;
-    emitStripUnknownKeys(comp: JitFnCompiler): JitCode;
-    emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode;
-    traverseCode(comp: JitFnCompiler, childJit: JitCode | undefined): {
-        code: string | undefined;
-        type: 'S';
-    };
-    checkNonSkipTypes(comp: JitFnCompiler): void;
-}
-//# sourceMappingURL=array.d.ts.map

package/.dist/esm/src/nodes/member/array.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../../../../src/nodes/member/array.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAC,IAAI,EAAE,SAAS,EAAC,MAAM,eAAe,CAAC;AACnD,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,EAAC,aAAa,EAAE,mBAAmB,EAAC,MAAM,4BAA4B,CAAC;AACnF,OAAO,EAAC,aAAa,EAAC,MAAM,2BAA2B,CAAC;AAGxD,qBAAa,YAAY,CAAC,CAAC,SAAS,IAAI,GAAG,SAAS,CAAE,SAAQ,aAAa,CAAC,CAAC,CAAC;IAE1E,UAAU,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM;IAGvC,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM;IAG5C,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM;IAG5C,gBAAgB,IAAI,IAAI;IAGxB,UAAU,IAAI,OAAO;IAKrB,UAAU,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAqBxC,cAAc,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO;IAclD,kBAAkB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAahD,mBAAmB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAajD,kBAAkB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAqBhD,oBAAoB,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO;IAOxD,oBAAoB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAOlD,0BAA0B,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAQxD,YAAY,CAAC,IAAI,EAAE,aAAa,EAAE,QAAQ,EAAE,OAAO,GAAG,SAAS,GAAG;QAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;QAAC,IAAI,EAAE,GAAG,CAAA;KAAC;IASvG,iBAAiB,CAAC,IAAI,EAAE,aAAa;CAIxC"}