So to create simple polygons from a complex polygon (self-intersecting), is to use `turf.unkink()` for Javascript turf.js. The area can also be found using the [polygon area equation][1]. 

Example code below.

Firstly, join the end point of the first curve with end of second curve, then join the start point of the second curve with start point of the first point. This creates a single polyon of the two curves.

Like the following:

    function zip(arrays) {
      return arrays[0].map((_,i) => {
        return arrays.map((array) => {return array[i]})
      });
    }
    
    var xy_1 = zip([x1,y1]);
    var xy_2 = zip([x2,y2]);
    
    var newPolygon = [] //creates a empty list where we will append the points to create the polygon
    
    for(var i = 0; i < xy_1.length; i++) 
      newPolygon.push([xy_1[i][0],xy_1[i][1]]) //append all xy points for curve 1
    
    for(var i = xy_2.length - 1; i >= 0; i--)
      newPolygon.push([xy_2[i][0],xy_2[i][1]]) //append all xy points for curve 2 in the reverse order (from last point to first point)
    
    console.log(newPolygon)


Then using the `unkink()` function from turf.js you can simplify the self-intersecting polygon into simple polygons and then find area.


**NOTE:** The area is calculated in Cartesian form, as `turf.area` gives different area.

    const line_non_simple = turf.polygon([some_intersecting_polygon_coords])
    
    var result = turf.unkinkPolygon(line_non_simple);
    
    var A_modelArea = []
    
    function findModelArea(multiCoords){
      //Split multicoords to x, y 
      var xNew = []
      var yNew = []
      for(var i = 0; i < multiCoords.length; i++ ){
        xNew.push(multiCoords[i][0]);
        yNew.push(multiCoords[i][1])
      }
      //Finds the area using the x, y
      var avg_sum = []
      for(var i = 0; i < multiCoords.length -1; i++ ){
        avg_sum.push(xNew[i]*yNew[i+1]-xNew[i+1]*yNew[i])
      }
      var avg_area = Math.abs(0.5*(avg_sum.reduce((a, b) => a + b)))
    
      A_modelArea.push(avg_area);
    }
    
    result.features.map(i => findModelArea(i.geometry.coordinates[0]))
    
    console.log(A_modelArea.reduce((a, b) => a + b))


  [1]: https://www.seas.upenn.edu/~ese502/lab-content/extra_materials/Polygon%20Area%20and%20Centroid.pdf