How to get the maximum rectangle drawn inside polygon

I am using three.js and I draw polygons inside viewer this polygon represented as Vector2[].

I want to get the maximum rectangle can be drawn inside that polygon represented as Vector2[]

I want to have a function that I pass a Vector2[] that represents a polygon and it returns back Vector2[] that represents the max rectangle can be drawn inside that polygon.

This is the function i use but it someetimes draw the rectangle outside the polygon

findLargestRectangle(polygon: Vector2[]): Vector2[] | null {
    let maxArea = 0;
    let bestRectangle: Vector2[] | null = null;
    
    for (let i = 0; i < polygon.length - 1; i++) { // Skip the last point
      for (let j = i + 1; j < polygon.length - 1; j++) { // Skip the last point
        const base1 = polygon[i];
        const base2 = polygon[j];
        const baseVector = new Vector2().subVectors(base2, base1);
        
        for (let k = 0; k < polygon.length - 1; k++) { // Skip the last point
          if (k === i || k === j) continue;
          
          const perpVector = new Vector2(-baseVector.y, baseVector.x).normalize();
          const height = perpVector.dot(new Vector2().subVectors(polygon[k], base1));
          
          const corner1 = base1.clone().add(perpVector.clone().multiplyScalar(height));
          const corner2 = base2.clone().add(perpVector.clone().multiplyScalar(height));
          
          // Check if both corner points are within the polygon
          if (PolygonHelperFunctions.isPointInPolygon(corner1, polygon) && PolygonHelperFunctions.isPointInPolygon(corner2, polygon)) {
            const rectangleArea = PolygonHelperFunctions.getRectangleArea(base1, base2, corner2, corner1);
            if (rectangleArea > maxArea) {
              maxArea = rectangleArea;
              bestRectangle = [base1, base2, corner2, corner1];
            }
          } else {
            // Handle the case where corners are outside the polygon
            const smallestEdge = PolygonHelperFunctions.findSmallestEdge(polygon);
            const smallBase1 = polygon[smallestEdge.index1];
            const smallBase2 = polygon[smallestEdge.index2];
            
            const smallBaseVector = new Vector2().subVectors(smallBase2, smallBase1);
            const smallHeight = perpVector.dot(new Vector2().subVectors(polygon[k], smallBase1));
            
            const smallCorner1 = smallBase1.clone().add(perpVector.clone().multiplyScalar(smallHeight));
            const smallCorner2 = smallBase2.clone().add(perpVector.clone().multiplyScalar(smallHeight));
            
            // Ensure it's a pure rectangle
            const smallBaseLength = smallBaseVector.length();
            const smallSide1 = smallCorner1.distanceTo(smallBase1);
            const smallSide2 = smallCorner2.distanceTo(smallBase2);
            
            if (
              smallBaseLength === smallBaseVector.length() &&
              smallSide1 === smallSide2 &&
              Math.abs(perpVector.dot(smallBaseVector)) < 1e-10 // Check that vectors are perpendicular
            ) {
              const smallRectangleArea = PolygonHelperFunctions.getRectangleArea(smallBase1, smallBase2, smallCorner2, smallCorner1);
              if (smallRectangleArea > maxArea) {
                maxArea = smallRectangleArea;
                bestRectangle = [smallBase1, smallBase2, smallCorner2, smallCorner1];
              }
            }
          }
        }
      }
    }