es6-fuzz 5.0.0 → 5.0.1

package/Readme.md

@@ -114,7 +114,7 @@ monsterBiteTest(jsBoonInput)
 
 ## development
 
-**Tests** use mocha and a plugin for traceur
+**Tests** use node internal testing framework
 
 ```
 npm test

package/docs/CHANGELOG.md

@@ -1,8 +1,12 @@
 2025-06-26
 ==========
 
-  * 5.0.0
+  * 5.0.1
+  * refactor: cleanup of test files
+  * chore: remove unused test
+  * docs: add correct name of test framework
   * (churn): changelog
+  * 5.0.0
   * 4.0.4
   * fix: edge cases
   * 4.0.3
@@ -156,7 +160,3 @@
   * Changelog
   * Added changelog link
   * 2.6.1
-  * Docs
-  * 2.6.0
-  * Added link to api docs
-  * More docs

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "es6-fuzz",
   "description": "fuzzy logic with and for es6",
-  "version": "5.0.0",
+  "version": "5.0.1",
   "main": "lib/logic.js",
   "repository": "git@github.com:sebs/es6-fuzz.git",
   "homepage": "https://github.com/sebs/es6-fuzz",
   "scripts": {
     "changelog": "rm ./docs/CHANGELOG.md && npx changelog https://github.com/sebs/es6-fuzz all > ./docs/CHANGELOG.md && git add . && git commit . -m '(churn): changelog'",
-    "test": "node --test",
-    "test:watch": "node --test --watch",
+    "test": "node --test ./test/*.test.js ./test/**/*.test.js ./test/curve/**/*.test.js",
+    "test:watch": "node --test --watch ./test/*.test.js ./test/**/*.test.js ./test/curve/**/*.test.js",
     "addpush": "git add . && git commit . -m 'docs'",
     "pages": "node ./scripts/publish-gh.js",
     "docs": "jsdoc -c ./jsdoc.json -t ./node_modules/ink-docstrap/template -R ./Readme.md -u ./docs",

package/test/curve/{grade.js → grade.test.js}

@@ -8,8 +8,15 @@ describe('Grade', function() {
     assert.equal(typeof Grade, 'function');
   });
   it('can create a new instance', function() {
+    var grade = new Grade(0, 1);
+    assert.ok(grade instanceof Grade);
+  });
+  it('sets x0 property correctly', function() {
     var grade = new Grade(0, 1);
     assert.equal(grade.x0, 0);
+  });
+  it('sets x1 property correctly', function() {
+    var grade = new Grade(0, 1);
     assert.equal(grade.x1, 1);
   });
   it('fuzzify', function() {

package/test/curve/{reverse-grade.js → reverse-grade.test.js}

@@ -8,8 +8,15 @@ describe('ReverseGrade', function() {
     assert.equal(typeof ReverseGrade, 'function');
   });
   it('can create a new instance', function() {
+    var reverseGrade = new ReverseGrade(0, 1);
+    assert.ok(reverseGrade instanceof ReverseGrade);
+  });
+  it('sets x0 property correctly', function() {
     var reverseGrade = new ReverseGrade(0, 1);
     assert.equal(reverseGrade.x0, 0);
+  });
+  it('sets x1 property correctly', function() {
+    var reverseGrade = new ReverseGrade(0, 1);
     assert.equal(reverseGrade.x1, 1);
   });
   it('fuzzify', function() {

package/test/curve/{shape.js → shape.test.js}

@@ -8,10 +8,23 @@ describe('Shape', function() {
     assert.equal(typeof Shape, 'function');
   });
   it('can create a new instance', function() {
+    var shape = new Shape(0, 1, 2, 3);
+    assert.ok(shape instanceof Shape);
+  });
+  it('sets x0 property correctly', function() {
     var shape = new Shape(0, 1, 2, 3);
     assert.equal(shape.x0, 0);
+  });
+  it('sets x1 property correctly', function() {
+    var shape = new Shape(0, 1, 2, 3);
     assert.equal(shape.x1, 1);
+  });
+  it('sets x2 property correctly', function() {
+    var shape = new Shape(0, 1, 2, 3);
     assert.equal(shape.x2, 2);
+  });
+  it('sets x3 property correctly', function() {
+    var shape = new Shape(0, 1, 2, 3);
     assert.equal(shape.x3, 3);
   });
 });

package/test/curve/sigmoid/sigmoid-basic.test.js

@@ -0,0 +1,27 @@
+'use strict';
+const { describe, it } = require('node:test');
+const Sigmoid = require('../../../lib/curve/sigmoid');
+const assert = require('assert');
+
+describe('Sigmoid', function() {
+  it('is a function', function() {
+    assert.equal(typeof Sigmoid, 'function');
+  });
+  it('can create a new instance', function() {
+    var sigmoid = new Sigmoid();
+    var res = sigmoid.fuzzify(5);
+    assert.equal(res, 0.9933071490757153);
+  });
+
+  it('0', function() {
+    var sigmoid = new Sigmoid();
+    var res = sigmoid.fuzzify(0);
+    assert.equal(res, 0.5);
+  });
+
+  it('uses treshold', function() {
+    var sigmoid = new Sigmoid(1);
+    var res = sigmoid.fuzzify(1);
+    assert.equal(res, 0.5);
+  });
+});

package/test/curve/sigmoid/sigmoid-center-behavior.test.js

@@ -0,0 +1,66 @@
+'use strict';
+const { describe, it } = require('node:test');
+const Sigmoid = require('../../../lib/curve/sigmoid');
+const assert = require('assert');
+
+describe('center parameter behavior', function() {
+  it('should return 0.5 at the center for positive center values', function() {
+    var sigmoid = new Sigmoid(2, 1);
+    var res = sigmoid.fuzzify(2);
+    assert.equal(res, 0.5);
+  });
+
+  it('should return value greater than 0.5 for values right of positive center', function() {
+    var sigmoid = new Sigmoid(2, 1);
+    var rightOfCenter = sigmoid.fuzzify(4);
+    assert(rightOfCenter > 0.5);
+  });
+
+  it('should return value less than 1 for values right of positive center', function() {
+    var sigmoid = new Sigmoid(2, 1);
+    var rightOfCenter = sigmoid.fuzzify(4);
+    assert(rightOfCenter < 1);
+  });
+
+  it('should return value less than 0.5 for values left of positive center', function() {
+    var sigmoid = new Sigmoid(2, 1);
+    var leftOfCenter = sigmoid.fuzzify(0);
+    assert(leftOfCenter < 0.5);
+  });
+
+  it('should return value greater than 0 for values left of positive center', function() {
+    var sigmoid = new Sigmoid(2, 1);
+    var leftOfCenter = sigmoid.fuzzify(0);
+    assert(leftOfCenter > 0);
+  });
+
+  it('should correctly handle negative center values', function() {
+    var sigmoid = new Sigmoid(-3, 1);
+    
+    // With center=-3, the sigmoid is centered at x=-3
+    // So sigmoid.fuzzify(-3) should return 0.5
+    var res = sigmoid.fuzzify(-3);
+    assert.equal(res, 0.5);
+  });
+
+  it('sigmoid should be 0.075 at zero', function() {
+    // Test that verifies the sigmoid value at x=0 when center=5
+    var sigmoid = new Sigmoid(5, 2);
+    var atZero = sigmoid.fuzzify(0);
+    assert.equal(atZero, 0.07585818002124355);
+  });
+
+  it('should return 0.5 at center point for symmetry', function() {
+    var sigmoid = new Sigmoid(5, 2);
+    var atCenter = sigmoid.fuzzify(5);
+    assert.equal(atCenter, 0.5);
+  });
+
+  it('should be symmetric around center point', function() {
+    var sigmoid = new Sigmoid(5, 2);
+    var rightPoint = sigmoid.fuzzify(7); // 2 units right of center
+    var leftPoint = sigmoid.fuzzify(3);  // 2 units left of center
+    var sum = rightPoint + leftPoint;
+    assert(Math.abs(sum - 1) < 0.0000001, `Sum ${sum} should be approximately 1`);
+  });
+});

package/test/curve/sigmoid/sigmoid-slope.test.js

@@ -0,0 +1,15 @@
+'use strict';
+const { describe, it } = require('node:test');
+const Sigmoid = require('../../../lib/curve/sigmoid');
+const assert = require('assert');
+
+describe('slope', function() {
+  it('slope makes actually a difference', function() {
+    const fvalue = 10;
+    var sigmoid = new Sigmoid(0, 10);
+    var resSmall = sigmoid.fuzzify(fvalue);
+    var sigmoid2 = new Sigmoid(0, 100000);
+    var resBig = sigmoid2.fuzzify(fvalue);
+    assert.notEqual(resSmall, resBig);
+  });
+});

package/test/curve/{trapezoid.js → trapezoid/trapezoid-basic.test.js}

@@ -1,6 +1,6 @@
 'use strict';
 const { describe, it } = require('node:test');
-const Trapezoid = require('../../lib/curve/trapezoid');
+const Trapezoid = require('../../../lib/curve/trapezoid');
 const assert = require('assert');
 
 describe('Trapezoid', function() {
@@ -8,9 +8,19 @@ describe('Trapezoid', function() {
     assert.equal(typeof Trapezoid, 'function');
   });
   it('can create a new instance', function() {
+    var trapez = new Trapezoid(0, 10, 20);
+    assert.ok(trapez instanceof Trapezoid);
+  });
+  it('sets x0 property correctly', function() {
     var trapez = new Trapezoid(0, 10, 20);
     assert.equal(trapez.x0, 0);
+  });
+  it('sets x1 property correctly', function() {
+    var trapez = new Trapezoid(0, 10, 20);
     assert.equal(trapez.x1, 10);
+  });
+  it('sets x2 property correctly', function() {
+    var trapez = new Trapezoid(0, 10, 20);
     assert.equal(trapez.x2, 20);
   });
   it('fuzzify', function() {
@@ -41,31 +51,4 @@ describe('Trapezoid', function() {
     var res = trapez.fuzzify(1.5);
     assert.equal(res, 1);
   });
-  
-
-  describe('bounds', ()=>{
-    it('trapezoid left bounds 0', function() {
-      var trapez = new Trapezoid(20, 30, 90, 100);
-      var res = trapez.fuzzify(20);
-      assert.equal(res, 0);
-    });
-  
-    it('trapezoid right bounds 0', function() {
-      var trapez = new Trapezoid(20, 30, 90, 100);
-      var res = trapez.fuzzify(100);
-      assert.equal(res, 0);
-    });
-    
-    it('trapezoid left top = 1', function() {
-      var trapez = new Trapezoid(20, 30, 90, 100);
-      var res = trapez.fuzzify(30);
-      assert.equal(res, 1);
-    });
-    
-    it('trapezoid right top = 1', function() {
-      var trapez = new Trapezoid(20, 30, 90, 100);
-      var res = trapez.fuzzify(90);
-      assert.equal(res, 1);
-    });
-  });
 });

package/test/curve/trapezoid/trapezoid-bounds.test.js

@@ -0,0 +1,30 @@
+'use strict';
+const { describe, it } = require('node:test');
+const Trapezoid = require('../../../lib/curve/trapezoid');
+const assert = require('assert');
+
+describe('bounds', ()=>{
+  it('trapezoid left bounds 0', function() {
+    var trapez = new Trapezoid(20, 30, 90, 100);
+    var res = trapez.fuzzify(20);
+    assert.equal(res, 0);
+  });
+
+  it('trapezoid right bounds 0', function() {
+    var trapez = new Trapezoid(20, 30, 90, 100);
+    var res = trapez.fuzzify(100);
+    assert.equal(res, 0);
+  });
+  
+  it('trapezoid left top = 1', function() {
+    var trapez = new Trapezoid(20, 30, 90, 100);
+    var res = trapez.fuzzify(30);
+    assert.equal(res, 1);
+  });
+  
+  it('trapezoid right top = 1', function() {
+    var trapez = new Trapezoid(20, 30, 90, 100);
+    var res = trapez.fuzzify(90);
+    assert.equal(res, 1);
+  });
+});

package/test/edge-cases/constant-edge-values.test.js

@@ -0,0 +1,56 @@
+'use strict';
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const Constant = require('../../lib/curve/constant');
+
+describe('Constant edge values', function() {
+  describe('all possible constant values', function() {
+    it('should return 0 for constant value 0', function() {
+      assert.equal(new Constant(0).fuzzify(), 0);
+    });
+    
+    it('should return 0.5 for constant value 0.5', function() {
+      assert.equal(new Constant(0.5).fuzzify(), 0.5);
+    });
+    
+    it('should return 1 for constant value 1', function() {
+      assert.equal(new Constant(1).fuzzify(), 1);
+    });
+    
+    it('should return -1 for constant value -1', function() {
+      assert.equal(new Constant(-1).fuzzify(), -1);
+    });
+    
+    it('should return 2 for constant value 2', function() {
+      assert.equal(new Constant(2).fuzzify(), 2);
+    });
+    
+    it('should return -0.5 for constant value -0.5', function() {
+      assert.equal(new Constant(-0.5).fuzzify(), -0.5);
+    });
+    
+    it('should return 1.5 for constant value 1.5', function() {
+      assert.equal(new Constant(1.5).fuzzify(), 1.5);
+    });
+  });
+
+  describe('ignoring x parameter in fuzzify', function() {
+    const constant = new Constant(0.7);
+    
+    it('should return constant value for x=0', function() {
+      assert.equal(constant.fuzzify(0), 0.7);
+    });
+    
+    it('should return constant value for x=100', function() {
+      assert.equal(constant.fuzzify(100), 0.7);
+    });
+    
+    it('should return constant value for x=-100', function() {
+      assert.equal(constant.fuzzify(-100), 0.7);
+    });
+    
+    it('should return constant value for x=Infinity', function() {
+      assert.equal(constant.fuzzify(Infinity), 0.7);
+    });
+  });
+});

package/test/edge-cases/fuzzy-function-edge-cases.test.js

@@ -0,0 +1,71 @@
+'use strict';
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const FuzzyFunction = require('../../lib/curve/fuzzy-function');
+
+describe('FuzzyFunction edge cases', function() {
+  describe('functions returning values outside [0,1]', function() {
+    describe('function returning > 1 for x > 0.5', function() {
+      const func1 = new FuzzyFunction(x => x * 2);
+      
+      it('should return valid value for x=0.3', function() {
+        assert.equal(func1.fuzzify(0.3), 0.6);
+      });
+      
+      it('should return exactly 1 for x=0.5', function() {
+        assert.equal(func1.fuzzify(0.5), 1);
+      });
+      
+      it('should throw error for x=0.7', function() {
+        assert.throws(() => func1.fuzzify(0.7), /fuzzified result must be smaller than 1/);
+      });
+    });
+    
+    describe('function returning < 0 for x < 1', function() {
+      const func2 = new FuzzyFunction(x => x - 1);
+      
+      it('should throw error for x=0.5', function() {
+        assert.throws(() => func2.fuzzify(0.5), /fuzzified result must be smaller than 1/);
+      });
+      
+      it('should return exactly 0 for x=1', function() {
+        assert.equal(func2.fuzzify(1), 0);
+      });
+      
+      it('should throw error for x=0.8', function() {
+        assert.throws(() => func2.fuzzify(0.8), /fuzzified result must be smaller than 1/);
+      });
+    });
+  });
+
+  describe('complex mathematical functions', function() {
+    const sinFunc = new FuzzyFunction(x => (Math.sin(x) + 1) / 2);
+    
+    it('should return 0.5 for x=0', function() {
+      assert(sinFunc.fuzzify(0) === 0.5);
+    });
+    
+    it('should return 1 for x=PI/2', function() {
+      assert(sinFunc.fuzzify(Math.PI / 2) === 1);
+    });
+    
+    it('should return 0 for x=3*PI/2', function() {
+      assert(sinFunc.fuzzify(3 * Math.PI / 2) === 0);
+    });
+  });
+
+  describe('functions that throw errors', function() {
+    const errorFunc = new FuzzyFunction(x => {
+      if (x < 0) throw new Error('Negative input');
+      return x;
+    });
+    
+    it('should return valid value for x=0.5', function() {
+      assert.equal(errorFunc.fuzzify(0.5), 0.5);
+    });
+    
+    it('should throw error for negative input', function() {
+      assert.throws(() => errorFunc.fuzzify(-1), /Negative input/);
+    });
+  });
+});

package/test/edge-cases/grade-edge-cases.test.js

@@ -0,0 +1,42 @@
+'use strict';
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const Grade = require('../../lib/curve/grade');
+
+describe('Grade edge cases', function() {
+  describe('vertical grade (x0=x1)', function() {
+    const grade = new Grade(5, 5);
+    
+    it('should return 0 for value before x0', function() {
+      assert.equal(grade.fuzzify(4.9), 0);
+    });
+    
+    it('should return 1 for value at x0=x1', function() {
+      assert.equal(grade.fuzzify(5), 1);
+    });
+    
+    it('should return 1 for value after x1', function() {
+      assert.equal(grade.fuzzify(5.1), 1);
+    });
+    
+    it('should return 1 for very large value', function() {
+      assert.equal(grade.fuzzify(100), 1);
+    });
+  });
+
+  describe('very steep grade', function() {
+    const grade = new Grade(5, 5.0001);
+    
+    it('should return 0 for value before x0', function() {
+      assert.equal(grade.fuzzify(4.9), 0);
+    });
+    
+    it('should return greater than 0.4 for value at midpoint', function() {
+      assert(grade.fuzzify(5.00005) > 0.4);
+    });
+    
+    it('should return 1 for value well after x1', function() {
+      assert.equal(grade.fuzzify(5.1), 1);
+    });
+  });
+});

package/test/edge-cases/reverse-grade-edge-cases.test.js

@@ -0,0 +1,42 @@
+'use strict';
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const ReverseGrade = require('../../lib/curve/reverse-grade');
+
+describe('ReverseGrade edge cases', function() {
+  describe('vertical reverse grade (x0=x1)', function() {
+    const reverseGrade = new ReverseGrade(5, 5);
+    
+    it('should return 1 for value before x0', function() {
+      assert.equal(reverseGrade.fuzzify(4.9), 1);
+    });
+    
+    it('should return 1 for value at x0=x1', function() {
+      assert.equal(reverseGrade.fuzzify(5), 1);
+    });
+    
+    it('should return 0 for value after x1', function() {
+      assert.equal(reverseGrade.fuzzify(5.1), 0);
+    });
+    
+    it('should return 0 for very large value', function() {
+      assert.equal(reverseGrade.fuzzify(100), 0);
+    });
+  });
+
+  describe('very steep reverse grade', function() {
+    const reverseGrade = new ReverseGrade(5, 5.0001);
+    
+    it('should return 1 for value before x0', function() {
+      assert.equal(reverseGrade.fuzzify(4.9), 1);
+    });
+    
+    it('should return less than 0.6 for value at midpoint', function() {
+      assert(reverseGrade.fuzzify(5.00005) < 0.6);
+    });
+    
+    it('should return 0 for value well after x1', function() {
+      assert.equal(reverseGrade.fuzzify(5.1), 0);
+    });
+  });
+});

package/test/edge-cases/shapes-large-values.test.js

@@ -0,0 +1,78 @@
+'use strict';
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const Triangle = require('../../lib/curve/triangle');
+const Trapezoid = require('../../lib/curve/trapezoid');
+const Grade = require('../../lib/curve/grade');
+const ReverseGrade = require('../../lib/curve/reverse-grade');
+const Sigmoid = require('../../lib/curve/sigmoid');
+
+describe('Shapes with very large x values', function() {
+  describe('Infinity handling', function() {
+    const triangle = new Triangle(0, 10, 20);
+    const trapezoid = new Trapezoid(0, 10, 20, 30);
+    const grade = new Grade(0, 10);
+    const reverseGrade = new ReverseGrade(0, 10);
+    const sigmoid = new Sigmoid(10, 1);
+    
+    it('should return 0 for triangle with positive Infinity', function() {
+      assert.equal(triangle.fuzzify(Infinity), 0);
+    });
+    
+    it('should return 0 for triangle with negative Infinity', function() {
+      assert.equal(triangle.fuzzify(-Infinity), 0);
+    });
+    
+    it('should return 0 for trapezoid with positive Infinity', function() {
+      assert.equal(trapezoid.fuzzify(Infinity), 0);
+    });
+    
+    it('should return 0 for trapezoid with negative Infinity', function() {
+      assert.equal(trapezoid.fuzzify(-Infinity), 0);
+    });
+    
+    it('should return 1 for grade with positive Infinity', function() {
+      assert.equal(grade.fuzzify(Infinity), 1);
+    });
+    
+    it('should return 0 for grade with negative Infinity', function() {
+      assert.equal(grade.fuzzify(-Infinity), 0);
+    });
+    
+    it('should return 0 for reverseGrade with positive Infinity', function() {
+      assert.equal(reverseGrade.fuzzify(Infinity), 0);
+    });
+    
+    it('should return 1 for reverseGrade with negative Infinity', function() {
+      assert.equal(reverseGrade.fuzzify(-Infinity), 1);
+    });
+    
+    it('should return 1 for sigmoid with positive Infinity', function() {
+      assert.equal(sigmoid.fuzzify(Infinity), 1);
+    });
+    
+    it('should return 0 for sigmoid with negative Infinity', function() {
+      assert.equal(sigmoid.fuzzify(-Infinity), 0);
+    });
+  });
+
+  describe('very large numbers', function() {
+    const triangle = new Triangle(0, 1e10, 2e10);
+    
+    it('should return 0 for value at x0', function() {
+      assert.equal(triangle.fuzzify(0), 0);
+    });
+    
+    it('should return 1 for value at x1', function() {
+      assert.equal(triangle.fuzzify(1e10), 1);
+    });
+    
+    it('should return 0 for value at x2', function() {
+      assert.equal(triangle.fuzzify(2e10), 0);
+    });
+    
+    it('should return 0.5 for value at midpoint', function() {
+      assert.equal(triangle.fuzzify(1.5e10), 0.5);
+    });
+  });
+});

package/test/edge-cases/shapes-negative-values.test.js

@@ -0,0 +1,75 @@
+'use strict';
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const Triangle = require('../../lib/curve/triangle');
+const Trapezoid = require('../../lib/curve/trapezoid');
+
+describe('Shapes with negative x values', function() {
+  describe('triangle with negative x values', function() {
+    const triangle = new Triangle(-10, -5, 0);
+    
+    it('should return 0 for value far before x0', function() {
+      assert.equal(triangle.fuzzify(-15), 0);
+    });
+    
+    it('should return 0 for value at x0', function() {
+      assert.equal(triangle.fuzzify(-10), 0);
+    });
+    
+    it('should return 0.5 for value at midpoint of left slope', function() {
+      assert.equal(triangle.fuzzify(-7.5), 0.5);
+    });
+    
+    it('should return 1 for value at x1', function() {
+      assert.equal(triangle.fuzzify(-5), 1);
+    });
+    
+    it('should return 0.5 for value at midpoint of right slope', function() {
+      assert.equal(triangle.fuzzify(-2.5), 0.5);
+    });
+    
+    it('should return 0 for value at x2', function() {
+      assert.equal(triangle.fuzzify(0), 0);
+    });
+    
+    it('should return 0 for value after x2', function() {
+      assert.equal(triangle.fuzzify(5), 0);
+    });
+  });
+
+  describe('trapezoid with negative x values', function() {
+    const trapezoid = new Trapezoid(-20, -15, -5, 0);
+    
+    it('should return 0 for value before x0', function() {
+      assert.equal(trapezoid.fuzzify(-25), 0);
+    });
+    
+    it('should return 0 for value at x0', function() {
+      assert.equal(trapezoid.fuzzify(-20), 0);
+    });
+    
+    it('should return 0.5 for value at midpoint of left slope', function() {
+      assert.equal(trapezoid.fuzzify(-17.5), 0.5);
+    });
+    
+    it('should return 1 for value at x1', function() {
+      assert.equal(trapezoid.fuzzify(-15), 1);
+    });
+    
+    it('should return 1 for value in middle plateau', function() {
+      assert.equal(trapezoid.fuzzify(-10), 1);
+    });
+    
+    it('should return 1 for value at x2', function() {
+      assert.equal(trapezoid.fuzzify(-5), 1);
+    });
+    
+    it('should return 0.5 for value at midpoint of right slope', function() {
+      assert.equal(trapezoid.fuzzify(-2.5), 0.5);
+    });
+    
+    it('should return 0 for value at x3', function() {
+      assert.equal(trapezoid.fuzzify(0), 0);
+    });
+  });
+});