@cheetah.js/orm 0.1.0 → 0.1.1

package/dist/bun/index.js

@@ -23556,15 +23556,15 @@ ${lanes.join("\n")}
       return predicate && predicate.kind === 0;
     }
     function forEachPropertyAssignment(objectLiteral, key, callback, key2) {
-      return forEach(objectLiteral == null ? undefined : objectLiteral.properties, (property) => {
-        if (!isPropertyAssignment(property))
+      return forEach(objectLiteral == null ? undefined : objectLiteral.properties, (property2) => {
+        if (!isPropertyAssignment(property2))
           return;
-        const propName = tryGetTextOfPropertyName(property.name);
-        return key === propName || key2 && key2 === propName ? callback(property) : undefined;
+        const propName = tryGetTextOfPropertyName(property2.name);
+        return key === propName || key2 && key2 === propName ? callback(property2) : undefined;
       });
     }
     function getPropertyArrayElementValue(objectLiteral, propKey, elementValue) {
-      return forEachPropertyAssignment(objectLiteral, propKey, (property) => isArrayLiteralExpression(property.initializer) ? find(property.initializer.elements, (element) => isStringLiteral(element) && element.text === elementValue) : undefined);
+      return forEachPropertyAssignment(objectLiteral, propKey, (property2) => isArrayLiteralExpression(property2.initializer) ? find(property2.initializer.elements, (element) => isStringLiteral(element) && element.text === elementValue) : undefined);
     }
     function getTsConfigObjectLiteralExpression(tsConfigSourceFile) {
       if (tsConfigSourceFile && tsConfigSourceFile.statements.length) {
@@ -23573,7 +23573,7 @@ ${lanes.join("\n")}
       }
     }
     function getTsConfigPropArrayElementValue(tsConfigSourceFile, propKey, elementValue) {
-      return forEachTsConfigPropArray(tsConfigSourceFile, propKey, (property) => isArrayLiteralExpression(property.initializer) ? find(property.initializer.elements, (element) => isStringLiteral(element) && element.text === elementValue) : undefined);
+      return forEachTsConfigPropArray(tsConfigSourceFile, propKey, (property2) => isArrayLiteralExpression(property2.initializer) ? find(property2.initializer.elements, (element) => isStringLiteral(element) && element.text === elementValue) : undefined);
     }
     function forEachTsConfigPropArray(tsConfigSourceFile, propKey, callback) {
       return forEachPropertyAssignment(getTsConfigObjectLiteralExpression(tsConfigSourceFile), propKey, callback);
@@ -26506,17 +26506,17 @@ ${lanes.join("\n")}
           return Debug.assertNever(a);
       }
     }
-    function compareDataObjects(dst, src) {
-      if (!dst || !src || Object.keys(dst).length !== Object.keys(src).length) {
+    function compareDataObjects(dst, src2) {
+      if (!dst || !src2 || Object.keys(dst).length !== Object.keys(src2).length) {
         return false;
       }
       for (const e in dst) {
         if (typeof dst[e] === "object") {
-          if (!compareDataObjects(dst[e], src[e])) {
+          if (!compareDataObjects(dst[e], src2[e])) {
             return false;
           }
         } else if (typeof dst[e] !== "function") {
-          if (dst[e] !== src[e]) {
+          if (dst[e] !== src2[e]) {
             return false;
           }
         }
@@ -35048,10 +35048,10 @@ ${lanes.join("\n")}
         return setParent(setTextRange(factory2.cloneNode(memberName), memberName), memberName.parent);
       }
     }
-    function createExpressionForAccessorDeclaration(factory2, properties, property, receiver, multiLine) {
-      const { firstAccessor, getAccessor, setAccessor } = getAllAccessorDeclarations(properties, property);
-      if (property === firstAccessor) {
-        return setTextRange(factory2.createObjectDefinePropertyCall(receiver, createExpressionForPropertyName(factory2, property.name), factory2.createPropertyDescriptor({
+    function createExpressionForAccessorDeclaration(factory2, properties, property2, receiver, multiLine) {
+      const { firstAccessor, getAccessor, setAccessor } = getAllAccessorDeclarations(properties, property2);
+      if (property2 === firstAccessor) {
+        return setTextRange(factory2.createObjectDefinePropertyCall(receiver, createExpressionForPropertyName(factory2, property2.name), factory2.createPropertyDescriptor({
           enumerable: factory2.createFalse(),
           configurable: true,
           get: getAccessor && setTextRange(setOriginalNode(factory2.createFunctionExpression(getModifiers(getAccessor), undefined, undefined, undefined, getAccessor.parameters, undefined, getAccessor.body), getAccessor), getAccessor),
@@ -35060,29 +35060,29 @@ ${lanes.join("\n")}
       }
       return;
     }
-    function createExpressionForPropertyAssignment(factory2, property, receiver) {
-      return setOriginalNode(setTextRange(factory2.createAssignment(createMemberAccessForPropertyName(factory2, receiver, property.name, property.name), property.initializer), property), property);
+    function createExpressionForPropertyAssignment(factory2, property2, receiver) {
+      return setOriginalNode(setTextRange(factory2.createAssignment(createMemberAccessForPropertyName(factory2, receiver, property2.name, property2.name), property2.initializer), property2), property2);
     }
-    function createExpressionForShorthandPropertyAssignment(factory2, property, receiver) {
-      return setOriginalNode(setTextRange(factory2.createAssignment(createMemberAccessForPropertyName(factory2, receiver, property.name, property.name), factory2.cloneNode(property.name)), property), property);
+    function createExpressionForShorthandPropertyAssignment(factory2, property2, receiver) {
+      return setOriginalNode(setTextRange(factory2.createAssignment(createMemberAccessForPropertyName(factory2, receiver, property2.name, property2.name), factory2.cloneNode(property2.name)), property2), property2);
     }
     function createExpressionForMethodDeclaration(factory2, method, receiver) {
       return setOriginalNode(setTextRange(factory2.createAssignment(createMemberAccessForPropertyName(factory2, receiver, method.name, method.name), setOriginalNode(setTextRange(factory2.createFunctionExpression(getModifiers(method), method.asteriskToken, undefined, undefined, method.parameters, undefined, method.body), method), method)), method), method);
     }
-    function createExpressionForObjectLiteralElementLike(factory2, node, property, receiver) {
-      if (property.name && isPrivateIdentifier(property.name)) {
-        Debug.failBadSyntaxKind(property.name, "Private identifiers are not allowed in object literals.");
+    function createExpressionForObjectLiteralElementLike(factory2, node, property2, receiver) {
+      if (property2.name && isPrivateIdentifier(property2.name)) {
+        Debug.failBadSyntaxKind(property2.name, "Private identifiers are not allowed in object literals.");
       }
-      switch (property.kind) {
+      switch (property2.kind) {
         case 177:
         case 178:
-          return createExpressionForAccessorDeclaration(factory2, node.properties, property, receiver, !!node.multiLine);
+          return createExpressionForAccessorDeclaration(factory2, node.properties, property2, receiver, !!node.multiLine);
         case 303:
-          return createExpressionForPropertyAssignment(factory2, property, receiver);
+          return createExpressionForPropertyAssignment(factory2, property2, receiver);
         case 304:
-          return createExpressionForShorthandPropertyAssignment(factory2, property, receiver);
+          return createExpressionForShorthandPropertyAssignment(factory2, property2, receiver);
         case 174:
-          return createExpressionForMethodDeclaration(factory2, property, receiver);
+          return createExpressionForMethodDeclaration(factory2, property2, receiver);
       }
     }
     function expandPreOrPostfixIncrementOrDecrementExpression(factory2, node, expression, recordTempVariable, resultVariable) {
@@ -43484,7 +43484,7 @@ ${lanes.join("\n")}
             if (sourceFile) {
               const fileName = configFileName || "tsconfig.json";
               const diagnosticMessage = Diagnostics.The_files_list_in_config_file_0_is_empty;
-              const nodeValue = forEachTsConfigPropArray(sourceFile, "files", (property) => property.initializer);
+              const nodeValue = forEachTsConfigPropArray(sourceFile, "files", (property2) => property2.initializer);
               const error2 = createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, nodeValue, diagnosticMessage, fileName);
               errors.push(error2);
             } else {
@@ -51498,9 +51498,9 @@ ${lanes.join("\n")}
           const node = getParseTreeNode(nodeIn, isPropertyAccessOrQualifiedNameOrImportTypeNode);
           return !!node && isValidPropertyAccess(node, escapeLeadingUnderscores(propertyName));
         },
-        isValidPropertyAccessForCompletions: (nodeIn, type, property) => {
+        isValidPropertyAccessForCompletions: (nodeIn, type, property2) => {
           const node = getParseTreeNode(nodeIn, isPropertyAccessExpression);
-          return !!node && isValidPropertyAccessForCompletions(node, type, property);
+          return !!node && isValidPropertyAccessForCompletions(node, type, property2);
         },
         getSignatureFromDeclaration: (declarationIn) => {
           const declaration = getParseTreeNode(declarationIn, isFunctionLike);
@@ -60069,11 +60069,11 @@ ${lanes.join("\n")}
       }
       function isTypeInvalidDueToUnionDiscriminant(contextualType, obj) {
         const list = obj.properties;
-        return list.some((property) => {
-          const nameType = property.name && (isJsxNamespacedName(property.name) ? getStringLiteralType(getTextOfJsxAttributeName(property.name)) : getLiteralTypeFromPropertyName(property.name));
+        return list.some((property2) => {
+          const nameType = property2.name && (isJsxNamespacedName(property2.name) ? getStringLiteralType(getTextOfJsxAttributeName(property2.name)) : getLiteralTypeFromPropertyName(property2.name));
           const name = nameType && isTypeUsableAsPropertyName(nameType) ? getPropertyNameFromType(nameType) : undefined;
           const expected = name === undefined ? undefined : getTypeOfPropertyOfType(contextualType, name);
-          return !!expected && isLiteralType(expected) && !isTypeAssignableTo(getTypeOfNode(property), expected);
+          return !!expected && isLiteralType(expected) && !isTypeAssignableTo(getTypeOfNode(property2), expected);
         });
       }
       function getAllPossiblePropertiesOfTypes(types) {
@@ -60499,15 +60499,15 @@ ${lanes.join("\n")}
       }
       function getUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment) {
         var _a, _b;
-        let property = ((_a = type.propertyCacheWithoutObjectFunctionPropertyAugment) == null ? undefined : _a.get(name)) || !skipObjectFunctionPropertyAugment ? (_b = type.propertyCache) == null ? undefined : _b.get(name) : undefined;
-        if (!property) {
-          property = createUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment);
-          if (property) {
+        let property2 = ((_a = type.propertyCacheWithoutObjectFunctionPropertyAugment) == null ? undefined : _a.get(name)) || !skipObjectFunctionPropertyAugment ? (_b = type.propertyCache) == null ? undefined : _b.get(name) : undefined;
+        if (!property2) {
+          property2 = createUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment);
+          if (property2) {
             const properties = skipObjectFunctionPropertyAugment ? type.propertyCacheWithoutObjectFunctionPropertyAugment || (type.propertyCacheWithoutObjectFunctionPropertyAugment = createSymbolTable()) : type.propertyCache || (type.propertyCache = createSymbolTable());
-            properties.set(name, property);
+            properties.set(name, property2);
           }
         }
-        return property;
+        return property2;
       }
       function getCommonDeclarationsOfSymbols(symbols) {
         let commonDeclarations;
@@ -60531,8 +60531,8 @@ ${lanes.join("\n")}
         return commonDeclarations;
       }
       function getPropertyOfUnionOrIntersectionType(type, name, skipObjectFunctionPropertyAugment) {
-        const property = getUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment);
-        return property && !(getCheckFlags(property) & 16) ? property : undefined;
+        const property2 = getUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment);
+        return property2 && !(getCheckFlags(property2) & 16) ? property2 : undefined;
       }
       function getReducedType(type) {
         if (type.flags & 1048576 && type.objectFlags & 16777216) {
@@ -61979,10 +61979,10 @@ ${lanes.join("\n")}
             const flags = elementFlags[i];
             combinedFlags |= flags;
             if (!(combinedFlags & 12)) {
-              const property = createSymbol(4 | (flags & 2 ? 16777216 : 0), "" + i, readonly ? 8 : 0);
-              property.links.tupleLabelDeclaration = namedMemberDeclarations == null ? undefined : namedMemberDeclarations[i];
-              property.links.type = typeParameter;
-              properties.push(property);
+              const property2 = createSymbol(4 | (flags & 2 ? 16777216 : 0), "" + i, readonly ? 8 : 0);
+              property2.links.tupleLabelDeclaration = namedMemberDeclarations == null ? undefined : namedMemberDeclarations[i];
+              property2.links.type = typeParameter;
+              properties.push(property2);
             }
           }
         }
@@ -62995,8 +62995,8 @@ ${lanes.join("\n")}
                 diagnostics.add(createDiagnosticForNode(accessExpression, Diagnostics.Property_0_does_not_exist_on_type_1, indexType.value, typeToString(objectType)));
                 return undefinedType;
               } else if (indexType.flags & (8 | 4)) {
-                const types = map(objectType.properties, (property) => {
-                  return getTypeOfSymbol(property);
+                const types = map(objectType.properties, (property2) => {
+                  return getTypeOfSymbol(property2);
                 });
                 return getUnionType(append(types, undefinedType));
               }
@@ -64991,12 +64991,12 @@ ${lanes.join("\n")}
           return !!(entry & 1);
         }
         const targetEnumType = getTypeOfSymbol(targetSymbol);
-        for (const property of getPropertiesOfType(getTypeOfSymbol(sourceSymbol))) {
-          if (property.flags & 8) {
-            const targetProperty = getPropertyOfType(targetEnumType, property.escapedName);
+        for (const property2 of getPropertiesOfType(getTypeOfSymbol(sourceSymbol))) {
+          if (property2.flags & 8) {
+            const targetProperty = getPropertyOfType(targetEnumType, property2.escapedName);
             if (!targetProperty || !(targetProperty.flags & 8)) {
               if (errorReporter) {
-                errorReporter(Diagnostics.Property_0_is_missing_in_type_1, symbolName(property), typeToString(getDeclaredTypeOfSymbol(targetSymbol), undefined, 64));
+                errorReporter(Diagnostics.Property_0_is_missing_in_type_1, symbolName(property2), typeToString(getDeclaredTypeOfSymbol(targetSymbol), undefined, 64));
                 enumRelation.set(id, 2 | 4);
               } else {
                 enumRelation.set(id, 2);
@@ -67073,10 +67073,10 @@ ${lanes.join("\n")}
       function getDeclaringClass(prop) {
         return prop.parent && prop.parent.flags & 32 ? getDeclaredTypeOfSymbol(getParentOfSymbol(prop)) : undefined;
       }
-      function getTypeOfPropertyInBaseClass(property) {
-        const classType = getDeclaringClass(property);
+      function getTypeOfPropertyInBaseClass(property2) {
+        const classType = getDeclaringClass(property2);
         const baseClassType = classType && getBaseTypes(classType)[0];
-        return baseClassType && getTypeOfPropertyOfType(baseClassType, property.escapedName);
+        return baseClassType && getTypeOfPropertyOfType(baseClassType, property2.escapedName);
       }
       function isPropertyInClassDerivedFrom(prop, baseClass) {
         return forEachProperty2(prop, (sp) => {
@@ -67505,10 +67505,10 @@ ${lanes.join("\n")}
       }
       function transformTypeOfMembers(type, f) {
         const members = createSymbolTable();
-        for (const property of getPropertiesOfObjectType(type)) {
-          const original = getTypeOfSymbol(property);
+        for (const property2 of getPropertiesOfObjectType(type)) {
+          const original = getTypeOfSymbol(property2);
           const updated = f(original);
-          members.set(property.escapedName, updated === original ? property : createSymbolWithType(property, updated));
+          members.set(property2.escapedName, updated === original ? property2 : createSymbolWithType(property2, updated));
         }
         return members;
       }
@@ -73573,8 +73573,8 @@ ${lanes.join("\n")}
             return isValidPropertyAccessWithType(node, false, propertyName, getTypeFromTypeNode(node));
         }
       }
-      function isValidPropertyAccessForCompletions(node, type, property) {
-        return isPropertyAccessible(node, node.kind === 211 && node.expression.kind === 108, false, type, property);
+      function isValidPropertyAccessForCompletions(node, type, property2) {
+        return isPropertyAccessible(node, node.kind === 211 && node.expression.kind === 108, false, type, property2);
       }
       function isValidPropertyAccessWithType(node, isSuper, propertyName, type) {
         if (isTypeAny(type)) {
@@ -73583,15 +73583,15 @@ ${lanes.join("\n")}
         const prop = getPropertyOfType(type, propertyName);
         return !!prop && isPropertyAccessible(node, isSuper, false, type, prop);
       }
-      function isPropertyAccessible(node, isSuper, isWrite, containingType, property) {
+      function isPropertyAccessible(node, isSuper, isWrite, containingType, property2) {
         if (isTypeAny(containingType)) {
           return true;
         }
-        if (property.valueDeclaration && isPrivateIdentifierClassElementDeclaration(property.valueDeclaration)) {
-          const declClass = getContainingClass(property.valueDeclaration);
+        if (property2.valueDeclaration && isPrivateIdentifierClassElementDeclaration(property2.valueDeclaration)) {
+          const declClass = getContainingClass(property2.valueDeclaration);
           return !isOptionalChain(node) && !!findAncestor(node, (parent2) => parent2 === declClass);
         }
-        return checkPropertyAccessibilityAtLocation(node, isSuper, isWrite, containingType, property);
+        return checkPropertyAccessibilityAtLocation(node, isSuper, isWrite, containingType, property2);
       }
       function getForInVariableSymbol(node) {
         const initializer = node.initializer;
@@ -76688,27 +76688,27 @@ ${lanes.join("\n")}
       }
       function checkObjectLiteralDestructuringPropertyAssignment(node, objectLiteralType, propertyIndex, allProperties, rightIsThis = false) {
         const properties = node.properties;
-        const property = properties[propertyIndex];
-        if (property.kind === 303 || property.kind === 304) {
-          const name = property.name;
+        const property2 = properties[propertyIndex];
+        if (property2.kind === 303 || property2.kind === 304) {
+          const name = property2.name;
           const exprType = getLiteralTypeFromPropertyName(name);
           if (isTypeUsableAsPropertyName(exprType)) {
             const text = getPropertyNameFromType(exprType);
             const prop = getPropertyOfType(objectLiteralType, text);
             if (prop) {
-              markPropertyAsReferenced(prop, property, rightIsThis);
-              checkPropertyAccessibility(property, false, true, objectLiteralType, prop);
+              markPropertyAsReferenced(prop, property2, rightIsThis);
+              checkPropertyAccessibility(property2, false, true, objectLiteralType, prop);
             }
           }
           const elementType = getIndexedAccessType(objectLiteralType, exprType, 32, name);
-          const type = getFlowTypeOfDestructuring(property, elementType);
-          return checkDestructuringAssignment(property.kind === 304 ? property : property.initializer, type);
-        } else if (property.kind === 305) {
+          const type = getFlowTypeOfDestructuring(property2, elementType);
+          return checkDestructuringAssignment(property2.kind === 304 ? property2 : property2.initializer, type);
+        } else if (property2.kind === 305) {
           if (propertyIndex < properties.length - 1) {
-            error2(property, Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern);
+            error2(property2, Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern);
           } else {
             if (languageVersion < 99) {
-              checkExternalEmitHelpers(property, 4);
+              checkExternalEmitHelpers(property2, 4);
             }
             const nonRestNames = [];
             if (allProperties) {
@@ -76720,10 +76720,10 @@ ${lanes.join("\n")}
             }
             const type = getRestType(objectLiteralType, nonRestNames, objectLiteralType.symbol);
             checkGrammarForDisallowedTrailingComma(allProperties, Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma);
-            return checkDestructuringAssignment(property.expression, type);
+            return checkDestructuringAssignment(property2.expression, type);
           }
         } else {
-          error2(property, Diagnostics.Property_assignment_expected);
+          error2(property2, Diagnostics.Property_assignment_expected);
         }
       }
       function checkArrayLiteralAssignment(node, sourceType, checkMode) {
@@ -79983,10 +79983,10 @@ ${lanes.join("\n")}
             const exprType = getLiteralTypeFromPropertyName(name);
             if (isTypeUsableAsPropertyName(exprType)) {
               const nameText = getPropertyNameFromType(exprType);
-              const property = getPropertyOfType(parentType, nameText);
-              if (property) {
-                markPropertyAsReferenced(property, undefined, false);
-                checkPropertyAccessibility(node, !!parent2.initializer && parent2.initializer.kind === 108, false, parentType, property);
+              const property2 = getPropertyOfType(parentType, nameText);
+              if (property2) {
+                markPropertyAsReferenced(property2, undefined, false);
+                checkPropertyAccessibility(node, !!parent2.initializer && parent2.initializer.kind === 108, false, parentType, property2);
               }
             }
           }
@@ -87696,8 +87696,8 @@ ${lanes.join("\n")}
       }
       return { decorators: decorators5, parameters };
     }
-    function getAllDecoratorsOfProperty(property) {
-      const decorators5 = getDecorators(property);
+    function getAllDecoratorsOfProperty(property2) {
+      const decorators5 = getDecorators(property2);
       if (!some(decorators5)) {
         return;
       }
@@ -90695,7 +90695,7 @@ ${lanes.join("\n")}
         const instanceProperties = getProperties(node, false, false);
         let properties = instanceProperties;
         if (!useDefineForClassFields) {
-          properties = filter(properties, (property) => !!property.initializer || isPrivateIdentifier(property.name) || hasAccessorModifier(property));
+          properties = filter(properties, (property2) => !!property2.initializer || isPrivateIdentifier(property2.name) || hasAccessorModifier(property2));
         }
         const privateMethodsAndAccessors = getPrivateInstanceMethodsAndAccessors(node);
         const needsConstructorBody = some(properties) || some(privateMethodsAndAccessors);
@@ -90748,32 +90748,32 @@ ${lanes.join("\n")}
         return setTextRange(factory2.createBlock(setTextRange(factory2.createNodeArray(statements), constructor ? constructor.body.statements : node.members), multiLine), constructor ? constructor.body : undefined);
       }
       function addPropertyOrClassStaticBlockStatements(statements, properties, receiver) {
-        for (const property of properties) {
-          if (isStatic(property) && !shouldTransformPrivateElementsOrClassStaticBlocks) {
+        for (const property2 of properties) {
+          if (isStatic(property2) && !shouldTransformPrivateElementsOrClassStaticBlocks) {
             continue;
           }
-          const statement = transformPropertyOrClassStaticBlock(property, receiver);
+          const statement = transformPropertyOrClassStaticBlock(property2, receiver);
           if (!statement) {
             continue;
           }
           statements.push(statement);
         }
       }
-      function transformPropertyOrClassStaticBlock(property, receiver) {
-        const expression = isClassStaticBlockDeclaration(property) ? setCurrentClassElementAnd(property, transformClassStaticBlockDeclaration, property) : transformProperty(property, receiver);
+      function transformPropertyOrClassStaticBlock(property2, receiver) {
+        const expression = isClassStaticBlockDeclaration(property2) ? setCurrentClassElementAnd(property2, transformClassStaticBlockDeclaration, property2) : transformProperty(property2, receiver);
         if (!expression) {
           return;
         }
         const statement = factory2.createExpressionStatement(expression);
-        setOriginalNode(statement, property);
-        addEmitFlags(statement, getEmitFlags(property) & 3072);
-        setCommentRange(statement, property);
-        const propertyOriginalNode = getOriginalNode(property);
+        setOriginalNode(statement, property2);
+        addEmitFlags(statement, getEmitFlags(property2) & 3072);
+        setCommentRange(statement, property2);
+        const propertyOriginalNode = getOriginalNode(property2);
         if (isParameter(propertyOriginalNode)) {
           setSourceMapRange(statement, propertyOriginalNode);
           removeAllComments(statement);
         } else {
-          setSourceMapRange(statement, moveRangePastModifiers(property));
+          setSourceMapRange(statement, moveRangePastModifiers(property2));
         }
         setSyntheticLeadingComments(expression, undefined);
         setSyntheticTrailingComments(expression, undefined);
@@ -90784,50 +90784,50 @@ ${lanes.join("\n")}
       }
       function generateInitializedPropertyExpressionsOrClassStaticBlock(propertiesOrClassStaticBlocks, receiver) {
         const expressions = [];
-        for (const property of propertiesOrClassStaticBlocks) {
-          const expression = isClassStaticBlockDeclaration(property) ? setCurrentClassElementAnd(property, transformClassStaticBlockDeclaration, property) : setCurrentClassElementAnd(property, () => transformProperty(property, receiver), undefined);
+        for (const property2 of propertiesOrClassStaticBlocks) {
+          const expression = isClassStaticBlockDeclaration(property2) ? setCurrentClassElementAnd(property2, transformClassStaticBlockDeclaration, property2) : setCurrentClassElementAnd(property2, () => transformProperty(property2, receiver), undefined);
           if (!expression) {
             continue;
           }
           startOnNewLine(expression);
-          setOriginalNode(expression, property);
-          addEmitFlags(expression, getEmitFlags(property) & 3072);
-          setSourceMapRange(expression, moveRangePastModifiers(property));
-          setCommentRange(expression, property);
+          setOriginalNode(expression, property2);
+          addEmitFlags(expression, getEmitFlags(property2) & 3072);
+          setSourceMapRange(expression, moveRangePastModifiers(property2));
+          setCommentRange(expression, property2);
           expressions.push(expression);
         }
         return expressions;
       }
-      function transformProperty(property, receiver) {
+      function transformProperty(property2, receiver) {
         var _a;
         const savedCurrentClassElement = currentClassElement;
-        const transformed = transformPropertyWorker(property, receiver);
-        if (transformed && hasStaticModifier(property) && ((_a = lexicalEnvironment == null ? undefined : lexicalEnvironment.data) == null ? undefined : _a.facts)) {
-          setOriginalNode(transformed, property);
+        const transformed = transformPropertyWorker(property2, receiver);
+        if (transformed && hasStaticModifier(property2) && ((_a = lexicalEnvironment == null ? undefined : lexicalEnvironment.data) == null ? undefined : _a.facts)) {
+          setOriginalNode(transformed, property2);
           addEmitFlags(transformed, 4);
-          setSourceMapRange(transformed, getSourceMapRange(property.name));
-          lexicalEnvironmentMap.set(getOriginalNode(property), lexicalEnvironment);
+          setSourceMapRange(transformed, getSourceMapRange(property2.name));
+          lexicalEnvironmentMap.set(getOriginalNode(property2), lexicalEnvironment);
         }
         currentClassElement = savedCurrentClassElement;
         return transformed;
       }
-      function transformPropertyWorker(property, receiver) {
+      function transformPropertyWorker(property2, receiver) {
         const emitAssignment = !useDefineForClassFields;
-        if (isNamedEvaluation(property, isAnonymousClassNeedingAssignedName)) {
-          property = transformNamedEvaluation(context, property);
+        if (isNamedEvaluation(property2, isAnonymousClassNeedingAssignedName)) {
+          property2 = transformNamedEvaluation(context, property2);
         }
-        const propertyName = hasAccessorModifier(property) ? factory2.getGeneratedPrivateNameForNode(property.name) : isComputedPropertyName(property.name) && !isSimpleInlineableExpression(property.name.expression) ? factory2.updateComputedPropertyName(property.name, factory2.getGeneratedNameForNode(property.name)) : property.name;
-        if (hasStaticModifier(property)) {
-          currentClassElement = property;
+        const propertyName = hasAccessorModifier(property2) ? factory2.getGeneratedPrivateNameForNode(property2.name) : isComputedPropertyName(property2.name) && !isSimpleInlineableExpression(property2.name.expression) ? factory2.updateComputedPropertyName(property2.name, factory2.getGeneratedNameForNode(property2.name)) : property2.name;
+        if (hasStaticModifier(property2)) {
+          currentClassElement = property2;
         }
-        if (isPrivateIdentifier(propertyName) && shouldTransformClassElementToWeakMap(property)) {
+        if (isPrivateIdentifier(propertyName) && shouldTransformClassElementToWeakMap(property2)) {
           const privateIdentifierInfo = accessPrivateIdentifier2(propertyName);
           if (privateIdentifierInfo) {
             if (privateIdentifierInfo.kind === "f") {
               if (!privateIdentifierInfo.isStatic) {
-                return createPrivateInstanceFieldInitializer(factory2, receiver, visitNode(property.initializer, visitor, isExpression), privateIdentifierInfo.brandCheckIdentifier);
+                return createPrivateInstanceFieldInitializer(factory2, receiver, visitNode(property2.initializer, visitor, isExpression), privateIdentifierInfo.brandCheckIdentifier);
               } else {
-                return createPrivateStaticFieldInitializer(factory2, privateIdentifierInfo.variableName, visitNode(property.initializer, visitor, isExpression));
+                return createPrivateStaticFieldInitializer(factory2, privateIdentifierInfo.variableName, visitNode(property2.initializer, visitor, isExpression));
               }
             } else {
               return;
@@ -90836,14 +90836,14 @@ ${lanes.join("\n")}
             Debug.fail("Undeclared private name for property declaration.");
           }
         }
-        if ((isPrivateIdentifier(propertyName) || hasStaticModifier(property)) && !property.initializer) {
+        if ((isPrivateIdentifier(propertyName) || hasStaticModifier(property2)) && !property2.initializer) {
           return;
         }
-        const propertyOriginalNode = getOriginalNode(property);
+        const propertyOriginalNode = getOriginalNode(property2);
         if (hasSyntacticModifier(propertyOriginalNode, 256)) {
           return;
         }
-        let initializer = visitNode(property.initializer, visitor, isExpression);
+        let initializer = visitNode(property2.initializer, visitor, isExpression);
         if (isParameterPropertyDeclaration(propertyOriginalNode, propertyOriginalNode.parent) && isIdentifier(propertyName)) {
           const localName = factory2.cloneNode(propertyName);
           if (initializer) {
@@ -95353,7 +95353,7 @@ ${lanes.join("\n")}
           } else if (hex) {
             return utf16EncodeAsString(parseInt(hex, 16));
           } else {
-            const ch = entities.get(word);
+            const ch = entities2.get(word);
             return ch ? utf16EncodeAsString(ch) : match;
           }
         });
@@ -95389,11 +95389,11 @@ ${lanes.join("\n")}
         return node.dotDotDotToken ? factory2.createSpreadElement(expression) : expression;
       }
     }
-    var entities;
+    var entities2;
     var init_jsx = __esm2({
       "src/compiler/transformers/jsx.ts"() {
         init_ts2();
-        entities = new Map(Object.entries({
+        entities2 = new Map(Object.entries({
           quot: 34,
           amp: 38,
           apos: 39,
@@ -96854,8 +96854,8 @@ ${lanes.join("\n")}
         const properties = node.properties;
         let numInitialProperties = -1, hasComputed = false;
         for (let i = 0;i < properties.length; i++) {
-          const property = properties[i];
-          if (property.transformFlags & 1048576 && hierarchyFacts & 4 || (hasComputed = Debug.checkDefined(property.name).kind === 167)) {
+          const property2 = properties[i];
+          if (property2.transformFlags & 1048576 && hierarchyFacts & 4 || (hasComputed = Debug.checkDefined(property2.name).kind === 167)) {
             numInitialProperties = i;
             break;
           }
@@ -97239,23 +97239,23 @@ ${lanes.join("\n")}
         const properties = node.properties;
         const numProperties = properties.length;
         for (let i = start;i < numProperties; i++) {
-          const property = properties[i];
-          switch (property.kind) {
+          const property2 = properties[i];
+          switch (property2.kind) {
             case 177:
             case 178:
-              const accessors = getAllAccessorDeclarations(node.properties, property);
-              if (property === accessors.firstAccessor) {
+              const accessors = getAllAccessorDeclarations(node.properties, property2);
+              if (property2 === accessors.firstAccessor) {
                 expressions.push(transformAccessorsToExpression(receiver, accessors, node, !!node.multiLine));
               }
               break;
             case 174:
-              expressions.push(transformObjectLiteralMethodDeclarationToExpression(property, receiver, node, node.multiLine));
+              expressions.push(transformObjectLiteralMethodDeclarationToExpression(property2, receiver, node, node.multiLine));
               break;
             case 303:
-              expressions.push(transformPropertyAssignmentToExpression(property, receiver, node.multiLine));
+              expressions.push(transformPropertyAssignmentToExpression(property2, receiver, node.multiLine));
               break;
             case 304:
-              expressions.push(transformShorthandPropertyAssignmentToExpression(property, receiver, node.multiLine));
+              expressions.push(transformShorthandPropertyAssignmentToExpression(property2, receiver, node.multiLine));
               break;
             default:
               Debug.failBadSyntaxKind(node);
@@ -97263,17 +97263,17 @@ ${lanes.join("\n")}
           }
         }
       }
-      function transformPropertyAssignmentToExpression(property, receiver, startsOnNewLine) {
-        const expression = factory2.createAssignment(createMemberAccessForPropertyName(factory2, receiver, Debug.checkDefined(visitNode(property.name, visitor, isPropertyName))), Debug.checkDefined(visitNode(property.initializer, visitor, isExpression)));
-        setTextRange(expression, property);
+      function transformPropertyAssignmentToExpression(property2, receiver, startsOnNewLine) {
+        const expression = factory2.createAssignment(createMemberAccessForPropertyName(factory2, receiver, Debug.checkDefined(visitNode(property2.name, visitor, isPropertyName))), Debug.checkDefined(visitNode(property2.initializer, visitor, isExpression)));
+        setTextRange(expression, property2);
         if (startsOnNewLine) {
           startOnNewLine(expression);
         }
         return expression;
       }
-      function transformShorthandPropertyAssignmentToExpression(property, receiver, startsOnNewLine) {
-        const expression = factory2.createAssignment(createMemberAccessForPropertyName(factory2, receiver, Debug.checkDefined(visitNode(property.name, visitor, isPropertyName))), factory2.cloneNode(property.name));
-        setTextRange(expression, property);
+      function transformShorthandPropertyAssignmentToExpression(property2, receiver, startsOnNewLine) {
+        const expression = factory2.createAssignment(createMemberAccessForPropertyName(factory2, receiver, Debug.checkDefined(visitNode(property2.name, visitor, isPropertyName))), factory2.cloneNode(property2.name));
+        setTextRange(expression, property2);
         if (startsOnNewLine) {
           startOnNewLine(expression);
         }
@@ -98150,12 +98150,12 @@ ${lanes.join("\n")}
         const expressions = reduceLeft(properties, reduceProperty, [], numInitialProperties);
         expressions.push(multiLine ? startOnNewLine(setParent(setTextRange(factory2.cloneNode(temp), temp), temp.parent)) : temp);
         return factory2.inlineExpressions(expressions);
-        function reduceProperty(expressions2, property) {
-          if (containsYield(property) && expressions2.length > 0) {
+        function reduceProperty(expressions2, property2) {
+          if (containsYield(property2) && expressions2.length > 0) {
             emitStatement(factory2.createExpressionStatement(factory2.inlineExpressions(expressions2)));
             expressions2 = [];
           }
-          const expression = createExpressionForObjectLiteralElementLike(factory2, node, property, temp);
+          const expression = createExpressionForObjectLiteralElementLike(factory2, node, property2, temp);
           const visited = visitNode(expression, visitor, isExpression);
           if (visited) {
             if (multiLine) {
@@ -111458,7 +111458,7 @@ ${lanes.join("\n")}
             if (!referenceInfo)
               return;
             const { sourceFile, index } = referenceInfo;
-            const referencesSyntax = forEachTsConfigPropArray(sourceFile, "references", (property) => isArrayLiteralExpression(property.initializer) ? property.initializer : undefined);
+            const referencesSyntax = forEachTsConfigPropArray(sourceFile, "references", (property2) => isArrayLiteralExpression(property2.initializer) ? property2.initializer : undefined);
             return referencesSyntax && referencesSyntax.elements.length > index ? createDiagnosticForNodeInSourceFile(sourceFile, referencesSyntax.elements[index], reason.kind === 2 ? Diagnostics.File_is_output_from_referenced_project_specified_here : Diagnostics.File_is_source_from_referenced_project_specified_here) : undefined;
           case 8:
             if (!options.types)
@@ -111552,7 +111552,7 @@ ${lanes.join("\n")}
         return forEachOptionsSyntaxByName("paths", callback);
       }
       function getOptionsSyntaxByValue(name, value) {
-        return forEachOptionsSyntaxByName(name, (property) => isStringLiteral(property.initializer) && property.initializer.text === value ? property.initializer : undefined);
+        return forEachOptionsSyntaxByName(name, (property2) => isStringLiteral(property2.initializer) && property2.initializer.text === value ? property2.initializer : undefined);
       }
       function getOptionsSyntaxByArrayElementValue(name, value) {
         const compilerOptionsObjectLiteralSyntax = getCompilerOptionsObjectLiteralSyntax();
@@ -111565,7 +111565,7 @@ ${lanes.join("\n")}
         createDiagnosticForOption(false, option1, undefined, message, ...args);
       }
       function createDiagnosticForReference(sourceFile, index, message, ...args) {
-        const referencesSyntax = forEachTsConfigPropArray(sourceFile || options.configFile, "references", (property) => isArrayLiteralExpression(property.initializer) ? property.initializer : undefined);
+        const referencesSyntax = forEachTsConfigPropArray(sourceFile || options.configFile, "references", (property2) => isArrayLiteralExpression(property2.initializer) ? property2.initializer : undefined);
         if (referencesSyntax && referencesSyntax.elements.length > index) {
           programDiagnostics.add(createDiagnosticForNodeInSourceFile(sourceFile || options.configFile, referencesSyntax.elements[index], message, ...args));
         } else {
@@ -122417,31 +122417,31 @@ ${lanes.join("\n")}
       const jsonObjectLiteral = getTsConfigObjectLiteralExpression(configFile);
       if (!jsonObjectLiteral)
         return;
-      forEachProperty(jsonObjectLiteral, (property, propertyName) => {
+      forEachProperty(jsonObjectLiteral, (property2, propertyName) => {
         switch (propertyName) {
           case "files":
           case "include":
           case "exclude": {
-            const foundExactMatch = updatePaths(property);
-            if (foundExactMatch || propertyName !== "include" || !isArrayLiteralExpression(property.initializer))
+            const foundExactMatch = updatePaths(property2);
+            if (foundExactMatch || propertyName !== "include" || !isArrayLiteralExpression(property2.initializer))
               return;
-            const includes = mapDefined(property.initializer.elements, (e) => isStringLiteral(e) ? e.text : undefined);
+            const includes = mapDefined(property2.initializer.elements, (e) => isStringLiteral(e) ? e.text : undefined);
             if (includes.length === 0)
               return;
             const matchers = getFileMatcherPatterns(configDir, [], includes, useCaseSensitiveFileNames2, currentDirectory);
             if (getRegexFromPattern(Debug.checkDefined(matchers.includeFilePattern), useCaseSensitiveFileNames2).test(oldFileOrDirPath) && !getRegexFromPattern(Debug.checkDefined(matchers.includeFilePattern), useCaseSensitiveFileNames2).test(newFileOrDirPath)) {
-              changeTracker.insertNodeAfter(configFile, last(property.initializer.elements), factory.createStringLiteral(relativePath(newFileOrDirPath)));
+              changeTracker.insertNodeAfter(configFile, last(property2.initializer.elements), factory.createStringLiteral(relativePath(newFileOrDirPath)));
             }
             return;
           }
           case "compilerOptions":
-            forEachProperty(property.initializer, (property2, propertyName2) => {
+            forEachProperty(property2.initializer, (property22, propertyName2) => {
               const option = getOptionFromName(propertyName2);
               Debug.assert((option == null ? undefined : option.type) !== "listOrElement");
               if (option && (option.isFilePath || option.type === "list" && option.element.isFilePath)) {
-                updatePaths(property2);
+                updatePaths(property22);
               } else if (propertyName2 === "paths") {
-                forEachProperty(property2.initializer, (pathsProperty) => {
+                forEachProperty(property22.initializer, (pathsProperty) => {
                   if (!isArrayLiteralExpression(pathsProperty.initializer))
                     return;
                   for (const e of pathsProperty.initializer.elements) {
@@ -122453,8 +122453,8 @@ ${lanes.join("\n")}
             return;
         }
       });
-      function updatePaths(property) {
-        const elements = isArrayLiteralExpression(property.initializer) ? property.initializer.elements : [property.initializer];
+      function updatePaths(property2) {
+        const elements = isArrayLiteralExpression(property2.initializer) ? property2.initializer.elements : [property2.initializer];
         let foundExactMatch = false;
         for (const element of elements) {
           foundExactMatch = tryUpdateString(element) || foundExactMatch;
@@ -122533,7 +122533,7 @@ ${lanes.join("\n")}
       return resolved.resolvedModule && { newFileName: resolved.resolvedModule.resolvedFileName, updated: false };
       function tryChangeWithIgnoringPackageJsonExisting(oldFileName) {
         const newFileName = oldToNew(oldFileName);
-        return newFileName && find(sourceFiles, (src) => src.fileName === newFileName) ? tryChangeWithIgnoringPackageJson(oldFileName) : undefined;
+        return newFileName && find(sourceFiles, (src2) => src2.fileName === newFileName) ? tryChangeWithIgnoringPackageJson(oldFileName) : undefined;
       }
       function tryChangeWithIgnoringPackageJson(oldFileName) {
         return !endsWith(oldFileName, "/package.json") ? tryChange(oldFileName) : undefined;
@@ -122561,9 +122561,9 @@ ${lanes.join("\n")}
     function forEachProperty(objectLiteral, cb) {
       if (!isObjectLiteralExpression(objectLiteral))
         return;
-      for (const property of objectLiteral.properties) {
-        if (isPropertyAssignment(property) && isStringLiteral(property.name)) {
-          cb(property, property.name.text);
+      for (const property2 of objectLiteral.properties) {
+        if (isPropertyAssignment(property2) && isStringLiteral(property2.name)) {
+          cb(property2, property2.name.text);
         }
       }
     }
@@ -126968,12 +126968,12 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       const nonRestArguments = hasRestParameter2 ? functionArguments.slice(0, parameters.length - 1) : functionArguments;
       const properties = map(nonRestArguments, (arg, i) => {
         const parameterName = getParameterName(parameters[i]);
-        const property = createPropertyOrShorthandAssignment(parameterName, arg);
-        suppressLeadingAndTrailingTrivia(property.name);
-        if (isPropertyAssignment(property))
-          suppressLeadingAndTrailingTrivia(property.initializer);
-        copyComments(arg, property);
-        return property;
+        const property2 = createPropertyOrShorthandAssignment(parameterName, arg);
+        suppressLeadingAndTrailingTrivia(property2.name);
+        if (isPropertyAssignment(property2))
+          suppressLeadingAndTrailingTrivia(property2.initializer);
+        copyComments(arg, property2);
+        return property2;
       });
       if (hasRestParameter2 && functionArguments.length >= parameters.length) {
         const restArguments = functionArguments.slice(parameters.length - 1);
@@ -133855,12 +133855,12 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
               return true;
             return isFunctionLike(source);
           } else {
-            return every(_target.properties, (property) => {
-              if (isMethodDeclaration(property) || isGetOrSetAccessorDeclaration(property))
+            return every(_target.properties, (property2) => {
+              if (isMethodDeclaration(property2) || isGetOrSetAccessorDeclaration(property2))
                 return true;
-              if (isPropertyAssignment(property) && isFunctionExpression(property.initializer) && !!property.name)
+              if (isPropertyAssignment(property2) && isFunctionExpression(property2.initializer) && !!property2.name)
                 return true;
-              if (isConstructorAssignment(property))
+              if (isConstructorAssignment(property2))
                 return true;
               return false;
             });
@@ -133899,14 +133899,14 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             }
             return;
           } else if (isObjectLiteralExpression(assignmentExpr)) {
-            forEach(assignmentExpr.properties, (property) => {
-              if (isMethodDeclaration(property) || isGetOrSetAccessorDeclaration(property)) {
-                members.push(property);
+            forEach(assignmentExpr.properties, (property2) => {
+              if (isMethodDeclaration(property2) || isGetOrSetAccessorDeclaration(property2)) {
+                members.push(property2);
               }
-              if (isPropertyAssignment(property) && isFunctionExpression(property.initializer)) {
-                createFunctionLikeExpressionMember(members, property.initializer, property.name);
+              if (isPropertyAssignment(property2) && isFunctionExpression(property2.initializer)) {
+                createFunctionLikeExpressionMember(members, property2.initializer, property2.name);
               }
-              if (isConstructorAssignment(property))
+              if (isConstructorAssignment(property2))
                 return;
               return;
             });
@@ -136611,9 +136611,9 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           fixIds: [fixId18],
           getCodeActions(context) {
             const { sourceFile, span, preferences } = context;
-            const property = getPropertyAccessExpression(sourceFile, span.start);
-            const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange14(t, context.sourceFile, property, preferences));
-            return [createCodeFixAction(fixId18, changes, [Diagnostics.Use_element_access_for_0, property.name.text], fixId18, Diagnostics.Use_element_access_for_all_undeclared_properties)];
+            const property2 = getPropertyAccessExpression(sourceFile, span.start);
+            const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange14(t, context.sourceFile, property2, preferences));
+            return [createCodeFixAction(fixId18, changes, [Diagnostics.Use_element_access_for_0, property2.name.text], fixId18, Diagnostics.Use_element_access_for_all_undeclared_properties)];
           },
           getAllCodeActions: (context) => codeFixAll(context, errorCodes21, (changes, diag2) => doChange14(changes, diag2.file, getPropertyAccessExpression(diag2.file, diag2.start), context.preferences))
         });
@@ -137284,12 +137284,12 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         const staticInitialization = initializePropertyToUndefined(factory.createIdentifier(className), tokenName);
         changeTracker.insertNodeAfter(sourceFile, classDeclaration, staticInitialization);
       } else if (isPrivateIdentifier(token)) {
-        const property = factory.createPropertyDeclaration(undefined, tokenName, undefined, undefined, undefined);
+        const property2 = factory.createPropertyDeclaration(undefined, tokenName, undefined, undefined, undefined);
         const lastProp = getNodeToInsertPropertyAfter(classDeclaration);
         if (lastProp) {
-          changeTracker.insertNodeAfter(sourceFile, lastProp, property);
+          changeTracker.insertNodeAfter(sourceFile, lastProp, property2);
         } else {
-          changeTracker.insertMemberAtStart(sourceFile, classDeclaration, property);
+          changeTracker.insertMemberAtStart(sourceFile, classDeclaration, property2);
         }
       } else {
         const classConstructor = getFirstConstructorWithBody(classDeclaration);
@@ -137333,12 +137333,12 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     }
     function addPropertyDeclaration(changeTracker, sourceFile, node, tokenName, typeNode, modifierFlags) {
       const modifiers = modifierFlags ? factory.createNodeArray(factory.createModifiersFromModifierFlags(modifierFlags)) : undefined;
-      const property = isClassLike(node) ? factory.createPropertyDeclaration(modifiers, tokenName, undefined, typeNode, undefined) : factory.createPropertySignature(undefined, tokenName, undefined, typeNode);
+      const property2 = isClassLike(node) ? factory.createPropertyDeclaration(modifiers, tokenName, undefined, typeNode, undefined) : factory.createPropertySignature(undefined, tokenName, undefined, typeNode);
       const lastProp = getNodeToInsertPropertyAfter(node);
       if (lastProp) {
-        changeTracker.insertNodeAfter(sourceFile, lastProp, property);
+        changeTracker.insertNodeAfter(sourceFile, lastProp, property2);
       } else {
-        changeTracker.insertMemberAtStart(sourceFile, node, property);
+        changeTracker.insertMemberAtStart(sourceFile, node, property2);
       }
     }
     function getNodeToInsertPropertyAfter(node) {
@@ -138030,8 +138030,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           fixIds: [fixId29],
           getCodeActions(context) {
             const { sourceFile, span } = context;
-            const property = getProperty2(sourceFile, span.start);
-            const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange23(t, context.sourceFile, property));
+            const property2 = getProperty2(sourceFile, span.start);
+            const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange23(t, context.sourceFile, property2));
             return [createCodeFixAction(fixId29, changes, [Diagnostics.Change_0_to_1, "=", ":"], fixId29, [Diagnostics.Switch_each_misused_0_to_1, "=", ":"])];
           },
           getAllCodeActions: (context) => codeFixAll(context, errorCodes35, (changes, diag2) => doChange23(changes, diag2.file, getProperty2(diag2.file, diag2.start)))
@@ -140531,8 +140531,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       ], true));
     }
     function updatePropertyDeclaration(changeTracker, file, declaration, type, fieldName, modifiers) {
-      const property = factory.updatePropertyDeclaration(declaration, modifiers, fieldName, declaration.questionToken || declaration.exclamationToken, type, declaration.initializer);
-      changeTracker.replaceNode(file, declaration, property);
+      const property2 = factory.updatePropertyDeclaration(declaration, modifiers, fieldName, declaration.questionToken || declaration.exclamationToken, type, declaration.initializer);
+      changeTracker.replaceNode(file, declaration, property2);
     }
     function updatePropertyAssignmentDeclaration(changeTracker, file, declaration, fieldName) {
       let assignment = factory.updatePropertyAssignment(declaration, fieldName, declaration.initializer);
@@ -140704,8 +140704,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     }
     function addDefiniteAssignmentAssertion(changeTracker, propertyDeclarationSourceFile, propertyDeclaration) {
       suppressLeadingAndTrailingTrivia(propertyDeclaration);
-      const property = factory.updatePropertyDeclaration(propertyDeclaration, propertyDeclaration.modifiers, propertyDeclaration.name, factory.createToken(54), propertyDeclaration.type, propertyDeclaration.initializer);
-      changeTracker.replaceNode(propertyDeclarationSourceFile, propertyDeclaration, property);
+      const property2 = factory.updatePropertyDeclaration(propertyDeclaration, propertyDeclaration.modifiers, propertyDeclaration.name, factory.createToken(54), propertyDeclaration.type, propertyDeclaration.initializer);
+      changeTracker.replaceNode(propertyDeclarationSourceFile, propertyDeclaration, property2);
     }
     function getActionForAddMissingUndefinedType(context, info) {
       const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => addUndefinedType(t, context.sourceFile, info));
@@ -140733,8 +140733,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     }
     function addInitializer(changeTracker, propertyDeclarationSourceFile, propertyDeclaration, initializer) {
       suppressLeadingAndTrailingTrivia(propertyDeclaration);
-      const property = factory.updatePropertyDeclaration(propertyDeclaration, propertyDeclaration.modifiers, propertyDeclaration.name, propertyDeclaration.questionToken, propertyDeclaration.type, initializer);
-      changeTracker.replaceNode(propertyDeclarationSourceFile, propertyDeclaration, property);
+      const property2 = factory.updatePropertyDeclaration(propertyDeclaration, propertyDeclaration.modifiers, propertyDeclaration.name, propertyDeclaration.questionToken, propertyDeclaration.type, initializer);
+      changeTracker.replaceNode(propertyDeclarationSourceFile, propertyDeclaration, property2);
     }
     function getInitializer(checker, propertyDeclaration) {
       return getDefaultValueFromType(checker, checker.getTypeFromTypeNode(propertyDeclaration.type));
@@ -144099,8 +144099,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         const type = symbol && typeChecker.getTypeOfSymbolAtLocation(symbol, expression);
         const properties = type && type.properties;
         if (properties) {
-          properties.forEach((property) => {
-            membersDeclaredBySpreadAssignment.add(property.name);
+          properties.forEach((property2) => {
+            membersDeclaredBySpreadAssignment.add(property2.name);
           });
         }
       }
@@ -158379,9 +158379,9 @@ var require_cjs = __commonJS((exports) => {
           }
           case "[":
             clearStateChar();
-            const [src, needUflag, consumed, magic] = (0, brace_expressions_js_1.parseClass)(pattern, i);
+            const [src2, needUflag, consumed, magic] = (0, brace_expressions_js_1.parseClass)(pattern, i);
             if (consumed) {
-              re += src;
+              re += src2;
               uflag = uflag || needUflag;
               i += consumed - 1;
               hasMagic = hasMagic || magic;
@@ -200336,15 +200336,15 @@ var require_ts_morph = __commonJS((exports) => {
       return this._context.project;
     }
     getNodeProperty(propertyName) {
-      const property = this.compilerNode[propertyName];
-      if (property == null)
+      const property2 = this.compilerNode[propertyName];
+      if (property2 == null)
         return;
-      else if (property instanceof Array)
-        return property.map((p) => isNode(p) ? this._getNodeFromCompilerNode(p) : p);
-      else if (isNode(property))
-        return this._getNodeFromCompilerNode(property);
+      else if (property2 instanceof Array)
+        return property2.map((p) => isNode(p) ? this._getNodeFromCompilerNode(p) : p);
+      else if (isNode(property2))
+        return this._getNodeFromCompilerNode(property2);
       else
-        return property;
+        return property2;
       function isNode(value) {
         return typeof value.kind === "number" && typeof value.pos === "number" && typeof value.end === "number";
       }
@@ -207545,7 +207545,7 @@ var require_ts_morph = __commonJS((exports) => {
         kind: exports.StructureKind.Class,
         ctors: this.getConstructors().filter((ctor) => isAmbient || !ctor.isOverload()).map((ctor) => ctor.getStructure()),
         methods: this.getMethods().filter((method) => isAmbient || !method.isOverload()).map((method) => method.getStructure()),
-        properties: this.getProperties().map((property) => property.getStructure()),
+        properties: this.getProperties().map((property2) => property2.getStructure()),
         extends: getExtends ? getExtends.getText() : undefined,
         getAccessors: this.getGetAccessors().map((getAccessor) => getAccessor.getStructure()),
         setAccessors: this.getSetAccessors().map((accessor) => accessor.getStructure())
@@ -213885,7 +213885,7 @@ var require_ts_morph = __commonJS((exports) => {
   exports.setScopeForNode = setScopeForNode;
 });
 
-// /export/htdocs/p/framework/node_modules/postgres-array/index.js
+// /export/htdocs/p/framework/node_modules/pg/node_modules/pg-types/node_modules/postgres-array/index.js
 var require_postgres_array = __commonJS((exports) => {
   var identity = function(value) {
     return value;
@@ -213981,7 +213981,7 @@ var require_postgres_array = __commonJS((exports) => {
   }
 });
 
-// /export/htdocs/p/framework/node_modules/pg-types/lib/arrayParser.js
+// /export/htdocs/p/framework/node_modules/pg/node_modules/pg-types/lib/arrayParser.js
 var require_arrayParser = __commonJS((exports, module) => {
   var array = require_postgres_array();
   module.exports = {
@@ -213995,7 +213995,7 @@ var require_arrayParser = __commonJS((exports, module) => {
   };
 });
 
-// /export/htdocs/p/framework/node_modules/postgres-date/index.js
+// /export/htdocs/p/framework/node_modules/pg/node_modules/pg-types/node_modules/postgres-date/index.js
 var require_postgres_date = __commonJS((exports, module) => {
   var getDate = function(isoDate) {
     var matches = DATE.exec(isoDate);
@@ -214097,7 +214097,7 @@ var require_mutable = __commonJS((exports, module) => {
   var hasOwnProperty = Object.prototype.hasOwnProperty;
 });
 
-// /export/htdocs/p/framework/node_modules/postgres-interval/index.js
+// /export/htdocs/p/framework/node_modules/pg/node_modules/pg-types/node_modules/postgres-interval/index.js
 var require_postgres_interval = __commonJS((exports, module) => {
   var PostgresInterval = function(raw) {
     if (!(this instanceof PostgresInterval)) {
@@ -214114,18 +214114,18 @@ var require_postgres_interval = __commonJS((exports, module) => {
       return {};
     var matches = INTERVAL.exec(interval);
     var isNegative = matches[8] === "-";
-    return Object.keys(positions).reduce(function(parsed, property2) {
-      var position = positions[property2];
+    return Object.keys(positions).reduce(function(parsed, property3) {
+      var position = positions[property3];
       var value = matches[position];
       if (!value)
         return parsed;
-      value = property2 === "milliseconds" ? parseMilliseconds(value) : parseInt(value, 10);
+      value = property3 === "milliseconds" ? parseMilliseconds(value) : parseInt(value, 10);
       if (!value)
         return parsed;
-      if (isNegative && ~negatives.indexOf(property2)) {
+      if (isNegative && ~negatives.indexOf(property3)) {
         value *= -1;
       }
-      parsed[property2] = value;
+      parsed[property3] = value;
       return parsed;
     }, {});
   };
@@ -214139,12 +214139,12 @@ var require_postgres_interval = __commonJS((exports, module) => {
     }
     if (filtered.length === 0)
       return "0";
-    return filtered.map(function(property2) {
-      var value = this[property2] || 0;
-      if (property2 === "seconds" && this.milliseconds) {
+    return filtered.map(function(property3) {
+      var value = this[property3] || 0;
+      if (property3 === "seconds" && this.milliseconds) {
         value = (value + this.milliseconds / 1000).toFixed(6).replace(/\.?0+$/, "");
       }
-      return value + " " + property2;
+      return value + " " + property3;
     }, this).join(" ");
   };
   var propertiesISOEquivalent = {
@@ -214161,12 +214161,12 @@ var require_postgres_interval = __commonJS((exports, module) => {
     var datePart = dateProperties.map(buildProperty, this).join("");
     var timePart = timeProperties.map(buildProperty, this).join("");
     return "P" + datePart + "T" + timePart;
-    function buildProperty(property2) {
-      var value = this[property2] || 0;
-      if (property2 === "seconds" && this.milliseconds) {
+    function buildProperty(property3) {
+      var value = this[property3] || 0;
+      if (property3 === "seconds" && this.milliseconds) {
         value = (value + this.milliseconds / 1000).toFixed(6).replace(/0+$/, "");
       }
-      return value + propertiesISOEquivalent[property2];
+      return value + propertiesISOEquivalent[property3];
     }
   };
   var NUMBER = "([+-]?\\d+)";
@@ -214189,7 +214189,7 @@ var require_postgres_interval = __commonJS((exports, module) => {
   var negatives = ["hours", "minutes", "seconds", "milliseconds"];
 });
 
-// /export/htdocs/p/framework/node_modules/postgres-bytea/index.js
+// /export/htdocs/p/framework/node_modules/pg/node_modules/pg-types/node_modules/postgres-bytea/index.js
 var require_postgres_bytea = __commonJS((exports, module) => {
   module.exports = function parseBytea(input) {
     if (/^\\x/.test(input)) {
@@ -214221,7 +214221,7 @@ var require_postgres_bytea = __commonJS((exports, module) => {
   };
 });
 
-// /export/htdocs/p/framework/node_modules/pg-types/lib/textParsers.js
+// /export/htdocs/p/framework/node_modules/pg/node_modules/pg-types/lib/textParsers.js
 var require_textParsers = __commonJS((exports, module) => {
   var allowNull = function(fn) {
     return function nullAllowed(value) {
@@ -214501,7 +214501,7 @@ var require_pg_int8 = __commonJS((exports, module) => {
   module.exports = readInt8;
 });
 
-// /export/htdocs/p/framework/node_modules/pg-types/lib/binaryParsers.js
+// /export/htdocs/p/framework/node_modules/pg/node_modules/pg-types/lib/binaryParsers.js
 var require_binaryParsers = __commonJS((exports, module) => {
   var parseInt64 = require_pg_int8();
   var parseBits = function(data, bits, offset, invert, callback) {
@@ -214700,7 +214700,7 @@ var require_binaryParsers = __commonJS((exports, module) => {
   };
 });
 
-// /export/htdocs/p/framework/node_modules/pg-types/lib/builtins.js
+// /export/htdocs/p/framework/node_modules/pg/node_modules/pg-types/lib/builtins.js
 var require_builtins = __commonJS((exports, module) => {
   module.exports = {
     BOOL: 16,
@@ -214766,7 +214766,7 @@ var require_builtins = __commonJS((exports, module) => {
   };
 });
 
-// /export/htdocs/p/framework/node_modules/pg-types/index.js
+// /export/htdocs/p/framework/node_modules/pg/node_modules/pg-types/index.js
 var require_pg_types = __commonJS((exports) => {
   var noParse = function(val) {
     return String(val);
@@ -215565,12 +215565,12 @@ var require_result = __commonJS((exports, module) => {
 var require_query = __commonJS((exports, module) => {
   var { EventEmitter } = import.meta.require("events");
   var Result = require_result();
-  var utils8 = require_utils5();
+  var utils10 = require_utils5();
 
   class Query3 extends EventEmitter {
     constructor(config, values, callback) {
       super();
-      config = utils8.normalizeQueryConfig(config, values, callback);
+      config = utils10.normalizeQueryConfig(config, values, callback);
       this.text = config.text;
       this.values = config.values;
       this.rows = config.rows;
@@ -215721,7 +215721,7 @@ var require_query = __commonJS((exports, module) => {
           statement: this.name,
           values: this.values,
           binary: this.binary,
-          valueMapper: utils8.prepareValue
+          valueMapper: utils10.prepareValue
         });
       } catch (err) {
         this.handleError(err, connection);
@@ -217025,7 +217025,7 @@ var require_lib = __commonJS((exports, module) => {
 // /export/htdocs/p/framework/node_modules/pg/lib/client.js
 var require_client = __commonJS((exports, module) => {
   var EventEmitter = import.meta.require("events").EventEmitter;
-  var utils8 = require_utils5();
+  var utils10 = require_utils5();
   var sasl = require_sasl();
   var TypeOverrides = require_type_overrides();
   var ConnectionParameters = require_connection_parameters();
@@ -217391,10 +217391,10 @@ var require_client = __commonJS((exports, module) => {
       return this._types.getTypeParser(oid, format);
     }
     escapeIdentifier(str) {
-      return utils8.escapeIdentifier(str);
+      return utils10.escapeIdentifier(str);
     }
     escapeLiteral(str) {
-      return utils8.escapeLiteral(str);
+      return utils10.escapeLiteral(str);
     }
     _pulseQueryQueue() {
       if (this.readyForQuery === true) {
@@ -217896,10 +217896,10 @@ var require_pg_pool = __commonJS((exports, module) => {
 var require_query2 = __commonJS((exports, module) => {
   var EventEmitter = import.meta.require("events").EventEmitter;
   var util = import.meta.require("util");
-  var utils8 = require_utils5();
+  var utils10 = require_utils5();
   var NativeQuery = module.exports = function(config, values, callback) {
     EventEmitter.call(this);
-    config = utils8.normalizeQueryConfig(config, values, callback);
+    config = utils10.normalizeQueryConfig(config, values, callback);
     this.text = config.text;
     this.values = config.values;
     this.name = config.name;
@@ -217998,7 +217998,7 @@ var require_query2 = __commonJS((exports, module) => {
         console.error("You supplied %s (%s)", this.name, this.name.length);
         console.error("This can cause conflicts and silent errors executing queries");
       }
-      var values = (this.values || []).map(utils8.prepareValue);
+      var values = (this.values || []).map(utils10.prepareValue);
       if (client.namedQueries[this.name]) {
         if (this.text && client.namedQueries[this.name] !== this.text) {
           const err = new Error(`Prepared statements must be unique - '${this.name}' was used for a different statement`);
@@ -218017,7 +218017,7 @@ var require_query2 = __commonJS((exports, module) => {
         const err = new Error("Query values must be an array");
         return after(err);
       }
-      var vals = this.values.map(utils8.prepareValue);
+      var vals = this.values.map(utils10.prepareValue);
       client.native.query(this.text, vals, after);
     } else {
       client.native.query(this.text, after);
@@ -218318,6 +218318,12 @@ var require_lib2 = __commonJS((exports, module) => {
   }
 });
 
+// ../../node_modul
+var ENTITIES = "cheetah:entities";
+var PROPERTIES = "cheetah:properties";
+var PROPERTIES_METADATA = "cheetah:properties:metadata";
+var PROPERTIES_RELATIONS = "cheetah:properties:relations";
+
 // /export/htdocs/p/framework/node_modules/reflect-metadata/Reflect.js
 /*! *****************************************************************************
 Copyright (C) Microsoft. All rights reserved.
@@ -219094,6 +219100,7 @@ class Provider {
     this.type = ProviderType2.PROVIDER;
     this.deps = [];
     this.scope = ProviderScope2.SINGLETON;
+    this.children = [];
     this.provide = token;
     this.useClass = token;
     Object.assign(this, options);
@@ -219130,6 +219137,9 @@ class Provider {
   clone() {
     return new (classOf(this))(this._provide, this);
   }
+  isChild() {
+    return !!this.parent;
+  }
 }
 
 // /export/htdocs/p/framework/packages/core/dist/commons/registries/ProviderControl.js
@@ -219485,6 +219495,9 @@ var generateGlobTasksSync = normalizeArgumentsSync(generateTasksSync);
 function Controller(options) {
   return (target) => {
     registerController({ provide: target, ...options });
+    options?.children && options.children.forEach((child) => {
+      registerController({ provide: child, parent: target });
+    });
   };
 }
 // /export/htdocs/p/framework/packages/core/dist/commons/decorators/http.decorators.js
@@ -219514,7 +219527,7 @@ var Body = createParamDecorator((context, data) => data ? context.body[data] : c
 var Query = createParamDecorator((context, data) => data ? context.query[data] : context.query || {});
 var Param = createParamDecorator((context, data) => data ? context.param[data] : null);
 var Req = createParamDecorator((context) => context.req);
-var Headers = createParamDecorator((context, data) => data ? context.headers.get(data) : context.headers || {});
+var Headers = createParamDecorator((context, data) => data ? context.headers[data] : context.headers || {});
 var Locals = createParamDecorator((context) => context.locals || {});
 var Get = createMethodDecorator("GET");
 var Post = createMethodDecorator("POST");
@@ -221445,7 +221458,7 @@ var InjectorService = InjectorService_1 = class InjectorService2 {
   resolveControllers() {
     if (!this.settings)
       return {};
-    const controllers = GlobalProvider.getByType(ProviderType2.CONTROLLER);
+    const controllers = GlobalProvider.getByType(ProviderType2.CONTROLLER).filter((controller2) => !controller2.isChild());
     let hydrateRoute = new Map;
     for (const controller2 of controllers) {
       let routes = Metadata.get(CONTROLLER_ROUTES, controller2.token);
@@ -221477,11 +221490,68 @@ var InjectorService = InjectorService_1 = class InjectorService2 {
           }))
         ]);
       }
+      if (controller2.children) {
+        const childrenRoutes = this.resolveChildrenRoutes(controller2.path ?? "", controller2.children, controllerMiddleware);
+        childrenRoutes.forEach((route) => {
+          hydrateRoute.set(route.method.toLowerCase(), [
+            ...hydrateRoute.get(route.method.toLowerCase()) || [],
+            route
+          ]);
+        });
+      }
     }
     hydrateRoute.forEach((method) => {
       method.forEach((route) => this.router.add(route.method.toLowerCase(), route.path, route));
     });
   }
+  resolveChildrenRoutes(parentPath, children, parentMiddlewares) {
+    let childrenRoutes = [];
+    for (const childController of children) {
+      let controller2 = GlobalProvider.get(childController);
+      if (!controller2)
+        throw new Error(`Child ${childController} not is an controller. Please, check the providers configuration.`);
+      let childRoutes = Metadata.get(CONTROLLER_ROUTES, controller2.token);
+      const childMiddlewares = Metadata.get(CONTROLLER_MIDDLEWARES, controller2.token) || [];
+      if (childRoutes.length === 0)
+        continue;
+      if (parentPath) {
+        childRoutes = childRoutes.map((route) => {
+          let controllerPath = controller2?.path ?? "";
+          if (controllerPath.endsWith("/")) {
+            controllerPath = controller2.path.slice(0, -1);
+          }
+          if (!controllerPath.startsWith("/")) {
+            controllerPath = `/${controller2.path}`;
+          }
+          route.path = `${parentPath}${controllerPath ?? ""}${route.path}`;
+          if (route.path.endsWith("/")) {
+            route.path = route.path.slice(0, -1);
+          }
+          if (!route.path.startsWith("/")) {
+            route.path = `/${route.path}`;
+          }
+          return route;
+        });
+      }
+      for (const method of Object.keys(HttpMethod).map((key) => HttpMethod[key])) {
+        if (!childRoutes.some((route) => route.method.toLowerCase() === method))
+          continue;
+        childrenRoutes = [
+          ...childrenRoutes,
+          ...childRoutes.filter((route) => route.method.toLowerCase() === method).map((route) => ({
+            ...route,
+            provider: controller2.token,
+            route,
+            middlewares: [...parentMiddlewares, ...childMiddlewares, ...Metadata.get(ROUTE_MIDDLEWARES, controller2.token, route.methodName) || []]
+          }))
+        ];
+      }
+      if (controller2.children) {
+        childrenRoutes = [...childrenRoutes, ...this.resolveChildrenRoutes(controller2.path, controller2.children, childMiddlewares)];
+      }
+    }
+    return childrenRoutes;
+  }
   ensureProvider(token) {
     if (!this.container.has(token) && GlobalProvider.has(token)) {
       this.container.addProvider(token);
@@ -221716,7 +221786,7 @@ class LocalsContainer extends Map {
 var DESIGN_PARAM_TYPES = "design:paramtypes";
 var DESIGN_TYPE = "design:type";
 var DESIGN_RETURN_TYPE = "design:returntype";
-var PROPERTIES = new Map;
+var PROPERTIES2 = new Map;
 
 class Metadata {
   static get(key, target, propertyKey) {
@@ -221754,11 +221824,11 @@ class Metadata {
     return this.set(DESIGN_PARAM_TYPES, value, target.prototype, propertyKey);
   }
   static set(key, value, target, propertyKey) {
-    const targets = PROPERTIES.has(key) ? PROPERTIES.get(key) || [] : [];
+    const targets = PROPERTIES2.has(key) ? PROPERTIES2.get(key) || [] : [];
     const classConstructor = classOf(target);
     if (targets.indexOf(classConstructor) === -1) {
       targets.push(classConstructor);
-      PROPERTIES.set(key, targets);
+      PROPERTIES2.set(key, targets);
     }
     Reflect.defineMetadata(key, value, classOf(target), propertyKey);
   }
@@ -221772,7 +221842,7 @@ class Metadata {
     return Reflect.getMetadata(ROUTE_PARAM, target.constructor, propertyKey);
   }
 }
-Metadata.getTargetsFromPropertyKey = (metadataKey) => PROPERTIES.has(metadataKey) ? PROPERTIES.get(metadataKey) || [] : [];
+Metadata.getTargetsFromPropertyKey = (metadataKey) => PROPERTIES2.has(metadataKey) ? PROPERTIES2.get(metadataKey) || [] : [];
 // /export/htdocs/p/framework/packages/core/dist/domain/http-method.js
 var HttpMethod;
 (function(HttpMethod2) {
@@ -221879,6 +221949,68 @@ class HttpException {
 // /export/htdocs/p/framework/packages/core/dist/Cheetah.js
 import process3 from "process";
 var parseUrl2 = require_parseurl_fast();
+
+class Cheetah {
+  constructor(config = {}) {
+    this.config = config;
+    this.router = new memoirist_default;
+    this.injector = createInjector();
+    this.fetch = (request, server) => this.fetcher(request, server);
+    this.catcher = (error) => {
+      if (error instanceof HttpException) {
+        return new Response(JSON.stringify({
+          message: error.getResponse(),
+          statusCode: error.getStatus()
+        }), {
+          status: error.statusCode,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+      return new Response(error.message, { status: 500 });
+    };
+  }
+  use(plugin) {
+    if (!this.config.providers) {
+      this.config.providers = [];
+    }
+    for (const provider4 of plugin.config.exports || []) {
+      this.config.providers.push(provider4);
+    }
+    return this;
+  }
+  useLogger(provider4) {
+    registerProvider({ provide: LoggerService, useClass: provider4 });
+    return this;
+  }
+  async listen(port = 3000) {
+    process3.on("SIGTERM", () => this.injector.callHook(EventType.OnApplicationShutdown));
+    this.injector.loadModule(createContainer(), this.config, this.router);
+    this.createHttpServer(port);
+  }
+  getInjector() {
+    return this.injector;
+  }
+  createHttpServer(port) {
+    this.server = Bun.serve({ port, fetch: this.fetch, error: this.catcher });
+    console.log(`Server running on port ${port}`);
+  }
+  async fetcher(request, server) {
+    const urlParsed = parseUrl2(request);
+    const context = await Context.createFromRequest(urlParsed, request, server);
+    this.injector.callHook(EventType.OnRequest, { context });
+    const local = new LocalsContainer;
+    const route = this.router.find(request.method.toLowerCase(), urlParsed.path);
+    if (!route) {
+      throw new HttpException("Method not allowed", 404);
+    }
+    context.param = route.params;
+    local.set(Context, context);
+    return RouteExecutor.executeRoute(route.store, this.injector, context, local);
+  }
+  close(closeActiveConnections = false) {
+    this.server.stop(closeActiveConnections);
+  }
+}
 // /export/htdocs/p/framework/packages/core/dist/events/on-event.js
 var EventType;
 (function(EventType2) {
@@ -222945,7 +223077,7 @@ Context4 = Context_12 = __decorate6([
 var DESIGN_PARAM_TYPES2 = "design:paramtypes";
 var DESIGN_TYPE2 = "design:type";
 var DESIGN_RETURN_TYPE2 = "design:returntype";
-var PROPERTIES2 = new Map;
+var PROPERTIES3 = new Map;
 
 class Metadata3 {
   static get(key, target, propertyKey) {
@@ -222983,11 +223115,11 @@ class Metadata3 {
     return this.set(DESIGN_PARAM_TYPES2, value, target.prototype, propertyKey);
   }
   static set(key, value, target, propertyKey) {
-    const targets = PROPERTIES2.has(key) ? PROPERTIES2.get(key) || [] : [];
+    const targets = PROPERTIES3.has(key) ? PROPERTIES3.get(key) || [] : [];
     const classConstructor = classOf(target);
     if (targets.indexOf(classConstructor) === -1) {
       targets.push(classConstructor);
-      PROPERTIES2.set(key, targets);
+      PROPERTIES3.set(key, targets);
     }
     Reflect.defineMetadata(key, value, classOf(target), propertyKey);
   }
@@ -223001,7 +223133,7 @@ class Metadata3 {
     return Reflect.getMetadata(ROUTE_PARAM, target.constructor, propertyKey);
   }
 }
-Metadata3.getTargetsFromPropertyKey = (metadataKey) => PROPERTIES2.has(metadataKey) ? PROPERTIES2.get(metadataKey) || [] : [];
+Metadata3.getTargetsFromPropertyKey = (metadataKey) => PROPERTIES3.has(metadataKey) ? PROPERTIES3.get(metadataKey) || [] : [];
 // ../../node_modules/balanced-match/index.jsodules/minimat
 var HttpMethod2;
 (function(HttpMethod3) {
@@ -223087,68 +223219,6 @@ var RouteExecutor4 = new Router2;
 // ../../node_modules/balanced-match/index.jsodu
 import process4 from "process";
 var parseUrl4 = require_parseurl_fast();
-
-class Cheetah2 {
-  constructor(config = {}) {
-    this.config = config;
-    this.router = new memoirist_default2;
-    this.injector = createInjector();
-    this.fetch = (request, server) => this.fetcher(request, server);
-    this.catcher = (error) => {
-      if (error instanceof HttpException) {
-        return new Response(JSON.stringify({
-          message: error.getResponse(),
-          statusCode: error.getStatus()
-        }), {
-          status: error.statusCode,
-          headers: { "Content-Type": "application/json" }
-        });
-      }
-      return new Response(error.message, { status: 500 });
-    };
-  }
-  use(plugin) {
-    if (!this.config.providers) {
-      this.config.providers = [];
-    }
-    for (const provider7 of plugin.config.exports || []) {
-      this.config.providers.push(provider7);
-    }
-    return this;
-  }
-  useLogger(provider7) {
-    registerProvider({ provide: LoggerService, useClass: provider7 });
-    return this;
-  }
-  async listen(port = 3000) {
-    process4.on("SIGTERM", () => this.injector.callHook(EventType.OnApplicationShutdown));
-    this.injector.loadModule(createContainer(), this.config, this.router);
-    this.createHttpServer(port);
-  }
-  getInjector() {
-    return this.injector;
-  }
-  createHttpServer(port) {
-    this.server = Bun.serve({ port, fetch: this.fetch, error: this.catcher });
-    console.log(`Server running on port ${port}`);
-  }
-  async fetcher(request, server) {
-    const urlParsed = parseUrl4(request);
-    const context = await Context.createFromRequest(urlParsed, request, server);
-    this.injector.callHook(EventType.OnRequest, { context });
-    const local = new LocalsContainer;
-    const route = this.router.find(request.method.toLowerCase(), urlParsed.path);
-    if (!route) {
-      throw new HttpException("Method not allowed", 404);
-    }
-    context.param = route.params;
-    local.set(Context, context);
-    return RouteExecutor4.executeRoute(route.store, this.injector, context, local);
-  }
-  close(closeActiveConnections = false) {
-    this.server.stop(closeActiveConnections);
-  }
-}
 // ../../node_modules/balanced-match/index.jsodules/mini
 var EventType2;
 (function(EventType3) {
@@ -223231,6 +223301,14 @@ LoggerService3 = __decorate8([
   Service(),
   __metadata6("design:paramtypes", [InjectorService])
 ], LoggerService3);
+// ../../node_modules/balanced-match/
+function Entity(options) {
+  return (target) => {
+    const entities = Metadata3.get(ENTITIES, Reflect) || [];
+    entities.push({ target, options });
+    Metadata3.set(ENTITIES, entities, Reflect);
+  };
+}
 // ../../node_m
 function getDefaultLength(type) {
   if (type === "String") {
@@ -223248,6 +223326,63 @@ function getDefaultLength(type) {
   return 255;
 }
 
+// ../../node_modules/balanced-match/in
+function Property(options) {
+  return (target, propertyKey) => {
+    const properties = Metadata.get(PROPERTIES, target.constructor) || [];
+    const type = Metadata.getType(target, propertyKey);
+    const length = options && options.length || getDefaultLength(type.name);
+    options = { length, ...options };
+    properties.push({ propertyKey, options });
+    Metadata.set(PROPERTIES, properties, target.constructor);
+    if (options.isPrimary) {
+      const indexes = Metadata.get("indexes", target.constructor) || [];
+      indexes.push({ name: `[TABLE]_pkey`, properties: [propertyKey] });
+      Metadata.set("indexes", indexes, target.constructor);
+    }
+    properties.forEach((property) => {
+      const types = Metadata.get(PROPERTIES_METADATA, target.constructor) || {};
+      const type2 = Metadata.getType(target, property.propertyKey);
+      types[property.propertyKey] = { type: type2, options: property.options };
+      Metadata.set(PROPERTIES_METADATA, types, target.constructor);
+    });
+  };
+}
+// ../../node_modules/balanced-match/index
+function PrimaryKey(options) {
+  const isPrimary = true;
+  return Property({ ...options, isPrimary, unique: true });
+}
+// ../../node_modules/balanced-match/in
+function OneToMany(entity, fkKey) {
+  return (target, propertyKey) => {
+    const existing = Metadata.get(PROPERTIES_RELATIONS, target.constructor) || [];
+    existing.push({ relation: "one-to-many", propertyKey, isRelation: true, entity, fkKey, type: Metadata.getType(target, propertyKey) });
+    Metadata.set(PROPERTIES_RELATIONS, existing, target.constructor);
+  };
+}
+function ManyToOne(entity) {
+  return (target, propertyKey) => {
+    const existing = Metadata.get(PROPERTIES_RELATIONS, target.constructor) || [];
+    existing.push({ relation: "many-to-one", propertyKey, isRelation: true, entity, type: Metadata.getType(target, propertyKey) });
+    Metadata.set(PROPERTIES_RELATIONS, existing, target.constructor);
+  };
+}
+// ../../node_modules/balanced-match
+function Index(options) {
+  return (target, propertyKey) => {
+    const indexes = Metadata.get("indexes", target.constructor) || [];
+    let index;
+    if (options && options.properties) {
+      const properties = options.properties;
+      index = { name: `${properties.join("_")}_index`, properties: options.properties };
+    } else {
+      index = { name: `${propertyKey}_index`, properties: [propertyKey] };
+    }
+    indexes.push(index);
+    Metadata.set("indexes", indexes, target.constructor);
+  };
+}
 // ../../node_modules/bal
 class EntityStorage {
   static instance;
@@ -223347,11 +223482,11 @@ class EntityStorage {
   getFkKey(relationShip) {
     if (typeof relationShip.fkKey === "undefined") {
       const entity = this.entities.get(relationShip.entity());
-      const property = Object.entries(entity.showProperties).find(([key, value]) => value.options.isPrimary === true);
-      if (!property) {
+      const property2 = Object.entries(entity.showProperties).find(([key, value]) => value.options.isPrimary === true);
+      if (!property2) {
         throw new Error(`Entity ${entity.tableName} does not have a primary key`);
       }
-      return property[0];
+      return property2[0];
     }
     if (typeof relationShip.fkKey === "string") {
       return relationShip.fkKey;
@@ -223365,181 +223500,6 @@ EntityStorage = __legacyDecorateClassTS([
   __legacyMetadataTS("design:paramtypes", [])
 ], EntityStorage);
 
-// ../../node_modul
-var ENTITIES = "cheetah:entities";
-var PROPERTIES3 = "cheetah:properties";
-var PROPERTIES_METADATA = "cheetah:properties:metadata";
-var PROPERTIES_RELATIONS = "cheetah:properties:relations";
-
-// ../../node_modules
-var import_ts_morph = __toESM(require_ts_morph(), 1);
-class OrmService {
-  storage2;
-  allEntities = new Map;
-  constructor(storage2, entityFile = undefined) {
-    this.storage = storage2;
-    console.log("Preparing entities...");
-    const files = new import_ts_morph.Project({ skipLoadingLibFiles: true }).addSourceFilesAtPaths(entityFile ?? this.getSourceFilePaths());
-    files.forEach((file) => {
-      file.getClasses().forEach((classDeclaration) => {
-        if (classDeclaration.getDecorator("Entity")) {
-          const properties = classDeclaration.getProperties();
-          const nullables = [];
-          const defaults = {};
-          properties.forEach((property) => {
-            const propertyName = property.getName();
-            const isNullable = property.hasQuestionToken();
-            const initializer = property.getInitializer();
-            if (isNullable) {
-              nullables.push(propertyName);
-            }
-            if (initializer) {
-              const initializerKind = initializer.getKind();
-              switch (initializerKind) {
-                case import_ts_morph.SyntaxKind.StringLiteral:
-                  defaults[propertyName] = initializer.getText();
-                  break;
-                case import_ts_morph.SyntaxKind.NumericLiteral:
-                  defaults[propertyName] = parseFloat(initializer.getText());
-                  break;
-                default:
-                  defaults[propertyName] = () => initializer.getText();
-                  break;
-              }
-            }
-            this.allEntities.set(classDeclaration.getName(), { nullables, defaults });
-          });
-        }
-      });
-    });
-  }
-  async onInit() {
-    const configFile = globbySync("cheetah.config.ts", { absolute: true });
-    if (configFile.length === 0) {
-      console.log("No config file found!");
-      return;
-    }
-    const config = await import(configFile[0]);
-    if (typeof config.default.entities === "string") {
-      const files = globbySync([config.default.entities, "!node_modules"], { gitignore: true, absolute: true });
-      for (const file of files) {
-        await import(file);
-      }
-    }
-    const entities2 = Metadata.get(ENTITIES, Reflect);
-    if (!entities2) {
-      console.log("No entities found!");
-      return;
-    }
-    for (const entity of entities2) {
-      const nullableDefaultEntity = this.allEntities.get(entity.target.name);
-      const properties = Metadata.get(PROPERTIES_METADATA, entity.target);
-      const relationship = Metadata.get(PROPERTIES_RELATIONS, entity.target);
-      for (const property in properties) {
-        if (nullableDefaultEntity?.nullables.includes(property)) {
-          properties[property].options.nullable = true;
-        }
-        if (nullableDefaultEntity?.defaults[property]) {
-          properties[property].options.default = nullableDefaultEntity?.defaults[property];
-        }
-      }
-      this.storage.add(entity, properties, relationship);
-    }
-    console.log("Entities prepared!");
-  }
-  getSourceFilePaths() {
-    const projectRoot = process.cwd();
-    const getAllFiles = (dir) => {
-      const patterns = [`${dir}/**/*.(ts|js)`, "!**/node_modules/**"];
-      try {
-        return globbySync(patterns, { gitignore: true });
-      } catch (error) {
-        console.error("Erro ao obter arquivos:", error);
-        return [];
-      }
-    };
-    return getAllFiles(projectRoot);
-  }
-}
-__legacyDecorateClassTS([
-  OnApplicationInit(),
-  __legacyMetadataTS("design:type", Function),
-  __legacyMetadataTS("design:paramtypes", []),
-  __legacyMetadataTS("design:returntype", Promise)
-], OrmService.prototype, "onInit", null);
-OrmService = __legacyDecorateClassTS([
-  Service(),
-  __legacyMetadataTS("design:paramtypes", [
-    typeof EntityStorage === "undefined" ? Object : EntityStorage,
-    String
-  ])
-], OrmService);
-
-// ../../node_modules/balanced-match/
-function Entity(options) {
-  return (target) => {
-    const entities2 = Metadata.get(ENTITIES, Reflect) || [];
-    entities2.push({ target, options });
-    Metadata.set(ENTITIES, entities2, Reflect);
-  };
-}
-// ../../node_modules/balanced-match/in
-function Property2(options) {
-  return (target, propertyKey) => {
-    const properties = Metadata.get(PROPERTIES3, target.constructor) || [];
-    const type = Metadata.getType(target, propertyKey);
-    const length = options && options.length || getDefaultLength(type.name);
-    options = { length, ...options };
-    properties.push({ propertyKey, options });
-    Metadata.set(PROPERTIES3, properties, target.constructor);
-    if (options.isPrimary) {
-      const indexes = Metadata.get("indexes", target.constructor) || [];
-      indexes.push({ name: `[TABLE]_pkey`, properties: [propertyKey] });
-      Metadata.set("indexes", indexes, target.constructor);
-    }
-    properties.forEach((property) => {
-      const types = Metadata.get(PROPERTIES_METADATA, target.constructor) || {};
-      const type2 = Metadata.getType(target, property.propertyKey);
-      types[property.propertyKey] = { type: type2, options: property.options };
-      Metadata.set(PROPERTIES_METADATA, types, target.constructor);
-    });
-  };
-}
-// ../../node_modules/balanced-match/index
-function PrimaryKey(options) {
-  const isPrimary = true;
-  return Property2({ ...options, isPrimary, unique: true });
-}
-// ../../node_modules/balanced-match/in
-function OneToMany(entity, fkKey) {
-  return (target, propertyKey) => {
-    const existing = Metadata.get(PROPERTIES_RELATIONS, target.constructor) || [];
-    existing.push({ relation: "one-to-many", propertyKey, isRelation: true, entity, fkKey, type: Metadata.getType(target, propertyKey) });
-    Metadata.set(PROPERTIES_RELATIONS, existing, target.constructor);
-  };
-}
-function ManyToOne(entity) {
-  return (target, propertyKey) => {
-    const existing = Metadata.get(PROPERTIES_RELATIONS, target.constructor) || [];
-    existing.push({ relation: "many-to-one", propertyKey, isRelation: true, entity, type: Metadata.getType(target, propertyKey) });
-    Metadata.set(PROPERTIES_RELATIONS, existing, target.constructor);
-  };
-}
-// ../../node_modules/balanced-match
-function Index(options) {
-  return (target, propertyKey) => {
-    const indexes = Metadata.get("indexes", target.constructor) || [];
-    let index;
-    if (options && options.properties) {
-      const properties = options.properties;
-      index = { name: `${properties.join("_")}_index`, properties: options.properties };
-    } else {
-      index = { name: `${propertyKey}_index`, properties: [propertyKey] };
-    }
-    indexes.push(index);
-    Metadata.set("indexes", indexes, target.constructor);
-  };
-}
 // ../../node_module
 class SqlBuilder {
   driver;
@@ -223694,24 +223654,24 @@ class SqlBuilder {
     if (typeof this.statements.join === "undefined") {
       throw new Error("Join not found");
     }
-    const entities3 = column.split(".");
+    const entities2 = column.split(".");
     let lastEntity = this.model;
     let lastAlias = this.statements.alias;
     const relationsMap = new Map(this.entity.relations.map((rel) => [rel.propertyKey, rel]));
     const joinMap = new Map(this.statements.join.map((join) => [join.joinProperty, join]));
-    for (let i = 0;i < entities3.length; i++) {
+    for (let i = 0;i < entities2.length; i++) {
       if (i === 0) {
-        const relation = relationsMap.get(entities3[i]);
+        const relation = relationsMap.get(entities2[i]);
         lastEntity = relation?.entity();
-        lastAlias = joinMap.get(entities3[i])?.joinAlias;
+        lastAlias = joinMap.get(entities2[i])?.joinAlias;
       } else {
-        if (i + 1 === entities3.length) {
+        if (i + 1 === entities2.length) {
           if (onlyAlias) {
-            return `${lastAlias}."${entities3[i]}"`;
+            return `${lastAlias}."${entities2[i]}"`;
           }
-          return `${lastAlias}."${entities3[i]}" as ${lastAlias}_${entities3[i]}`;
+          return `${lastAlias}."${entities2[i]}" as ${lastAlias}_${entities2[i]}`;
         }
-        const lastStatement = joinMap.get(entities3[i]);
+        const lastStatement = joinMap.get(entities2[i]);
         lastEntity = lastStatement?.joinEntity;
         lastAlias = lastStatement?.joinAlias;
       }
@@ -223953,18 +223913,20 @@ class SqlBuilder {
 
 // ../../node
 class Orm {
-  connection;
   logger3;
   driverInstance;
   static instance;
+  connection;
+  constructor(logger3) {
+    this.logger = logger3;
+    Orm.instance = this;
+  }
   static getInstance() {
     return Orm.instance;
   }
-  constructor(connection, logger3) {
+  setConnection(connection) {
     this.connection = connection;
-    this.logger = logger3;
     this.driverInstance = new this.connection.driver(connection);
-    Orm.instance = this;
   }
   createQueryBuilder(model) {
     return new SqlBuilder(model);
@@ -223976,6 +223938,840 @@ class Orm {
     return this.driverInstance.disconnect();
   }
 }
+Orm = __legacyDecorateClassTS([
+  Service(),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof LoggerService === "undefined" ? Object : LoggerService
+  ])
+], Orm);
+// ../../node_modules
+var import_ts_morph2 = __toESM(require_ts_morph(), 1);
+
+// ../../node_module
+var ENTITIES2 = "cheetah:entities";
+var PROPERTIES_METADATA2 = "cheetah:properties:metadata";
+var PROPERTIES_RELATIONS2 = "cheetah:properties:relations";
+// ../../node_mo
+function getDefaultLength2(type) {
+  if (type === "String") {
+    return 255;
+  }
+  if (type === "Number") {
+    return 11;
+  }
+  if (type === "Boolean") {
+    return 1;
+  }
+  if (type === "Date") {
+    return 6;
+  }
+  return 255;
+}
+// ../../node_modules/bala
+var __decorate9 = function(decorators5, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators5, target, key, desc);
+  else
+    for (var i = decorators5.length - 1;i >= 0; i--)
+      if (d = decorators5[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata7 = function(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var EntityStorage_1;
+var EntityStorage2 = EntityStorage_1 = class EntityStorage3 {
+  constructor() {
+    this.entities = new Map;
+    EntityStorage_1.instance = this;
+  }
+  add(entity, properties, relations) {
+    const entityName = entity.options?.tableName || entity.target.name.toLowerCase();
+    const indexes = Metadata.get("indexes", entity.target) || [];
+    this.entities.set(entity.target, {
+      showProperties: properties,
+      hideProperties: [],
+      relations,
+      indexes: indexes.map((index) => {
+        return {
+          table: entityName,
+          indexName: index.name.replace("[TABLE]", entityName),
+          columnName: index.properties.join(",")
+        };
+      }),
+      tableName: entityName,
+      ...entity.options
+    });
+  }
+  get(entity) {
+    return this.entities.get(entity);
+  }
+  entries() {
+    return this.entities.entries();
+  }
+  static getInstance() {
+    return EntityStorage_1.instance;
+  }
+  async snapshot(values) {
+    return {
+      tableName: values.tableName,
+      schema: values.schema || "public",
+      indexes: values.indexes || [],
+      columns: this.snapshotColumns(values)
+    };
+  }
+  snapshotColumns(values) {
+    let properties = Object.entries(values.showProperties).map(([key, value]) => {
+      return {
+        name: key,
+        type: value.type.name,
+        nullable: value.options?.nullable,
+        default: value.options?.default,
+        primary: value.options?.isPrimary,
+        unique: value.options?.unique,
+        length: value.options?.length
+      };
+    });
+    let relations = values.relations && values.relations.map((relation) => {
+      const type = this.getFkType(relation);
+      return {
+        name: relation.propertyKey,
+        type,
+        nullable: relation.nullable,
+        unique: relation.unique,
+        length: relation.length || getDefaultLength2(type),
+        default: relation.default,
+        primary: relation.isPrimary,
+        foreignKeys: [
+          {
+            referencedColumnName: this.getFkKey(relation),
+            referencedTableName: this.get(relation.entity()).tableName
+          }
+        ]
+      };
+    });
+    if (!relations) {
+      relations = [];
+    }
+    if (!properties) {
+      properties = [];
+    }
+    return [...properties, ...relations];
+  }
+  snapshotIndexes(values) {
+    return Object.entries(values.showProperties).map(([key, value]) => {
+      return {
+        indexName: key,
+        columnName: key,
+        table: values.tableName
+      };
+    });
+  }
+  getFkType(relation) {
+    const entity = this.get(relation.entity());
+    if (!entity) {
+      return "unknown";
+    }
+    return entity.showProperties[this.getFkKey(relation)].type.name;
+  }
+  getFkKey(relationShip) {
+    if (typeof relationShip.fkKey === "undefined") {
+      const entity = this.entities.get(relationShip.entity());
+      const property3 = Object.entries(entity.showProperties).find(([key, value]) => value.options.isPrimary === true);
+      if (!property3) {
+        throw new Error(`Entity ${entity.tableName} does not have a primary key`);
+      }
+      return property3[0];
+    }
+    if (typeof relationShip.fkKey === "string") {
+      return relationShip.fkKey;
+    }
+    const match = /\.(?<propriedade>[\w]+)/.exec(relationShip.fkKey.toString());
+    return match ? match.groups.propriedade : "";
+  }
+};
+EntityStorage2 = EntityStorage_1 = __decorate9([
+  Service(),
+  __metadata7("design:paramtypes", [])
+], EntityStorage2);
+
+// ../../node_modules
+class SqlBuilder3 {
+  constructor(model) {
+    this.statements = {};
+    this.aliases = new Set;
+    this.lastKeyNotOperator = "";
+    this.updatedColumns = [];
+    const orm = Orm.getInstance();
+    this.driver = orm.driverInstance;
+    this.logger = orm.logger;
+    this.entityStorage = EntityStorage2.getInstance();
+    this.getEntity(model);
+  }
+  select(columns) {
+    const tableName = this.entity.tableName || this.model.name.toLowerCase();
+    const schema = this.entity.schema || "public";
+    this.statements.statement = "select";
+    this.statements.columns = columns;
+    this.statements.alias = this.getAlias(tableName);
+    this.statements.table = `"${schema}"."${tableName}"`;
+    return this;
+  }
+  insert(values) {
+    const { tableName, schema } = this.getTableName();
+    this.statements.statement = "insert";
+    this.statements.alias = this.getAlias(tableName);
+    this.statements.table = `"${schema}"."${tableName}"`;
+    this.statements.values = this.withUpdatedValues(this.withDefaultValues(values, this.entity), this.entity);
+    return this;
+  }
+  update(values) {
+    const { tableName, schema } = this.getTableName();
+    this.statements.statement = "update";
+    this.statements.alias = this.getAlias(tableName);
+    this.statements.table = `${schema}.${tableName}`;
+    this.statements.values = this.withUpdatedValues(values, this.entity);
+    return this;
+  }
+  where(where) {
+    if (typeof where === "undefined" || Object.entries(where).length === 0) {
+      return this;
+    }
+    this.statements.where = this.conditionToSql(where, this.statements.alias);
+    return this;
+  }
+  orderBy(orderBy) {
+    if (typeof orderBy === "undefined") {
+      return this;
+    }
+    this.statements.orderBy = this.objectToStringMap(orderBy);
+    return this;
+  }
+  limit(limit) {
+    this.statements.limit = limit;
+    return this;
+  }
+  offset(offset) {
+    this.statements.offset = offset;
+    return this;
+  }
+  async executeAndReturnFirst() {
+    this.statements.limit = 1;
+    const result = await this.execute();
+    if (result.query.rows.length === 0) {
+      return;
+    }
+    return this.transformToModel(result.query.rows[0]);
+  }
+  async executeAndReturnFirstOrFail() {
+    this.statements.limit = 1;
+    const result = await this.execute();
+    if (result.query.rows.length === 0) {
+      throw new Error("Result not found");
+    }
+    return this.transformToModel(result.query.rows[0]);
+  }
+  async executeAndReturnAll() {
+    const result = await this.execute();
+    if (result.query.rows.length === 0) {
+      return [];
+    }
+    return result.query.rows.map((row) => this.transformToModel(row));
+  }
+  async execute() {
+    if (!this.statements.columns) {
+      let columns = [
+        ...this.getColumnsEntity(this.model, this.statements.alias)
+      ];
+      if (this.statements.join) {
+        columns = [
+          ...columns,
+          ...this.statements.join.flatMap((join) => this.getColumnsEntity(join.joinEntity, join.joinAlias))
+        ];
+      }
+      this.statements.columns = columns;
+    } else {
+      this.statements.columns = this.statements.columns.map((column) => {
+        return this.discoverColumnAlias(column);
+      }).flat();
+    }
+    this.statements.columns.push(...this.updatedColumns);
+    const result = await this.driver.executeStatement(this.statements);
+    this.logger.debug(`SQL: ${result.sql} [${Date.now() - result.startTime}ms]`);
+    return result;
+  }
+  startTransaction() {
+    return this.driver.startTransaction();
+  }
+  commit() {
+    return this.driver.commitTransaction();
+  }
+  rollback() {
+    return this.driver.rollbackTransaction();
+  }
+  async inTransaction(callback) {
+    await this.startTransaction();
+    try {
+      const result = await callback(this);
+      await this.commit();
+      return result;
+    } catch (e) {
+      await this.rollback();
+      throw e;
+    }
+  }
+  objectToStringMap(obj, parentKey = "") {
+    let result = [];
+    for (let key in obj) {
+      if (obj.hasOwnProperty(key)) {
+        let fullKey = parentKey ? `${parentKey}.${key}` : key;
+        if (typeof obj[key] === "object" && obj[key] !== null) {
+          result = result.concat(this.objectToStringMap(obj[key], fullKey));
+        } else {
+          result.push(`${this.discoverColumnAlias(fullKey, true)} ${obj[key]}`);
+        }
+      }
+    }
+    return result;
+  }
+  discoverColumnAlias(column, onlyAlias = false) {
+    if (!column.includes(".")) {
+      if (onlyAlias) {
+        return `${this.statements.alias}."${column}"`;
+      }
+      return `${this.statements.alias}."${column}" as ${this.statements.alias}_${column}`;
+    }
+    if (typeof this.statements.join === "undefined") {
+      throw new Error("Join not found");
+    }
+    const entities3 = column.split(".");
+    let lastEntity = this.model;
+    let lastAlias = this.statements.alias;
+    const relationsMap = new Map(this.entity.relations.map((rel) => [rel.propertyKey, rel]));
+    const joinMap = new Map(this.statements.join.map((join) => [join.joinProperty, join]));
+    for (let i = 0;i < entities3.length; i++) {
+      if (i === 0) {
+        const relation = relationsMap.get(entities3[i]);
+        lastEntity = relation?.entity();
+        lastAlias = joinMap.get(entities3[i])?.joinAlias;
+      } else {
+        if (i + 1 === entities3.length) {
+          if (onlyAlias) {
+            return `${lastAlias}."${entities3[i]}"`;
+          }
+          return `${lastAlias}."${entities3[i]}" as ${lastAlias}_${entities3[i]}`;
+        }
+        const lastStatement = joinMap.get(entities3[i]);
+        lastEntity = lastStatement?.joinEntity;
+        lastAlias = lastStatement?.joinAlias;
+      }
+    }
+    return "";
+  }
+  getTableName() {
+    const tableName = this.entity.tableName || this.model.name.toLowerCase();
+    const schema = this.entity.schema || "public";
+    return { tableName, schema };
+  }
+  addSimpleConditionToSql(key, value, alias = null, operator = "=") {
+    const aliasToUse = alias || this.statements.alias;
+    const valueByType = typeof value === "string" ? `'${value}'` : value;
+    return `${aliasToUse}.${key} ${operator} ${valueByType}`;
+  }
+  addInConditionToSql(key, values, alias = null) {
+    const aliasToUse = alias || this.statements.alias;
+    return `${aliasToUse}.${key} IN (${values.map((val) => typeof val === "string" ? `'${val}'` : val).join(", ")})`;
+  }
+  addLogicalOperatorToSql(conditions, operator) {
+    return `(${conditions.join(` ${operator} `)})`;
+  }
+  conditionToSql(condition, alias) {
+    const sqlParts = [];
+    const operators = ["$eq", "$ne", "$in", "$nin", "$like", "$gt", "$gte", "$lt", "$lte", "$and", "$or"];
+    for (let [key, value] of Object.entries(condition)) {
+      if (!operators.includes(key)) {
+        this.lastKeyNotOperator = key;
+      }
+      const relationShip = this.entity.relations?.find((rel) => rel.propertyKey === key);
+      if (relationShip) {
+        sqlParts.push(this.applyJoin(relationShip, value, alias));
+      } else if (typeof value !== "object" || value === null) {
+        if (key === "$eq") {
+          sqlParts.push(this.addSimpleConditionToSql(this.lastKeyNotOperator, value, alias, "="));
+          continue;
+        }
+        sqlParts.push(this.addSimpleConditionToSql(key, value, alias));
+      } else if (!operators.includes(key) && Array.isArray(value)) {
+        sqlParts.push(this.addInConditionToSql(key, value, alias));
+      } else {
+        if (["$or", "$and"].includes(key)) {
+          sqlParts.push(this.addLogicalOperatorToSql(value.map((cond) => this.conditionToSql(cond, alias)), key.toUpperCase().replace("$", "")));
+        }
+        for (const operator of operators) {
+          if (operator in value) {
+            switch (operator) {
+              case "$eq":
+                sqlParts.push(this.addSimpleConditionToSql(key, value["$eq"], alias, "="));
+                break;
+              case "$ne":
+                sqlParts.push(this.addSimpleConditionToSql(key, value["$ne"], alias, "!="));
+                break;
+              case "$in":
+                sqlParts.push(this.addInConditionToSql(key, value["$in"], alias));
+                break;
+              case "$nin":
+                sqlParts.push(`${alias}.${key} NOT IN (${value["$nin"].map((val) => this.t(val)).join(", ")})`);
+                break;
+              case "$like":
+                sqlParts.push(`${alias}.${key} LIKE '${value["$like"]}'`);
+                break;
+              case "$gt":
+                sqlParts.push(`${alias}.${key} > ${value["$gt"]}`);
+                break;
+              case "$gte":
+                sqlParts.push(`${alias}.${key} >= ${value["$gte"]}`);
+                break;
+              case "$lt":
+                sqlParts.push(`${alias}.${key} < ${value["$lt"]}`);
+                break;
+              case "$lte":
+                sqlParts.push(`${alias}.${key} <= ${value["$lte"]}`);
+                break;
+              case "$and":
+              case "$or":
+                const parts = value[operator].map((cond) => this.conditionToSql(cond, alias));
+                sqlParts.push(this.addLogicalOperatorToSql(parts, operator.toUpperCase().replace("$", "")));
+                break;
+            }
+          }
+        }
+      }
+    }
+    return this.addLogicalOperatorToSql(sqlParts, "AND");
+  }
+  t(value) {
+    return typeof value === "string" ? `'${value}'` : value;
+  }
+  applyJoin(relationShip, value, alias) {
+    const { tableName, schema } = this.getTableName();
+    const { tableName: joinTableName, schema: joinSchema } = this.entityStorage.get(relationShip.entity()) || {
+      tableName: relationShip.entity().name.toLowerCase(),
+      schema: "public"
+    };
+    let originPrimaryKey = "id";
+    for (const prop in this.entity.showProperties) {
+      if (this.entity.showProperties[prop].options.isPrimary) {
+        originPrimaryKey = prop;
+        break;
+      }
+    }
+    const joinAlias = `${this.getAlias(joinTableName)}`;
+    const joinWhere = this.conditionToSql(value, joinAlias);
+    this.statements.join = this.statements.join || [];
+    let on = "";
+    switch (relationShip.relation) {
+      case "one-to-many":
+        on = `${joinAlias}.${this.getFkKey(relationShip)} = ${alias}.${originPrimaryKey}`;
+        break;
+      case "many-to-one":
+        on = `${alias}.${relationShip.propertyKey} = ${joinAlias}.${this.getFkKey(relationShip)}`;
+        break;
+    }
+    this.statements.join.push({
+      joinAlias,
+      joinTable: joinTableName,
+      joinSchema: joinSchema || "public",
+      joinWhere,
+      joinProperty: relationShip.propertyKey,
+      originAlias: alias,
+      originSchema: schema,
+      originTable: tableName,
+      propertyKey: relationShip.propertyKey,
+      joinEntity: relationShip.entity(),
+      type: "LEFT",
+      on,
+      originalEntity: relationShip.originalEntity
+    });
+    return joinWhere;
+  }
+  getFkKey(relationShip) {
+    if (typeof relationShip.fkKey === "undefined") {
+      return "id";
+    }
+    if (typeof relationShip.fkKey === "string") {
+      return relationShip.fkKey;
+    }
+    const match = /\.(?<propriedade>[\w]+)/.exec(relationShip.fkKey.toString());
+    return match ? match.groups.propriedade : "";
+  }
+  getEntity(model) {
+    const entity = this.entityStorage.get(model);
+    this.model = model;
+    if (!entity) {
+      throw new Error("Entity not found");
+    }
+    this.entity = entity;
+  }
+  transformToModel(data) {
+    const instance = new this.model;
+    instance.$_isPersisted = true;
+    const entitiesByAlias = {
+      [this.statements.alias]: instance
+    };
+    const entitiesOptions = new Map;
+    entitiesOptions.set(this.statements.alias, this.entityStorage.get(instance.constructor));
+    if (this.statements.join) {
+      this.statements.join.forEach((join) => {
+        const joinInstance = new join.joinEntity;
+        joinInstance.$_isPersisted = true;
+        entitiesByAlias[join.joinAlias] = joinInstance;
+        entitiesOptions.set(join.joinAlias, this.entityStorage.get(joinInstance.constructor));
+      });
+    }
+    Object.entries(data).forEach(([key, value]) => {
+      const [alias, prop] = key.split("_");
+      const entity = entitiesByAlias[alias];
+      if (!entity) {
+        return;
+      }
+      if (entitiesOptions.get(alias).showProperties.hasOwnProperty(prop)) {
+        entity[prop] = value;
+      }
+    });
+    if (this.statements.join) {
+      this.statements.join.forEach((join) => {
+        const { joinAlias, originAlias, propertyKey } = join;
+        const originEntity = entitiesByAlias[originAlias];
+        const joinEntity = entitiesByAlias[joinAlias];
+        const property3 = entitiesOptions.get(originAlias).relations.find((rel) => rel.propertyKey === propertyKey);
+        if (!originEntity || !joinEntity) {
+          return;
+        }
+        originEntity[propertyKey] = property3.type === Array ? originEntity[propertyKey] ? [...originEntity[propertyKey], joinEntity] : [joinEntity] : joinEntity;
+      });
+    }
+    return instance;
+  }
+  getAlias(tableName) {
+    const alias = tableName.split("").shift() || "";
+    let counter = 1;
+    let uniqueAlias = `${alias}${counter}`;
+    while (this.aliases.has(uniqueAlias)) {
+      counter++;
+      uniqueAlias = `${alias}${counter}`;
+    }
+    this.aliases.add(uniqueAlias);
+    return uniqueAlias;
+  }
+  getColumnsEntity(entity, alias) {
+    const e = this.entityStorage.get(entity);
+    if (!e) {
+      throw new Error("Entity not found");
+    }
+    return Object.keys(e.showProperties).map((key) => `${alias}."${key}" as "${alias}_${key}"`);
+  }
+  withDefaultValues(values, entityOptions) {
+    const property3 = Object.entries(entityOptions.showProperties).filter(([_, value]) => value.options.onInsert);
+    const defaultProperties = Object.entries(entityOptions.showProperties).filter(([_, value]) => value.options.default);
+    for (const [key, property4] of defaultProperties) {
+      if (typeof values[key] === "undefined") {
+        if (typeof property4.options.default === "function") {
+          values[key] = (0, eval)(property4.options.default());
+        } else {
+          values[key] = (0, eval)(property4.options.default);
+        }
+      }
+    }
+    property3.forEach(([key, property4]) => {
+      values[key] = property4.options.onInsert();
+      this.updatedColumns.push(`${this.statements.alias}."${key}" as "${this.statements.alias}_${key}"`);
+    });
+    return values;
+  }
+  withUpdatedValues(values, entityOptions) {
+    const property3 = Object.entries(entityOptions.showProperties).filter(([_, value]) => value.options.onUpdate);
+    property3.forEach(([key, property4]) => {
+      values[key] = property4.options.onUpdate();
+      this.updatedColumns.push(`${this.statements.alias}."${key}" as "${this.statements.alias}_${key}"`);
+    });
+    return values;
+  }
+}
+
+// ../../node_
+var __decorate10 = function(decorators5, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators5, target, key, desc);
+  else
+    for (var i = decorators5.length - 1;i >= 0; i--)
+      if (d = decorators5[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata8 = function(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var Orm_1;
+var Orm2 = Orm_1 = class Orm3 {
+  constructor(logger3) {
+    this.logger = logger3;
+    Orm_1.instance = this;
+  }
+  static getInstance() {
+    return Orm_1.instance;
+  }
+  setConnection(connection) {
+    this.connection = connection;
+    this.driverInstance = new this.connection.driver(connection);
+  }
+  createQueryBuilder(model) {
+    return new SqlBuilder3(model);
+  }
+  connect() {
+    return this.driverInstance.connect();
+  }
+  disconnect() {
+    return this.driverInstance.disconnect();
+  }
+};
+Orm2 = Orm_1 = __decorate10([
+  Service(),
+  __metadata8("design:paramtypes", [LoggerService])
+], Orm2);
+// ../../node_modules/
+var import_ts_morph = __toESM(require_ts_morph(), 1);
+var __decorate11 = function(decorators5, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators5, target, key, desc);
+  else
+    for (var i = decorators5.length - 1;i >= 0; i--)
+      if (d = decorators5[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata9 = function(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var OrmService = class OrmService2 {
+  constructor(orm2, storage2, entityFile = undefined) {
+    this.orm = orm2;
+    this.storage = storage2;
+    this.allEntities = new Map;
+    console.log("Preparing entities...");
+    const files = new import_ts_morph.Project({ skipLoadingLibFiles: true }).addSourceFilesAtPaths(entityFile ?? this.getSourceFilePaths());
+    files.forEach((file) => {
+      file.getClasses().forEach((classDeclaration) => {
+        if (classDeclaration.getDecorator("Entity")) {
+          const properties = classDeclaration.getProperties();
+          const nullables = [];
+          const defaults = {};
+          properties.forEach((property3) => {
+            const propertyName = property3.getName();
+            const isNullable = property3.hasQuestionToken();
+            const initializer = property3.getInitializer();
+            if (isNullable) {
+              nullables.push(propertyName);
+            }
+            if (initializer) {
+              const initializerKind = initializer.getKind();
+              switch (initializerKind) {
+                case import_ts_morph.SyntaxKind.StringLiteral:
+                  defaults[propertyName] = initializer.getText();
+                  break;
+                case import_ts_morph.SyntaxKind.NumericLiteral:
+                  defaults[propertyName] = parseFloat(initializer.getText());
+                  break;
+                default:
+                  defaults[propertyName] = () => initializer.getText();
+                  break;
+              }
+            }
+            this.allEntities.set(classDeclaration.getName(), { nullables, defaults });
+          });
+        }
+      });
+    });
+  }
+  async onInit(customConfig = undefined) {
+    const configFile = globbySync("cheetah.config.ts", { absolute: true });
+    if (configFile.length === 0) {
+      console.log("No config file found!");
+      return;
+    }
+    const config = await import(configFile[0]);
+    this.orm.setConnection(customConfig ?? config.default.connection);
+    await this.orm.connect();
+    if (typeof config.default.entities === "string") {
+      const files = globbySync([config.default.entities, "!node_modules"], { gitignore: true, absolute: true });
+      for (const file of files) {
+        await import(file);
+      }
+    }
+    const entities4 = Metadata.get(ENTITIES2, Reflect);
+    if (!entities4) {
+      console.log("No entities found!");
+      return;
+    }
+    for (const entity of entities4) {
+      const nullableDefaultEntity = this.allEntities.get(entity.target.name);
+      const properties = Metadata.get(PROPERTIES_METADATA2, entity.target);
+      const relationship = Metadata.get(PROPERTIES_RELATIONS2, entity.target);
+      for (const property3 in properties) {
+        if (nullableDefaultEntity?.nullables.includes(property3)) {
+          properties[property3].options.nullable = true;
+        }
+        if (nullableDefaultEntity?.defaults[property3]) {
+          properties[property3].options.default = nullableDefaultEntity?.defaults[property3];
+        }
+      }
+      this.storage.add(entity, properties, relationship);
+    }
+    console.log("Entities prepared!");
+  }
+  getSourceFilePaths() {
+    const projectRoot = process.cwd();
+    const getAllFiles = (dir) => {
+      const patterns = [`${dir}/**/*.(ts|js)`, "!**/node_modules/**"];
+      try {
+        return globbySync(patterns, { gitignore: true });
+      } catch (error) {
+        console.error("Erro ao obter arquivos:", error);
+        return [];
+      }
+    };
+    return getAllFiles(projectRoot);
+  }
+};
+__decorate11([
+  OnApplicationInit(),
+  __metadata9("design:type", Function),
+  __metadata9("design:paramtypes", [Object]),
+  __metadata9("design:returntype", Promise)
+], OrmService.prototype, "onInit", null);
+OrmService = __decorate11([
+  Service(),
+  __metadata9("design:paramtypes", [Orm2, EntityStorage2, Object])
+], OrmService);
+// ../../node_modules/balan
+var import_pg = __toESM(require_lib2(), 1);
+// ../../node_mo
+var CheetahOrm = new Cheetah({ exports: [Orm2, OrmService, EntityStorage2] });
+// ../../node_modules
+class OrmService3 {
+  orm7;
+  storage2;
+  allEntities = new Map;
+  constructor(orm7, storage2, entityFile = undefined) {
+    this.orm = orm7;
+    this.storage = storage2;
+    console.log("Preparing entities...");
+    const files = new import_ts_morph2.Project({ skipLoadingLibFiles: true }).addSourceFilesAtPaths(entityFile ?? this.getSourceFilePaths());
+    files.forEach((file) => {
+      file.getClasses().forEach((classDeclaration) => {
+        if (classDeclaration.getDecorator("Entity")) {
+          const properties = classDeclaration.getProperties();
+          const nullables = [];
+          const defaults = {};
+          properties.forEach((property4) => {
+            const propertyName = property4.getName();
+            const isNullable = property4.hasQuestionToken();
+            const initializer = property4.getInitializer();
+            if (isNullable) {
+              nullables.push(propertyName);
+            }
+            if (initializer) {
+              const initializerKind = initializer.getKind();
+              switch (initializerKind) {
+                case import_ts_morph2.SyntaxKind.StringLiteral:
+                  defaults[propertyName] = initializer.getText();
+                  break;
+                case import_ts_morph2.SyntaxKind.NumericLiteral:
+                  defaults[propertyName] = parseFloat(initializer.getText());
+                  break;
+                default:
+                  defaults[propertyName] = () => initializer.getText();
+                  break;
+              }
+            }
+            this.allEntities.set(classDeclaration.getName(), { nullables, defaults });
+          });
+        }
+      });
+    });
+  }
+  async onInit(customConfig = undefined) {
+    const configFile = globbySync("cheetah.config.ts", { absolute: true });
+    if (configFile.length === 0) {
+      console.log("No config file found!");
+      return;
+    }
+    const config = await import(configFile[0]);
+    this.orm.setConnection(customConfig ?? config.default.connection);
+    await this.orm.connect();
+    if (typeof config.default.entities === "string") {
+      const files = globbySync([config.default.entities, "!node_modules"], { gitignore: true, absolute: true });
+      for (const file of files) {
+        await import(file);
+      }
+    }
+    const entities6 = Metadata.get(ENTITIES, Reflect);
+    if (!entities6) {
+      console.log("No entities found!");
+      return;
+    }
+    for (const entity2 of entities6) {
+      const nullableDefaultEntity = this.allEntities.get(entity2.target.name);
+      const properties = Metadata.get(PROPERTIES_METADATA, entity2.target);
+      const relationship = Metadata.get(PROPERTIES_RELATIONS, entity2.target);
+      for (const property4 in properties) {
+        if (nullableDefaultEntity?.nullables.includes(property4)) {
+          properties[property4].options.nullable = true;
+        }
+        if (nullableDefaultEntity?.defaults[property4]) {
+          properties[property4].options.default = nullableDefaultEntity?.defaults[property4];
+        }
+      }
+      this.storage.add(entity2, properties, relationship);
+    }
+    console.log("Entities prepared!");
+  }
+  getSourceFilePaths() {
+    const projectRoot = process.cwd();
+    const getAllFiles = (dir) => {
+      const patterns = [`${dir}/**/*.(ts|js)`, "!**/node_modules/**"];
+      try {
+        return globbySync(patterns, { gitignore: true });
+      } catch (error) {
+        console.error("Erro ao obter arquivos:", error);
+        return [];
+      }
+    };
+    return getAllFiles(projectRoot);
+  }
+}
+__legacyDecorateClassTS([
+  OnApplicationInit(),
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", [
+    Object
+  ]),
+  __legacyMetadataTS("design:returntype", Promise)
+], OrmService3.prototype, "onInit", null);
+OrmService3 = __legacyDecorateClassTS([
+  Service(),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof Orm2 === "undefined" ? Object : Orm2,
+    typeof EntityStorage === "undefined" ? Object : EntityStorage,
+    String
+  ])
+], OrmService3);
 // ../../node_modules/balanc
 class BaseEntity {
   _oldValues = {};
@@ -224043,7 +224839,7 @@ class BaseEntity {
   }
 }
 // ../../node_modules/bala
-var import_pg = __toESM(require_lib2(), 1);
+var import_pg2 = __toESM(require_lib2(), 1);
 
 class PgDriver {
   connectionString;
@@ -224055,7 +224851,7 @@ class PgDriver {
       const { host, port, username, password, database } = options;
       this.connectionString = `postgres://${username}:${password}@${host}:${port}/${database}`;
     }
-    this.client = new import_pg.Client({
+    this.client = new import_pg2.Client({
       connectionString: this.connectionString
     });
   }
@@ -224298,22 +225094,21 @@ class PgDriver {
     }
   }
 }
-
 // ../../node_m
-var CheetahOrm = new Cheetah2({ exports: [OrmService, EntityStorage] });
+var CheetahOrm2 = new Cheetah({ exports: [Orm, OrmService3, EntityStorage] });
 export {
   getDefaultLength,
-  Property2 as Property,
+  Property,
   PrimaryKey,
   PgDriver,
-  OrmService,
+  OrmService3 as OrmService,
   Orm,
   OneToMany,
   ManyToOne,
   Index,
   Entity,
-  CheetahOrm,
+  CheetahOrm2 as CheetahOrm,
   BaseEntity
 };
 
-//# debugId=1B90EB18FBEFC99A64756e2164756e21
+//# debugId=3C714E5DC008C7C264756e2164756e21