Add spacing between methods

tshemsedinov · tshemsedinov · commit 8bf4ed360d7c · 2019-05-26T01:14:25.000+03:00
diff --git a/JavaScript/1-channels.js b/JavaScript/1-channels.js
@@ -11,9 +11,11 @@ class Queue {
     this.onFailure = null;
     this.onDrain = null;
   }
+
   static channels(concurrency) {
     return new Queue(concurrency);
   }
+
   add(task) {
     const hasChannel = this.count < this.concurrency;
     if (hasChannel) {
@@ -22,6 +24,7 @@ class Queue {
     }
     this.waiting.push(task);
   }
+
   next(task) {
     this.count++;
     this.onProcess(task, (err, result) => {
@@ -42,22 +45,27 @@ class Queue {
       }
     });
   }
+
   process(listener) {
     this.onProcess = listener;
     return this;
   }
+
   done(listener) {
     this.onDone = listener;
     return this;
   }
+
   success(listener) {
     this.onSuccess = listener;
     return this;
   }
+
   failure(listener) {
     this.onFailure = listener;
     return this;
   }
+
   drain(listener) {
     this.onDrain = listener;
     return this;
diff --git a/JavaScript/2-timeouts.js b/JavaScript/2-timeouts.js
@@ -13,17 +13,21 @@ class Queue {
     this.waitTimeout = Infinity;
     this.processTimeout = Infinity;
   }
+
   static channels(concurrency) {
     return new Queue(concurrency);
   }
+
   wait(msec) {
     this.waitTimeout = msec;
     return this;
   }
+
   timeout(msec) {
     this.processTimeout = msec;
     return this;
   }
+
   add(task) {
     const hasChannel = this.count < this.concurrency;
     if (hasChannel) {
@@ -32,6 +36,7 @@ class Queue {
     }
     this.waiting.push({ task, start: Date.now() });
   }
+
   next(task) {
     this.count++;
     let timer = null;
@@ -54,6 +59,7 @@ class Queue {
     }
     onProcess(task, finish);
   }
+
   takeNext() {
     const { waiting, waitTimeout } = this;
     const { task, start } = waiting.shift();
@@ -69,6 +75,7 @@ class Queue {
     this.next(task);
     return;
   }
+
   finish(err, res) {
     const { onFailure, onSuccess, onDone, onDrain } = this;
     if (err) {
@@ -79,22 +86,27 @@ class Queue {
     if (onDone) onDone(err, res);
     if (this.count === 0 && onDrain) onDrain();
   }
+
   process(listener) {
     this.onProcess = listener;
     return this;
   }
+
   done(listener) {
     this.onDone = listener;
     return this;
   }
+
   success(listener) {
     this.onSuccess = listener;
     return this;
   }
+
   failure(listener) {
     this.onFailure = listener;
     return this;
   }
+
   drain(listener) {
     this.onDrain = listener;
     return this;
diff --git a/JavaScript/3-pause.js b/JavaScript/3-pause.js
@@ -14,17 +14,21 @@ class Queue {
     this.waitTimeout = Infinity;
     this.processTimeout = Infinity;
   }
+
   static channels(concurrency) {
     return new Queue(concurrency);
   }
+
   wait(msec) {
     this.waitTimeout = msec;
     return this;
   }
+
   timeout(msec) {
     this.processTimeout = msec;
     return this;
   }
+
   add(task) {
     if (!this.paused) {
       const hasChannel = this.count < this.concurrency;
@@ -35,6 +39,7 @@ class Queue {
     }
     this.waiting.push({ task, start: Date.now() });
   }
+
   next(task) {
     this.count++;
     let timer = null;
@@ -54,6 +59,7 @@ class Queue {
     }
     onProcess(task, finish);
   }
+
   takeNext() {
     const { waiting, waitTimeout } = this;
     const { task, start } = waiting.shift();
@@ -74,6 +80,7 @@ class Queue {
     if (hasChannel) this.next(task);
     return;
   }
+
   finish(err, res) {
     const { onFailure, onSuccess, onDone, onDrain } = this;
     if (err) {
@@ -84,30 +91,37 @@ class Queue {
     if (onDone) onDone(err, res);
     if (this.count === 0 && onDrain) onDrain();
   }
+
   process(listener) {
     this.onProcess = listener;
     return this;
   }
+
   done(listener) {
     this.onDone = listener;
     return this;
   }
+
   success(listener) {
     this.onSuccess = listener;
     return this;
   }
+
   failure(listener) {
     this.onFailure = listener;
     return this;
   }
+
   drain(listener) {
     this.onDrain = listener;
     return this;
   }
+
   pause() {
     this.paused = true;
     return this;
   }
+
   resume() {
     if (this.waiting.length > 0) {
       const channels = this.concurrency - this.count;
diff --git a/JavaScript/4-priority.js b/JavaScript/4-priority.js
@@ -15,17 +15,21 @@ class Queue {
     this.processTimeout = Infinity;
     this.priorityMode = false;
   }
+
   static channels(concurrency) {
     return new Queue(concurrency);
   }
+
   wait(msec) {
     this.waitTimeout = msec;
     return this;
   }
+
   timeout(msec) {
     this.processTimeout = msec;
     return this;
   }
+
   add(task, priority = 0) {
     if (!this.paused) {
       const hasChannel = this.count < this.concurrency;
@@ -39,6 +43,7 @@ class Queue {
       this.waiting.sort((a, b) => b.priority - a.priority);
     }
   }
+
   next(task) {
     this.count++;
     let timer = null;
@@ -58,6 +63,7 @@ class Queue {
     }
     onProcess(task, finish);
   }
+
   takeNext() {
     const { waiting, waitTimeout } = this;
     const { task, start } = waiting.shift();
@@ -78,6 +84,7 @@ class Queue {
     if (hasChannel) this.next(task);
     return;
   }
+
   finish(err, res) {
     const { onFailure, onSuccess, onDone, onDrain } = this;
     if (err) {
@@ -88,30 +95,37 @@ class Queue {
     if (onDone) onDone(err, res);
     if (this.count === 0 && onDrain) onDrain();
   }
+
   process(listener) {
     this.onProcess = listener;
     return this;
   }
+
   done(listener) {
     this.onDone = listener;
     return this;
   }
+
   success(listener) {
     this.onSuccess = listener;
     return this;
   }
+
   failure(listener) {
     this.onFailure = listener;
     return this;
   }
+
   drain(listener) {
     this.onDrain = listener;
     return this;
   }
+
   pause() {
     this.paused = true;
     return this;
   }
+
   resume() {
     if (this.waiting.length > 0) {
       const channels = this.concurrency - this.count;
@@ -122,6 +136,7 @@ class Queue {
     this.paused = false;
     return this;
   }
+
   priority(flag = true) {
     this.priorityMode = flag;
     return this;
diff --git a/JavaScript/5-pipe.js b/JavaScript/5-pipe.js
@@ -16,17 +16,21 @@ class Queue {
     this.priorityMode = false;
     this.destination = null;
   }
+
   static channels(concurrency) {
     return new Queue(concurrency);
   }
+
   wait(msec) {
     this.waitTimeout = msec;
     return this;
   }
+
   timeout(msec) {
     this.processTimeout = msec;
     return this;
   }
+
   add(task, priority = 0) {
     if (!this.paused) {
       const hasChannel = this.count < this.concurrency;
@@ -40,6 +44,7 @@ class Queue {
       this.waiting.sort((a, b) => b.priority - a.priority);
     }
   }
+
   next(task) {
     this.count++;
     let timer = null;
@@ -59,6 +64,7 @@ class Queue {
     }
     onProcess(task, finish);
   }
+
   takeNext() {
     const { waiting, waitTimeout } = this;
     const { task, start } = waiting.shift();
@@ -79,6 +85,7 @@ class Queue {
     if (hasChannel) this.next(task);
     return;
   }
+
   finish(err, res) {
     const { onFailure, onSuccess, onDone, onDrain } = this;
     if (err) {
@@ -90,30 +97,37 @@ class Queue {
     if (onDone) onDone(err, res);
     if (this.count === 0 && onDrain) onDrain();
   }
+
   process(listener) {
     this.onProcess = listener;
     return this;
   }
+
   done(listener) {
     this.onDone = listener;
     return this;
   }
+
   success(listener) {
     this.onSuccess = listener;
     return this;
   }
+
   failure(listener) {
     this.onFailure = listener;
     return this;
   }
+
   drain(listener) {
     this.onDrain = listener;
     return this;
   }
+
   pause() {
     this.paused = true;
     return this;
   }
+
   resume() {
     if (this.waiting.length > 0) {
       const channels = this.concurrency - this.count;
@@ -124,10 +138,12 @@ class Queue {
     this.paused = false;
     return this;
   }
+
   priority(flag = true) {
     this.priorityMode = flag;
     return this;
   }
+
   pipe(destination) {
     this.destination = destination;
     return this;

Original file line number	Diff line number	Diff line change
`@@ -11,9 +11,11 @@ class Queue {`
`11`	`11`	`this.onFailure = null;`
`12`	`12`	`this.onDrain = null;`
`13`	`13`	`}`
	`14`	`+`
`14`	`15`	`static channels(concurrency) {`
`15`	`16`	`return new Queue(concurrency);`
`16`	`17`	`}`
	`18`	`+`
`17`	`19`	`add(task) {`
`18`	`20`	`const hasChannel = this.count < this.concurrency;`
`19`	`21`	`if (hasChannel) {`
`@@ -22,6 +24,7 @@ class Queue {`
`22`	`24`	`}`
`23`	`25`	`this.waiting.push(task);`
`24`	`26`	`}`
	`27`	`+`
`25`	`28`	`next(task) {`
`26`	`29`	`this.count++;`
`27`	`30`	`this.onProcess(task, (err, result) => {`
`@@ -42,22 +45,27 @@ class Queue {`
`42`	`45`	`}`
`43`	`46`	`});`
`44`	`47`	`}`
	`48`	`+`
`45`	`49`	`process(listener) {`
`46`	`50`	`this.onProcess = listener;`
`47`	`51`	`return this;`
`48`	`52`	`}`
	`53`	`+`
`49`	`54`	`done(listener) {`
`50`	`55`	`this.onDone = listener;`
`51`	`56`	`return this;`
`52`	`57`	`}`
	`58`	`+`
`53`	`59`	`success(listener) {`
`54`	`60`	`this.onSuccess = listener;`
`55`	`61`	`return this;`
`56`	`62`	`}`
	`63`	`+`
`57`	`64`	`failure(listener) {`
`58`	`65`	`this.onFailure = listener;`
`59`	`66`	`return this;`
`60`	`67`	`}`
	`68`	`+`
`61`	`69`	`drain(listener) {`
`62`	`70`	`this.onDrain = listener;`
`63`	`71`	`return this;`
Original file line number	Diff line number	Diff line change
`@@ -13,17 +13,21 @@ class Queue {`
`13`	`13`	`this.waitTimeout = Infinity;`
`14`	`14`	`this.processTimeout = Infinity;`
`15`	`15`	`}`
	`16`	`+`
`16`	`17`	`static channels(concurrency) {`
`17`	`18`	`return new Queue(concurrency);`
`18`	`19`	`}`
	`20`	`+`
`19`	`21`	`wait(msec) {`
`20`	`22`	`this.waitTimeout = msec;`
`21`	`23`	`return this;`
`22`	`24`	`}`
	`25`	`+`
`23`	`26`	`timeout(msec) {`
`24`	`27`	`this.processTimeout = msec;`
`25`	`28`	`return this;`
`26`	`29`	`}`
	`30`	`+`
`27`	`31`	`add(task) {`
`28`	`32`	`const hasChannel = this.count < this.concurrency;`
`29`	`33`	`if (hasChannel) {`
`@@ -32,6 +36,7 @@ class Queue {`
`32`	`36`	`}`
`33`	`37`	`this.waiting.push({ task, start: Date.now() });`
`34`	`38`	`}`
	`39`	`+`
`35`	`40`	`next(task) {`
`36`	`41`	`this.count++;`
`37`	`42`	`let timer = null;`
`@@ -54,6 +59,7 @@ class Queue {`
`54`	`59`	`}`
`55`	`60`	`onProcess(task, finish);`
`56`	`61`	`}`
	`62`	`+`
`57`	`63`	`takeNext() {`
`58`	`64`	`const { waiting, waitTimeout } = this;`
`59`	`65`	`const { task, start } = waiting.shift();`
`@@ -69,6 +75,7 @@ class Queue {`
`69`	`75`	`this.next(task);`
`70`	`76`	`return;`
`71`	`77`	`}`
	`78`	`+`
`72`	`79`	`finish(err, res) {`
`73`	`80`	`const { onFailure, onSuccess, onDone, onDrain } = this;`
`74`	`81`	`if (err) {`
`@@ -79,22 +86,27 @@ class Queue {`
`79`	`86`	`if (onDone) onDone(err, res);`
`80`	`87`	`if (this.count === 0 && onDrain) onDrain();`
`81`	`88`	`}`
	`89`	`+`
`82`	`90`	`process(listener) {`
`83`	`91`	`this.onProcess = listener;`
`84`	`92`	`return this;`
`85`	`93`	`}`
	`94`	`+`
`86`	`95`	`done(listener) {`
`87`	`96`	`this.onDone = listener;`
`88`	`97`	`return this;`
`89`	`98`	`}`
	`99`	`+`
`90`	`100`	`success(listener) {`
`91`	`101`	`this.onSuccess = listener;`
`92`	`102`	`return this;`
`93`	`103`	`}`
	`104`	`+`
`94`	`105`	`failure(listener) {`
`95`	`106`	`this.onFailure = listener;`
`96`	`107`	`return this;`
`97`	`108`	`}`
	`109`	`+`
`98`	`110`	`drain(listener) {`
`99`	`111`	`this.onDrain = listener;`
`100`	`112`	`return this;`
Original file line number	Diff line number	Diff line change
`@@ -14,17 +14,21 @@ class Queue {`
`14`	`14`	`this.waitTimeout = Infinity;`
`15`	`15`	`this.processTimeout = Infinity;`
`16`	`16`	`}`
	`17`	`+`
`17`	`18`	`static channels(concurrency) {`
`18`	`19`	`return new Queue(concurrency);`
`19`	`20`	`}`
	`21`	`+`
`20`	`22`	`wait(msec) {`
`21`	`23`	`this.waitTimeout = msec;`
`22`	`24`	`return this;`
`23`	`25`	`}`
	`26`	`+`
`24`	`27`	`timeout(msec) {`
`25`	`28`	`this.processTimeout = msec;`
`26`	`29`	`return this;`
`27`	`30`	`}`
	`31`	`+`
`28`	`32`	`add(task) {`
`29`	`33`	`if (!this.paused) {`
`30`	`34`	`const hasChannel = this.count < this.concurrency;`
`@@ -35,6 +39,7 @@ class Queue {`
`35`	`39`	`}`
`36`	`40`	`this.waiting.push({ task, start: Date.now() });`
`37`	`41`	`}`
	`42`	`+`
`38`	`43`	`next(task) {`
`39`	`44`	`this.count++;`
`40`	`45`	`let timer = null;`
`@@ -54,6 +59,7 @@ class Queue {`
`54`	`59`	`}`
`55`	`60`	`onProcess(task, finish);`
`56`	`61`	`}`
	`62`	`+`
`57`	`63`	`takeNext() {`
`58`	`64`	`const { waiting, waitTimeout } = this;`
`59`	`65`	`const { task, start } = waiting.shift();`
`@@ -74,6 +80,7 @@ class Queue {`
`74`	`80`	`if (hasChannel) this.next(task);`
`75`	`81`	`return;`
`76`	`82`	`}`
	`83`	`+`
`77`	`84`	`finish(err, res) {`
`78`	`85`	`const { onFailure, onSuccess, onDone, onDrain } = this;`
`79`	`86`	`if (err) {`
`@@ -84,30 +91,37 @@ class Queue {`
`84`	`91`	`if (onDone) onDone(err, res);`
`85`	`92`	`if (this.count === 0 && onDrain) onDrain();`
`86`	`93`	`}`
	`94`	`+`
`87`	`95`	`process(listener) {`
`88`	`96`	`this.onProcess = listener;`
`89`	`97`	`return this;`
`90`	`98`	`}`
	`99`	`+`
`91`	`100`	`done(listener) {`
`92`	`101`	`this.onDone = listener;`
`93`	`102`	`return this;`
`94`	`103`	`}`
	`104`	`+`
`95`	`105`	`success(listener) {`
`96`	`106`	`this.onSuccess = listener;`
`97`	`107`	`return this;`
`98`	`108`	`}`
	`109`	`+`
`99`	`110`	`failure(listener) {`
`100`	`111`	`this.onFailure = listener;`
`101`	`112`	`return this;`
`102`	`113`	`}`
	`114`	`+`
`103`	`115`	`drain(listener) {`
`104`	`116`	`this.onDrain = listener;`
`105`	`117`	`return this;`
`106`	`118`	`}`
	`119`	`+`
`107`	`120`	`pause() {`
`108`	`121`	`this.paused = true;`
`109`	`122`	`return this;`
`110`	`123`	`}`
	`124`	`+`
`111`	`125`	`resume() {`
`112`	`126`	`if (this.waiting.length > 0) {`
`113`	`127`	`const channels = this.concurrency - this.count;`
Original file line number	Diff line number	Diff line change
`@@ -15,17 +15,21 @@ class Queue {`
`15`	`15`	`this.processTimeout = Infinity;`
`16`	`16`	`this.priorityMode = false;`
`17`	`17`	`}`
	`18`	`+`
`18`	`19`	`static channels(concurrency) {`
`19`	`20`	`return new Queue(concurrency);`
`20`	`21`	`}`
	`22`	`+`
`21`	`23`	`wait(msec) {`
`22`	`24`	`this.waitTimeout = msec;`
`23`	`25`	`return this;`
`24`	`26`	`}`
	`27`	`+`
`25`	`28`	`timeout(msec) {`
`26`	`29`	`this.processTimeout = msec;`
`27`	`30`	`return this;`
`28`	`31`	`}`
	`32`	`+`
`29`	`33`	`add(task, priority = 0) {`
`30`	`34`	`if (!this.paused) {`
`31`	`35`	`const hasChannel = this.count < this.concurrency;`
`@@ -39,6 +43,7 @@ class Queue {`
`39`	`43`	`this.waiting.sort((a, b) => b.priority - a.priority);`
`40`	`44`	`}`
`41`	`45`	`}`
	`46`	`+`
`42`	`47`	`next(task) {`
`43`	`48`	`this.count++;`
`44`	`49`	`let timer = null;`
`@@ -58,6 +63,7 @@ class Queue {`
`58`	`63`	`}`
`59`	`64`	`onProcess(task, finish);`
`60`	`65`	`}`
	`66`	`+`
`61`	`67`	`takeNext() {`
`62`	`68`	`const { waiting, waitTimeout } = this;`
`63`	`69`	`const { task, start } = waiting.shift();`
`@@ -78,6 +84,7 @@ class Queue {`
`78`	`84`	`if (hasChannel) this.next(task);`
`79`	`85`	`return;`
`80`	`86`	`}`
	`87`	`+`
`81`	`88`	`finish(err, res) {`
`82`	`89`	`const { onFailure, onSuccess, onDone, onDrain } = this;`
`83`	`90`	`if (err) {`
`@@ -88,30 +95,37 @@ class Queue {`
`88`	`95`	`if (onDone) onDone(err, res);`
`89`	`96`	`if (this.count === 0 && onDrain) onDrain();`
`90`	`97`	`}`
	`98`	`+`
`91`	`99`	`process(listener) {`
`92`	`100`	`this.onProcess = listener;`
`93`	`101`	`return this;`
`94`	`102`	`}`
	`103`	`+`
`95`	`104`	`done(listener) {`
`96`	`105`	`this.onDone = listener;`
`97`	`106`	`return this;`
`98`	`107`	`}`
	`108`	`+`
`99`	`109`	`success(listener) {`
`100`	`110`	`this.onSuccess = listener;`
`101`	`111`	`return this;`
`102`	`112`	`}`
	`113`	`+`
`103`	`114`	`failure(listener) {`
`104`	`115`	`this.onFailure = listener;`
`105`	`116`	`return this;`
`106`	`117`	`}`
	`118`	`+`
`107`	`119`	`drain(listener) {`
`108`	`120`	`this.onDrain = listener;`
`109`	`121`	`return this;`
`110`	`122`	`}`
	`123`	`+`
`111`	`124`	`pause() {`
`112`	`125`	`this.paused = true;`
`113`	`126`	`return this;`
`114`	`127`	`}`
	`128`	`+`
`115`	`129`	`resume() {`
`116`	`130`	`if (this.waiting.length > 0) {`
`117`	`131`	`const channels = this.concurrency - this.count;`
`@@ -122,6 +136,7 @@ class Queue {`
`122`	`136`	`this.paused = false;`
`123`	`137`	`return this;`
`124`	`138`	`}`
	`139`	`+`
`125`	`140`	`priority(flag = true) {`
`126`	`141`	`this.priorityMode = flag;`
`127`	`142`	`return this;`
Original file line number	Diff line number	Diff line change
`@@ -16,17 +16,21 @@ class Queue {`
`16`	`16`	`this.priorityMode = false;`
`17`	`17`	`this.destination = null;`
`18`	`18`	`}`
	`19`	`+`
`19`	`20`	`static channels(concurrency) {`
`20`	`21`	`return new Queue(concurrency);`
`21`	`22`	`}`
	`23`	`+`
`22`	`24`	`wait(msec) {`
`23`	`25`	`this.waitTimeout = msec;`
`24`	`26`	`return this;`
`25`	`27`	`}`
	`28`	`+`
`26`	`29`	`timeout(msec) {`
`27`	`30`	`this.processTimeout = msec;`
`28`	`31`	`return this;`
`29`	`32`	`}`
	`33`	`+`
`30`	`34`	`add(task, priority = 0) {`
`31`	`35`	`if (!this.paused) {`
`32`	`36`	`const hasChannel = this.count < this.concurrency;`
`@@ -40,6 +44,7 @@ class Queue {`
`40`	`44`	`this.waiting.sort((a, b) => b.priority - a.priority);`
`41`	`45`	`}`
`42`	`46`	`}`
	`47`	`+`
`43`	`48`	`next(task) {`
`44`	`49`	`this.count++;`
`45`	`50`	`let timer = null;`
`@@ -59,6 +64,7 @@ class Queue {`
`59`	`64`	`}`
`60`	`65`	`onProcess(task, finish);`
`61`	`66`	`}`
	`67`	`+`
`62`	`68`	`takeNext() {`
`63`	`69`	`const { waiting, waitTimeout } = this;`
`64`	`70`	`const { task, start } = waiting.shift();`
`@@ -79,6 +85,7 @@ class Queue {`
`79`	`85`	`if (hasChannel) this.next(task);`
`80`	`86`	`return;`
`81`	`87`	`}`
	`88`	`+`
`82`	`89`	`finish(err, res) {`
`83`	`90`	`const { onFailure, onSuccess, onDone, onDrain } = this;`
`84`	`91`	`if (err) {`
`@@ -90,30 +97,37 @@ class Queue {`
`90`	`97`	`if (onDone) onDone(err, res);`
`91`	`98`	`if (this.count === 0 && onDrain) onDrain();`
`92`	`99`	`}`
	`100`	`+`
`93`	`101`	`process(listener) {`
`94`	`102`	`this.onProcess = listener;`
`95`	`103`	`return this;`
`96`	`104`	`}`
	`105`	`+`
`97`	`106`	`done(listener) {`
`98`	`107`	`this.onDone = listener;`
`99`	`108`	`return this;`
`100`	`109`	`}`
	`110`	`+`
`101`	`111`	`success(listener) {`
`102`	`112`	`this.onSuccess = listener;`
`103`	`113`	`return this;`
`104`	`114`	`}`
	`115`	`+`
`105`	`116`	`failure(listener) {`
`106`	`117`	`this.onFailure = listener;`
`107`	`118`	`return this;`
`108`	`119`	`}`
	`120`	`+`
`109`	`121`	`drain(listener) {`
`110`	`122`	`this.onDrain = listener;`
`111`	`123`	`return this;`
`112`	`124`	`}`
	`125`	`+`
`113`	`126`	`pause() {`
`114`	`127`	`this.paused = true;`
`115`	`128`	`return this;`
`116`	`129`	`}`
	`130`	`+`
`117`	`131`	`resume() {`
`118`	`132`	`if (this.waiting.length > 0) {`
`119`	`133`	`const channels = this.concurrency - this.count;`
`@@ -124,10 +138,12 @@ class Queue {`
`124`	`138`	`this.paused = false;`
`125`	`139`	`return this;`
`126`	`140`	`}`
	`141`	`+`
`127`	`142`	`priority(flag = true) {`
`128`	`143`	`this.priorityMode = flag;`
`129`	`144`	`return this;`
`130`	`145`	`}`
	`146`	`+`
`131`	`147`	`pipe(destination) {`
`132`	`148`	`this.destination = destination;`
`133`	`149`	`return this;`