poly-extrude 0.0.1 → 0.0.4

package/dist/poly-extrude.mjs

@@ -1,5 +1,5 @@
 /*!
- * poly-extrude v0.0.1
+ * poly-extrude v0.0.4
   */
 var earcut$2 = {exports: {}};
 
@@ -725,8 +725,9 @@ function generateNormal(indices, position) {
   var n = [];
   var len = indices.length;
   var normals = new Float32Array(position.length);
+  var f = 0;
 
-  for (var f = 0; f < len; f += 3) {
+  while (f < len) {
     // const i1 = indices[f++] * 3;
     // const i2 = indices[f++] * 3;
     // const i3 = indices[f++] * 3;
@@ -741,30 +742,30 @@ function generateNormal(indices, position) {
         i3 = c * 3;
     v3Set(p1, position[i1], position[i1 + 1], position[i1 + 2]);
     v3Set(p2, position[i2], position[i2 + 1], position[i2 + 2]);
-    v3Set(p3, position[i3], position[i3 + 1], position[i3 + 2]); // pA.fromBufferAttribute(positionAttribute, vA);
-    // pB.fromBufferAttribute(positionAttribute, vB);
-    // pC.fromBufferAttribute(positionAttribute, vC);
-    // cb.subVectors(pC, pB);
-    // ab.subVectors(pA, pB);
-    // cb.cross(ab);
-
+    v3Set(p3, position[i3], position[i3 + 1], position[i3 + 2]);
     v3Sub(v32, p3, p2);
     v3Sub(v21, p1, p2);
     v3Cross(n, v32, v21); // Already be weighted by the triangle area
 
-    for (var i = 0; i < 3; i++) {
-      normals[i1 + i] += n[i];
-      normals[i2 + i] += n[i];
-      normals[i3 + i] += n[i];
+    for (var _i = 0; _i < 3; _i++) {
+      normals[i1 + _i] += n[_i];
+      normals[i2 + _i] += n[_i];
+      normals[i3 + _i] += n[_i];
     }
+
+    f += 3;
   }
 
-  for (var _i = 0; _i < normals.length; _i += 3) {
-    v3Set(n, normals[_i], normals[_i + 1], normals[_i + 2]);
+  var i = 0;
+  var l = normals.length;
+
+  while (i < l) {
+    v3Set(n, normals[i], normals[i + 1], normals[i + 2]);
     v3Normalize(n, n);
-    normals[_i] = n[0] || 1;
-    normals[_i + 1] = n[1] || 1;
-    normals[_i + 2] = n[2] || 1;
+    normals[i] = n[0] || 0;
+    normals[i + 1] = n[1] || 0;
+    normals[i + 2] = n[2] || 0;
+    i += 3;
   }
 
   return normals;
@@ -813,11 +814,14 @@ function merge(results) {
     result.position.set(_position, pOffset);
     result.normal.set(normal, pOffset);
     result.uv.set(uv, uvOffset);
+    var j = 0;
+    var len1 = _indices.length;
 
-    for (var j = 0, len1 = _indices.length; j < len1; j++) {
+    while (j < len1) {
       var pIndex = _indices[j] + pCount;
       result.indices[iIdx] = pIndex;
       iIdx++;
+      j++;
     }
 
     uvOffset += uv.length;
@@ -835,39 +839,33 @@ function degToRad(angle) {
 } // https://github.com/mrdoob/three.js/blob/16f13e3b07e31d0e9a00df7c3366bbe0e464588c/src/geometries/ExtrudeGeometry.js?_pjax=%23js-repo-pjax-container#L736
 
 function generateSideWallUV(uvs, vertices, indexA, indexB, indexC, indexD) {
-  var a_x = vertices[indexA * 3];
-  var a_y = vertices[indexA * 3 + 1];
-  var a_z = vertices[indexA * 3 + 2];
-  var b_x = vertices[indexB * 3];
-  var b_y = vertices[indexB * 3 + 1];
-  var b_z = vertices[indexB * 3 + 2];
-  var c_x = vertices[indexC * 3];
-  var c_y = vertices[indexC * 3 + 1];
-  var c_z = vertices[indexC * 3 + 2];
-  var d_x = vertices[indexD * 3];
-  var d_y = vertices[indexD * 3 + 1];
-  var d_z = vertices[indexD * 3 + 2];
+  var idx1 = indexA * 3,
+      idx2 = indexB * 3,
+      idx3 = indexC * 3,
+      idx4 = indexD * 3;
+  var a_x = vertices[idx1];
+  var a_y = vertices[idx1 + 1];
+  var a_z = vertices[idx1 + 2];
+  var b_x = vertices[idx2];
+  var b_y = vertices[idx2 + 1];
+  var b_z = vertices[idx2 + 2];
+  var c_x = vertices[idx3];
+  var c_y = vertices[idx3 + 1];
+  var c_z = vertices[idx3 + 2];
+  var d_x = vertices[idx4];
+  var d_y = vertices[idx4 + 1];
+  var d_z = vertices[idx4 + 2];
 
   if (Math.abs(a_y - b_y) < Math.abs(a_x - b_x)) {
     uvs.push(a_x, 1 - a_z);
     uvs.push(b_x, 1 - b_z);
     uvs.push(c_x, 1 - c_z);
-    uvs.push(d_x, 1 - d_z); // return [
-    //     new Vector2(a_x, 1 - a_z),
-    //     new Vector2(b_x, 1 - b_z),
-    //     new Vector2(c_x, 1 - c_z),
-    //     new Vector2(d_x, 1 - d_z)
-    // ];
+    uvs.push(d_x, 1 - d_z);
   } else {
     uvs.push(a_y, 1 - a_z);
     uvs.push(b_y, 1 - b_z);
     uvs.push(c_y, 1 - c_z);
-    uvs.push(d_y, 1 - d_z); // return [
-    //     new Vector2(a_y, 1 - a_z),
-    //     new Vector2(b_y, 1 - b_z),
-    //     new Vector2(c_y, 1 - c_z),
-    //     new Vector2(d_y, 1 - d_z)
-    // ];
+    uvs.push(d_y, 1 - d_z);
   }
 }
 
@@ -900,10 +898,7 @@ function extrudePolygons(polygons, options) {
     });
     var result = flatVertices(polygon, options);
     result.polygon = polygon;
-    var time = 'earcut';
-    console.time(time);
     var triangles = earcut$1(result.flatVertices, result.holes, 2);
-    console.timeEnd(time);
     generateTopAndBottom$1(result, triangles);
     generateSides$1(result, options);
     result.position = new Float32Array(result.points);
@@ -951,29 +946,32 @@ function generateSides$1(result, options) {
 
   for (var i = 0, len = polygon.length; i < len; i++) {
     var ring = polygon[i];
+    var j = 0;
+    var len1 = ring.length;
 
-    for (var j = 0, len1 = ring.length; j < len1; j++) {
+    while (j < len1) {
       var v1 = ring[j];
       var v2 = ring[j + 1];
 
       if (j === len1 - 1) {
         v2 = ring[0];
-      } // const p1 = [v1[0], v1[1], options.depth],
-      //     p2 = [v2[0], v2[1], options.depth],
-      //     p3 = [v1[0], v1[1], 0],
-      //     p4 = [v2[0], v2[1], 0];
-
+      }
 
       var idx = points.length / 3;
-      points.push(v1[0], v1[1], 0, v2[0], v2[1], 0, v1[0], v1[1], z, v2[0], v2[1], z);
+      var x1 = v1[0],
+          y1 = v1[1],
+          x2 = v2[0],
+          y2 = v2[1];
+      points.push(x1, y1, 0, x2, y2, 0, x1, y1, z, x2, y2, z);
       var a = idx,
           b = idx + 1,
           c = idx + 2,
           d = idx + 3; // points.push(p3, p4, p1, p2);
 
-      index.push(a, c, b);
-      index.push(c, d, b);
+      index.push(a, c, b, c, d, b); // index.push(c, d, b);
+
       generateSideWallUV(uvs, points, a, b, c, d);
+      j++;
     }
   }
 }
@@ -1012,7 +1010,10 @@ function flatVertices(polygon, options) {
       holes.push(idx0 / 2);
     }
 
-    for (var j = 0, len1 = ring.length; j < len1; j++) {
+    var j = 0;
+    var len1 = ring.length;
+
+    while (j < len1) {
       var c = ring[j];
       var x = c[0],
           y = c[1];
@@ -1032,6 +1033,7 @@ function flatVertices(polygon, options) {
       uvs[uOffset + idx2 + 1] = y;
       idx1 += 3;
       idx2 += 2;
+      j++;
     }
   }
 
@@ -1072,8 +1074,10 @@ function generateTopAndBottom(result, options) {
       uvs = [];
   var leftPoints = result.leftPoints,
       rightPoints = result.rightPoints;
+  var i = 0,
+      len = leftPoints.length;
 
-  for (var i = 0, len = leftPoints.length; i < len; i++) {
+  while (i < len) {
     // top left
     var idx0 = i * 3;
     var _leftPoints$i = leftPoints[i],
@@ -1100,32 +1104,41 @@ function generateTopAndBottom(result, options) {
     points[idx3] = x2;
     points[idx3 + 1] = y2;
     points[idx3 + 2] = 0;
+    i++;
   }
 
-  for (var _i = 0, _len = points.length; _i < _len; _i += 3) {
-    var x = points[_i],
-        y = points[_i + 1];
+  i = 0;
+  len = points.length;
+
+  while (i < len) {
+    var x = points[i],
+        y = points[i + 1];
     uvs.push(x, y);
+    i += 3;
   }
 
-  for (var _i2 = 0, _len2 = leftPoints.length; _i2 < _len2 - 1; _i2++) {
+  i = 0;
+  len = leftPoints.length;
+
+  while (i < len - 1) {
     // top
     // left1 left2 right1,right2
-    var a1 = _i2,
-        b1 = _i2 + 1,
-        c1 = a1 + _len2,
-        d1 = b1 + _len2;
+    var a1 = i,
+        b1 = i + 1,
+        c1 = a1 + len,
+        d1 = b1 + len;
     index.push(a1, c1, b1);
     index.push(c1, d1, b1); // bottom
     // left1 left2 right1,right2
 
-    var len2 = _len2 * 2;
-    var a2 = _i2 + len2,
+    var len2 = len * 2;
+    var a2 = i + len2,
         b2 = a2 + 1,
-        c2 = a2 + _len2,
-        d2 = b2 + _len2;
+        c2 = a2 + len,
+        d2 = b2 + len;
     index.push(a2, c2, b2);
     index.push(c2, d2, b2);
+    i++;
   }
 
   result.index = index;
@@ -1148,14 +1161,12 @@ function generateSides(result, options) {
     var a = idx,
         b = idx + 1,
         c = idx + 2,
-        d = idx + 3; // points.push(p3, p4, p1, p2);
-
-    index.push(a, c, b);
-    index.push(c, d, b);
+        d = idx + 3;
+    index.push(a, c, b, c, d, b);
     generateSideWallUV(uvs, points, a, b, c, d);
   }
 
-  for (var i = 0, _len3 = rings.length; i < _len3; i++) {
+  for (var i = 0, _len = rings.length; i < _len; i++) {
     var ring = rings[i];
 
     if (i > 0) {
@@ -1165,19 +1176,23 @@ function generateSides(result, options) {
       ring = ring.reverse();
     }
 
-    for (var j = 0, len1 = ring.length - 1; j < len1; j++) {
+    var j = 0;
+    var len1 = ring.length - 1;
+
+    while (j < len1) {
       var v1 = ring[j];
       var v2 = ring[j + 1];
       addOneSideIndex(v1, v2);
+      j++;
     }
   }
 
   var len = leftPoints.length;
   var vs = [rightPoints[0], leftPoints[0], leftPoints[len - 1], rightPoints[len - 1]];
 
-  for (var _i3 = 0; _i3 < vs.length; _i3 += 2) {
-    var _v = vs[_i3],
-        _v2 = vs[_i3 + 1];
+  for (var _i = 0; _i < vs.length; _i += 2) {
+    var _v = vs[_i],
+        _v2 = vs[_i + 1];
     addOneSideIndex(_v, _v2);
   }
 }
@@ -1198,8 +1213,9 @@ function expandLine(line, options) {
       leftPoints = [],
       rightPoints = [];
   var len = line.length;
+  var i = 0;
 
-  for (var i = 0; i < len - 1; i++) {
+  while (i < len - 1) {
     var _p = line[i],
         _p2 = line[i + 1];
     var dy = _p2[1] - _p[1],
@@ -1237,6 +1253,8 @@ function expandLine(line, options) {
       leftPoints.push(_op2);
       rightPoints.push(_op);
     }
+
+    i++;
   }
 
   var rAngle = preAngle;
@@ -1301,5 +1319,3 @@ function leftOnLine(p, p1, p2) {
 }
 
 export { extrudePolygons, extrudePolylines };
-
-typeof console !== 'undefined' && console.log('poly-extrude v0.0.1');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poly-extrude",
-  "version": "0.0.1",
+  "version": "0.0.4",
   "description": "",
   "main": "dist/poly-extrude.js",
   "module": "dist/poly-extrude.mjs",
@@ -38,5 +38,10 @@
   },
   "dependencies": {
     "earcut": "^2.2.3"
-  }
+  },
+  "files": [
+    "dist/",
+    "src/",
+    "index.js"
+  ]
 }

package/src/polygon.js

@@ -22,10 +22,7 @@ export function extrudePolygons(polygons, options) {
         });
         const result = flatVertices(polygon, options);
         result.polygon = polygon;
-        const time = 'earcut';
-        console.time(time);
         const triangles = earcut(result.flatVertices, result.holes, 2);
-        console.timeEnd(time);
         generateTopAndBottom(result, triangles);
         generateSides(result, options);
         result.position = new Float32Array(result.points);
@@ -64,24 +61,24 @@ function generateSides(result, options) {
     const z = options.depth;
     for (let i = 0, len = polygon.length; i < len; i++) {
         const ring = polygon[i];
-        for (let j = 0, len1 = ring.length; j < len1; j++) {
+        let j = 0;
+        const len1 = ring.length;
+        while (j < len1) {
             const v1 = ring[j];
             let v2 = ring[j + 1];
             if (j === len1 - 1) {
                 v2 = ring[0];
             }
-            // const p1 = [v1[0], v1[1], options.depth],
-            //     p2 = [v2[0], v2[1], options.depth],
-            //     p3 = [v1[0], v1[1], 0],
-            //     p4 = [v2[0], v2[1], 0];
             const idx = points.length / 3;
-            points.push(v1[0], v1[1], 0, v2[0], v2[1], 0, v1[0], v1[1], z, v2[0], v2[1], z);
+            const x1 = v1[0], y1 = v1[1], x2 = v2[0], y2 = v2[1];
+            points.push(x1, y1, 0, x2, y2, 0, x1, y1, z, x2, y2, z);
             const a = idx, b = idx + 1, c = idx + 2, d = idx + 3;
             // points.push(p3, p4, p1, p2);
-            index.push(a, c, b);
-            index.push(c, d, b);
+            index.push(a, c, b, c, d, b);
+            // index.push(c, d, b);
 
             generateSideWallUV(uvs, points, a, b, c, d);
+            j++;
         }
     }
 }
@@ -110,7 +107,9 @@ function flatVertices(polygon, options) {
         if (i > 0) {
             holes.push(idx0 / 2);
         }
-        for (let j = 0, len1 = ring.length; j < len1; j++) {
+        let j = 0;
+        const len1 = ring.length;
+        while (j < len1) {
             const c = ring[j];
             const x = c[0], y = c[1];
 
@@ -135,6 +134,7 @@ function flatVertices(polygon, options) {
 
             idx1 += 3;
             idx2 += 2;
+            j++;
         }
     }
     return {

package/src/polyline.js

@@ -22,7 +22,8 @@ function generateTopAndBottom(result, options) {
     const z = options.depth;
     const points = [], index = [], uvs = [];
     const { leftPoints, rightPoints } = result;
-    for (let i = 0, len = leftPoints.length; i < len; i++) {
+    let i = 0, len = leftPoints.length;
+    while (i < len) {
         // top left
         const idx0 = i * 3;
         const [x1, y1] = leftPoints[i];
@@ -48,12 +49,19 @@ function generateTopAndBottom(result, options) {
         points[idx3] = x2;
         points[idx3 + 1] = y2;
         points[idx3 + 2] = 0;
+
+        i++;
     }
-    for (let i = 0, len = points.length; i < len; i += 3) {
+    i = 0;
+    len = points.length;
+    while (i < len) {
         const x = points[i], y = points[i + 1];
         uvs.push(x, y);
+        i += 3;
     }
-    for (let i = 0, len = leftPoints.length; i < len - 1; i++) {
+    i = 0;
+    len = leftPoints.length;
+    while (i < len - 1) {
         // top
         // left1 left2 right1,right2
         const a1 = i, b1 = i + 1, c1 = a1 + len, d1 = b1 + len;
@@ -66,6 +74,7 @@ function generateTopAndBottom(result, options) {
         const a2 = i + len2, b2 = a2 + 1, c2 = a2 + len, d2 = b2 + len;
         index.push(a2, c2, b2);
         index.push(c2, d2, b2);
+        i++;
     }
     result.index = index;
     result.points = points;
@@ -76,13 +85,12 @@ function generateSides(result, options) {
     const { points, index, leftPoints, rightPoints, uvs } = result;
     const z = options.depth;
     const rings = [leftPoints, rightPoints];
+
     function addOneSideIndex(v1, v2) {
         const idx = points.length / 3;
         points.push(v1[0], v1[1], 0, v2[0], v2[1], 0, v1[0], v1[1], z, v2[0], v2[1], z);
         const a = idx, b = idx + 1, c = idx + 2, d = idx + 3;
-        // points.push(p3, p4, p1, p2);
-        index.push(a, c, b);
-        index.push(c, d, b);
+        index.push(a, c, b, c, d, b);
         generateSideWallUV(uvs, points, a, b, c, d);
     }
 
@@ -94,10 +102,13 @@ function generateSides(result, options) {
             });
             ring = ring.reverse();
         }
-        for (let j = 0, len1 = ring.length - 1; j < len1; j++) {
+        let j = 0;
+        const len1 = ring.length - 1;
+        while (j < len1) {
             const v1 = ring[j];
             const v2 = ring[j + 1];
             addOneSideIndex(v1, v2);
+            j++;
         }
     }
     const len = leftPoints.length;
@@ -115,7 +126,8 @@ function expandLine(line, options) {
     const radius = options.lineWidth / 2;
     const points = [], leftPoints = [], rightPoints = [];
     const len = line.length;
-    for (let i = 0; i < len - 1; i++) {
+    let i = 0;
+    while (i < len - 1) {
         const p1 = line[i],
             p2 = line[i + 1];
         const dy = p2[1] - p1[1],
@@ -146,6 +158,7 @@ function expandLine(line, options) {
             leftPoints.push(op2);
             rightPoints.push(op1);
         }
+        i++;
     }
     let rAngle = preAngle;
     rAngle -= 90;

package/src/util.js

@@ -64,8 +64,9 @@ export function generateNormal(indices, position) {
 
     const len = indices.length;
     const normals = new Float32Array(position.length);
+    let f = 0;
+    while (f < len) {
 
-    for (let f = 0; f < len; f += 3) {
         // const i1 = indices[f++] * 3;
         // const i2 = indices[f++] * 3;
         // const i3 = indices[f++] * 3;
@@ -79,13 +80,6 @@ export function generateNormal(indices, position) {
         v3Set(p2, position[i2], position[i2 + 1], position[i2 + 2]);
         v3Set(p3, position[i3], position[i3 + 1], position[i3 + 2]);
 
-        // pA.fromBufferAttribute(positionAttribute, vA);
-        // pB.fromBufferAttribute(positionAttribute, vB);
-        // pC.fromBufferAttribute(positionAttribute, vC);
-
-        // cb.subVectors(pC, pB);
-        // ab.subVectors(pA, pB);
-        // cb.cross(ab);
         v3Sub(v32, p3, p2);
         v3Sub(v21, p1, p2);
         v3Cross(n, v32, v21);
@@ -95,15 +89,18 @@ export function generateNormal(indices, position) {
             normals[i2 + i] += n[i];
             normals[i3 + i] += n[i];
         }
+        f += 3;
     }
 
-    for (let i = 0; i < normals.length; i += 3) {
+    let i = 0;
+    const l = normals.length;
+    while (i < l) {
         v3Set(n, normals[i], normals[i + 1], normals[i + 2]);
         v3Normalize(n, n);
-        normals[i] = n[0] || 1;
-        normals[i + 1] = n[1] || 1;
-        normals[i + 2] = n[2] || 1;
-
+        normals[i] = n[0] || 0;
+        normals[i + 1] = n[1] || 0;
+        normals[i + 2] = n[2] || 0;
+        i += 3;
     }
 
     return normals;
@@ -139,10 +136,13 @@ export function merge(results) {
         result.position.set(position, pOffset);
         result.normal.set(normal, pOffset);
         result.uv.set(uv, uvOffset);
-        for (let j = 0, len1 = indices.length; j < len1; j++) {
+        let j = 0;
+        const len1 = indices.length;
+        while (j < len1) {
             const pIndex = indices[j] + pCount;
             result.indices[iIdx] = pIndex;
             iIdx++;
+            j++;
         }
         uvOffset += uv.length;
         pOffset += position.length;
@@ -162,18 +162,19 @@ export function degToRad(angle) {
 // https://github.com/mrdoob/three.js/blob/16f13e3b07e31d0e9a00df7c3366bbe0e464588c/src/geometries/ExtrudeGeometry.js?_pjax=%23js-repo-pjax-container#L736
 export function generateSideWallUV(uvs, vertices, indexA, indexB, indexC, indexD) {
 
-    const a_x = vertices[indexA * 3];
-    const a_y = vertices[indexA * 3 + 1];
-    const a_z = vertices[indexA * 3 + 2];
-    const b_x = vertices[indexB * 3];
-    const b_y = vertices[indexB * 3 + 1];
-    const b_z = vertices[indexB * 3 + 2];
-    const c_x = vertices[indexC * 3];
-    const c_y = vertices[indexC * 3 + 1];
-    const c_z = vertices[indexC * 3 + 2];
-    const d_x = vertices[indexD * 3];
-    const d_y = vertices[indexD * 3 + 1];
-    const d_z = vertices[indexD * 3 + 2];
+    const idx1 = indexA * 3, idx2 = indexB * 3, idx3 = indexC * 3, idx4 = indexD * 3;
+    const a_x = vertices[idx1];
+    const a_y = vertices[idx1 + 1];
+    const a_z = vertices[idx1 + 2];
+    const b_x = vertices[idx2];
+    const b_y = vertices[idx2 + 1];
+    const b_z = vertices[idx2 + 2];
+    const c_x = vertices[idx3];
+    const c_y = vertices[idx3 + 1];
+    const c_z = vertices[idx3 + 2];
+    const d_x = vertices[idx4];
+    const d_y = vertices[idx4 + 1];
+    const d_z = vertices[idx4 + 2];
 
     if (Math.abs(a_y - b_y) < Math.abs(a_x - b_x)) {
 
@@ -181,25 +182,11 @@ export function generateSideWallUV(uvs, vertices, indexA, indexB, indexC, indexD
         uvs.push(b_x, 1 - b_z);
         uvs.push(c_x, 1 - c_z);
         uvs.push(d_x, 1 - d_z);
-        // return [
-        //     new Vector2(a_x, 1 - a_z),
-        //     new Vector2(b_x, 1 - b_z),
-        //     new Vector2(c_x, 1 - c_z),
-        //     new Vector2(d_x, 1 - d_z)
-        // ];
-
     } else {
         uvs.push(a_y, 1 - a_z);
         uvs.push(b_y, 1 - b_z);
         uvs.push(c_y, 1 - c_z);
         uvs.push(d_y, 1 - d_z);
-        // return [
-        //     new Vector2(a_y, 1 - a_z),
-        //     new Vector2(b_y, 1 - b_z),
-        //     new Vector2(c_y, 1 - c_z),
-        //     new Vector2(d_y, 1 - d_z)
-        // ];
-
     }
 
 }

package/.eslintignore

@@ -1,12 +0,0 @@
-src/vendor
-dist
-src/libs
-build.js
-ftp.js
-clean.js
-siteclean.js
-gulpfile.js
-src/lib
-src/data
-src/GLTFLoader.js
-

package/.eslintrc.js

@@ -1,34 +0,0 @@
-module.exports = {
-    "env": {
-        "browser": true,
-        "es6": true,
-        "node": true
-    },
-    "extends": "standard",
-    "globals": {
-        "Atomics": "readonly",
-        "SharedArrayBuffer": "readonly",
-        "AMap": true,
-        "mapboxgl": true,
-        "TMap": true
-    },
-    "parserOptions": {
-        "ecmaVersion": 2018,
-        "sourceType": "module"
-    },
-    "rules": {
-        "no-console": "off",
-        "no-inner-declarations": "off",
-        "semi": ["error", "always"],
-        "indent": 0,
-        "padded-blocks": 0,
-        "space-before-function-paren": 0,
-        "no-var": 1,
-        "dot-notation": 0,
-        "one-var": 0,
-        "new-cap": 0,
-        "quote-props": 0,
-        "camelcase": 0,
-        "wrap-iife": 0
-    }
-};

package/.vscode/settings.json

@@ -1,3 +0,0 @@
-{
-    "liveServer.settings.port": 5501
-}