├── Gemfile
├── README.md
├── _config.yml
├── _layouts
    └── default.html
├── autocomplete.png
├── browser.png
├── package.json
└── test
    └── parser.js


/Gemfile:
--------------------------------------------------------------------------------
1 | source 'https://rubygems.org'
2 | gem 'github-pages', group: :jekyll_plugins
3 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | This is a [stage 0](https://tc39.github.io/process-document/) proposal to add a [pluggable type system](http://bracha.org/pluggableTypesPosition.pdf) to JavaScript.
  2 | 
  3 | A **pluggable** type system is a set of [syntactical constructs](#syntax) that serve as type **annotations** that formally bind them to an **optional type checker** (i.e. no assertions made at runtime) defined in  **userland** (e.g. typescript, flow and closure). For example:
  4 | 
  5 | ```javascript
  6 | /* 
  7 |  * @types https://www.typescriptlang.org/
  8 |  */
  9 | function add(x: number, y: number): number {
 10 |     return x + y;
 11 | }
 12 | ```
 13 | 
 14 | At runtime, this is equivalent to:
 15 | 
 16 | ```javascript
 17 | function add(x /*: number */, y /*: number */) /*: number */ {
 18 |     return x + y;
 19 | }
 20 | ```
 21 | 
 22 | You bind a type system plugin to code by using a **to-be-determined-at-stage-2** convention ([alternatives](#binding)).
 23 | 
 24 | # Motivation
 25 | 
 26 | In the last 10 years, large engineering teams have developed type systems for JavaScript through a variety of preprocessors, transpilers and code editors to scale large codebases.
 27 | 
 28 | Most notably, [TypeScript](https://www.typescriptlang.org/), [Flow](http://flowtype.org/) and the [Closure](https://github.com/google/closure-compiler/wiki/Annotating-JavaScript-for-the-Closure-Compiler) have gained a massive amount of adoption and are used as the foundation and starting point of this proposal.
 29 | 
 30 | Unfortunately, the javascript syntax isn't expressive enough to enable an effective type checker, so it was extended beyond the **standard** language.
 31 | 
 32 | This proposal tries to bridge the gap between the **standard** javascript language and the massive benefits of type checkers, making them more accessible to users that want to remain within the boundaries of the **standard** javascript language, while still nurturing the innovation and development of independent type systems.
 33 | 
 34 | It accomplishes this by introducing a **pluggable** type system for JS composed of (a) syntax extensions and (b) a binding mechanism that enables (existing) type checkers to operate during code development according to the semantics that were bound.
 35 | 
 36 | ```javascript
 37 | /**
 38 |  * A Shape represents objects that can ...
 39 |  *
 40 |  * @types http://flowtype.org/
 41 |  */
 42 | interface Shape {
 43 |   ...
 44 | }
 45 | ```
 46 | 
 47 | At runtime, the syntax extensions are **not** used for type checking by interpreters.
 48 | 
 49 | ```javascript
 50 | /**
 51 |  * An Account represents the user's ...
 52 |  *
 53 |  * @types https://developers.google.com/closure
 54 |  */
 55 | class Account {  
 56 |   constructor(initially: number) {  
 57 |     this.balance = initially;  
 58 |   }  
 59 |   deposit(credit: number) : number {  
 60 |     this.balance += credit;  
 61 |     return this.balance;  
 62 |   }  
 63 | }
 64 | ```
 65 | 
 66 | 
 67 | Pluggable type systems enable the **standard** javascript language to:
 68 | 
 69 | 1. **delegate** the development/innovation of type **semantics** to userland, formalizing **current norms**
 70 | 1. steer **convergence** on syntax of type systems for JS 
 71 | 1. place a **stepping stone** on a possible path towards finding a unified [optional type system](http://code.sgo.to/proposal-optional-types/)
 72 | 
 73 | Browsers could, potentially, connect with a [language server](https://github.com/Microsoft/language-server-protocol) and offer type checks during **development** time (e.g. possibly even catching runtime type checking information).
 74 | 
 75 | Having said that, the main **drawback** with pluggable type systems for TC39 it that they corner ourselves from **gradual typing** (i.e. once introduced without runtime type checking, they can't add them afterwards without introducing extra syntax).
 76 | 
 77 | We believe, however, that there is significant evidence in the research literature that gradual typing incurs a significant performance penalty, which makes it impractical. In addition, TypeScript, Flow, and Closure Compiler have demonstrated that optional typing works well for JS at scale.
 78 | 
 79 | # Strawman proposal
 80 | 
 81 | In this proposal, we describe syntactical extensions that enables type plugins to define semantics. At runtime, every extension below is semantically sequivalent to wrapping them in ```/* */``` comments.
 82 | 
 83 | ## Binding
 84 | 
 85 | We believe it is important to make an association between the syntax and the type checking semantics to be performed. Currently, to the best of our knowledge, each type system has their own convention:
 86 | 
 87 | * file extensions (e.g. [```.flow```](https://github.com/facebook/flow/issues/1996#issuecomment-230919868) or ```.ts```).
 88 | * reserved ```// @``` comment annotations (e.g. [```// @flow```](https://flow.org/en/docs/usage/#toc-prepare-your-code-for-flow) source annotation).
 89 | * ```jsdocs``` annotations.
 90 | * ```"use pragmas"``` pragmas.
 91 | 
 92 | We should take these (and more) into consideration:
 93 | 
 94 | * does it require TC39 to enumerate/register type systems or can it be self-service?
 95 | * does the binding happen in the source code or out of band (e.g. compilation flag, file extensions, etc)?
 96 | 
 97 | As a starting point, consider a reserved jsdoc annotation (e.g. ```@types```) pointing to a URL (along the lines of xml namespaces) which is responsible to define how types should be interpreted.
 98 | 
 99 | For example:
100 | 
101 | ```javascript
102 | /**
103 |  * This class abstracts X, Y and Z.
104 |  *
105 |  * @types https://www.typescriptlang.org/
106 |  */
107 | ```
108 | 
109 | ## Syntax
110 | 
111 | In addition to the binding mechanism, we propose syntactical extensions for type annotations.
112 | 
113 | ### Variables
114 | 
115 | ```javascript
116 | let isDone: boolean = false;
117 | let decimal: number = 6;
118 | let hex: number = 0xf00d;
119 | let binary: number = 0b1010;
120 | let octal: number = 0o744;
121 | let color: string = "blue";
122 | let list: number[] = [1, 2, 3];
123 | let x: [string, number] = ["hello", 10]; // tuples
124 | let notsure: any = 4;
125 | let u: undefined = undefined;
126 | let n: null = null;
127 | ```
128 | 
129 | ### Functions
130 | 
131 | ```javascript
132 | function add(x: number, y: number): number {
133 |     return x + y;
134 | }
135 | 
136 | let mul: (x: number, y: number) => number =
137 |     function(x: number, y: number): number { return x * y; };
138 | 
139 | function vote(candidate: string, callback: (result: string) => any) {  
140 |    // ...  
141 | }
142 | ```
143 | 
144 | Optional parameters:
145 | 
146 | ```javascript
147 | function buildName(firstName: string, lastName?: string) {
148 |   if (lastName) {
149 |     return firstName + " " + lastName;
150 |   } else {
151 |     return firstName;
152 |   }
153 | }
154 | ```
155 | 
156 | ### Classes
157 | 
158 | ```javascript
159 | class BankAccount {  
160 |   balance: number;  
161 |   constructor(initially: number) {  
162 |     this.balance = initially;  
163 |   }  
164 |   deposit(credit: number) {  
165 |     this.balance += credit;  
166 |     return this.balance;  
167 |   }  
168 | }
169 | ```
170 | 
171 | ### Interfaces
172 | 
173 | ```javascript
174 | interface Timer {
175 |   currentTime: Date;
176 |   setTime(d: Date);
177 | }
178 | 
179 | class Clock implements Timer {
180 |   ...
181 | }
182 | ```
183 | 
184 | ### Generics
185 | 
186 | ```javascript
187 | interface Array<T> {  
188 |     reverse(): T[];  
189 |     sort(compareFn?: (a: T, b: T) => number): T[];  
190 |     // ...   
191 | }
192 | 
193 | function identity<T>(arg: T): T {
194 |     return arg;
195 | }
196 | 
197 | class GenericNumber<T> {
198 |     zeroValue: T;
199 |     add: (x: T, y: T) => T;
200 | }
201 | ```
202 | 
203 | # Related Work
204 | 
205 | * [Other languages](http://code.sgo.to/proposal-optional-types/FAQ.html#other-languages)
206 | * [TC39 discussions](http://code.sgo.to/proposal-optional-types/FAQ.html#tc39-discussions)
207 | * [An Optional Type System for JS](http://code.sgo.to/proposal-optional-types/)
208 | 


--------------------------------------------------------------------------------
/_config.yml:
--------------------------------------------------------------------------------
1 | baseurl: /proposal-pluggable-types
2 | 
3 | theme: jekyll-theme-slate
4 | 
5 | kramdown:
6 |   auto_ids: true # Auto-generate ID's for headings
7 | 
8 | 


--------------------------------------------------------------------------------
/_layouts/default.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="{{ site.lang | default: "en-US" }}">
 3 |   <head>
 4 |     <meta charset='utf-8'>
 5 |     <meta http-equiv="X-UA-Compatible" content="IE=edge">
 6 |     <meta name="viewport" content="width=device-width,maximum-scale=2">
 7 |     <link rel="stylesheet" type="text/css" media="screen" href="{{ '/assets/css/style.css?v=' | append: site.github.build_revision | relative_url }}">
 8 |     <script src="//cdnjs.cloudflare.com/ajax/libs/anchor-js/3.2.0/anchor.min.js"></script>
 9 |     <style>
10 |     .anchorjs-link {
11 |       color: inherit !important;
12 |       text-decoration: none !important; /* do not underline */
13 |     }
14 | 
15 |     @media (max-width: 768px) {
16 |       /* Do not display AnchorJS icon on less than 768px view point */
17 |       .anchorjs-link {
18 |         display: none;
19 |       }
20 |     }
21 | 
22 |     *:hover > .anchorjs-link {
23 |       opacity: .75;
24 |       /* To fade links as they appear, change transition-property from 'color' to 'all' */
25 |       -webkit-transition: color .16s linear;
26 |       transition: color .16s linear;
27 |     }
28 | 
29 |     *:hover > .anchorjs-link:hover,
30 |     .anchorjs-link:focus {
31 |       text-decoration: none !important; /* do not underline */
32 |       opacity: 1;
33 |     }
34 |     </style>
35 |   </head>
36 |   <body>
37 |     <div id="header_wrap" class="outer">
38 |       <a href="{{ site.github.repository_url }}">
39 |         <img style="position: absolute; top: 0; right: 0; border: 0; padding: 0; margin: 0; box-shadow: unset;" src="https://s3.amazonaws.com/github/ribbons/forkme_right_red_aa0000.png" alt="Fork me on GitHub">
40 |       </a>
41 |       <header class="inner">
42 |         <h1 id="project_title">
43 |           <a href="{{ site.baseurl }}/index.html" style="color: white;">{{ site.title | default: site.github.repository_name }}</a>
44 |         </h1>
45 |         <h2 id="project_tagline">
46 |           {{ site.description | default: site.github.project_tagline }}
47 |         </h2>
48 |       </header>
49 |     </div>
50 |     <div id="main_content_wrap" class="outer">
51 |       <section id="main_content" class="inner post-content">
52 |         {{ content }}
53 |       </section>
54 |     </div>
55 |     <div id="footer_wrap" class="outer">
56 |       <footer class="inner">
57 |         {% if site.github.is_project_page %}
58 |         <p class="copyright">{{ site.title | default: site.github.repository_name }} maintained by <a href="{{ site.github.owner_url }}">{{ site.github.owner_name }}</a></p>
59 |         {% endif %}
60 |         <p>Published with <a href="https://pages.github.com">GitHub Pages</a></p>
61 |       </footer>
62 |     </div>
63 | 
64 |     <script>
65 |     (function () {
66 |       'use strict';
67 |       anchors.options.placement = "left";
68 |       anchors.add(".post-content > h1, .post-content > h2, .post-content > h3, .post-content > h4, .post-content > h5, .post-content > h6");
69 |     })();
70 |     </script>
71 | 
72 |   </body>
73 | </html>
74 | 


--------------------------------------------------------------------------------
/autocomplete.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/samuelgoto/proposal-pluggable-types/e8995a0c56042ba1fe7a68e517f62def1f2ce505/autocomplete.png


--------------------------------------------------------------------------------
/browser.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/samuelgoto/proposal-pluggable-types/e8995a0c56042ba1fe7a68e517f62def1f2ce505/browser.png


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "proposal-pluggable-types",
 3 |   "scripts": {
 4 |     "test": "mocha -w",
 5 |     "debug": "google-chrome http://127.0.0.1:8080/debug?port=5858 2> /dev/null & mocha --inspect --inspect-brk"
 6 |   },
 7 |   "repository": {
 8 |     "type": "git",
 9 |     "url": "git+https://github.com/samuelgoto/proposal-pluggable-types.git"
10 |   },
11 |   "author": "samuelgoto@gmail.com",
12 |   "license": "MIT",
13 |   "bugs": {
14 |     "url": "https://github.com/samuelgoto/proposal-pluggable-types/issues"
15 |   },
16 |   "dependencies": {
17 |     "acorn": "^5.1.1",
18 |     "acorn-es7": "git+https://github.com/angelozerr/acorn-es7.git",
19 |     "acorn-es7-plugin": "^1.1.7",
20 |     "astring": "^1.0.3",
21 |     "commander": "^2.11.0",
22 |     "escodegen": "^1.11.0",
23 |     "falafel": "^2.1.0"
24 |   },
25 |   "devDependencies": {
26 |     "babel-core": "^6.26.0",
27 |     "babel-plugin-transform-decorators": "^6.24.1",
28 |     "babel-plugin-transform-decorators-legacy": "^1.3.4",
29 |     "chai": "^4.1.0",
30 |     "mocha": "^3.5.0"
31 |   }
32 | }
33 | 


--------------------------------------------------------------------------------
/test/parser.js:
--------------------------------------------------------------------------------
  1 | const Assert = require("assert");
  2 | const acorn = require("acorn");
  3 | const walk = require("acorn/dist/walk")
  4 | const tt = acorn.tokTypes;
  5 | const {TokenType, keywordTypes} = acorn;
  6 | const escodegen = require("escodegen");
  7 | 
  8 | const reserved = {};
  9 | const reserve = (token) => {
 10 |  reserved[token] = tt[token] = keywordTypes[token] = new TokenType(token, {keyword: token});
 11 | };
 12 | 
 13 | reserve("number");
 14 | reserve("boolean");
 15 | reserve("string");
 16 | reserve("any");
 17 | reserve("void");
 18 | reserve("object");
 19 | reserve("undefined");
 20 | reserve("null");
 21 | 
 22 | acorn.plugins.types = function(parser) {
 23 |  function parseType() {
 24 |     if (!this.eat(tt.colon)) {
 25 |      return;
 26 |     }
 27 |     // TODO(goto): disallow type declarations in variable lists.
 28 |     // because @jsdocs can't refer to multiple variables,
 29 |     // at least as far as I'm aware of.
 30 | 
 31 |     let node = this.startNode();
 32 |     if (this.eat(tt.number)) {
 33 |      node.label = tt.number.label;
 34 |     } else if (this.eat(tt.boolean)) {
 35 |      node.label = tt.boolean.label;
 36 |     } else if (this.eat(tt.string)) {
 37 |      node.label = tt.string.label;
 38 |     } else if (this.eat(tt.object)) {
 39 |      node.label = tt.object.label;
 40 |     } else if (this.eat(tt.any)) {
 41 |      node.label = tt.any.label;
 42 |     } else if (this.eat(tt.void)) {
 43 |      node.label = tt.void.label;
 44 |     } else if (this.eat(tt.null)) {
 45 |      node.label = tt.null.label;
 46 |     } else if (this.eat(tt.undefined)) {
 47 |      node.label = tt.undefined.label;
 48 |     } else {
 49 |      this.raise(this.pos, "Expected a type declaration");
 50 |      return;
 51 |     }
 52 | 
 53 |     return this.finishNode(node, "TypeDeclaration");
 54 |  }
 55 | 
 56 |  parser.extend("parseVarId", function(nextMethod) {
 57 |    return function(decl, kind) {
 58 |     decl.id = this.parseBindingAtom(kind);
 59 |     let type = parseType.call(this, decl);
 60 |     if (type) {
 61 |      decl.types = type;
 62 |     }
 63 |     this.checkLVal(decl.id, kind, false)
 64 |    };
 65 |   });
 66 | 
 67 |  parser.extend("parseBindingList", function(nextMethod) {
 68 |    return function(close, allowEmpty, allowTrailingComma) {
 69 |     // console.log(close);
 70 |     return nextMethod.call(this, close, allowEmpty, allowTrailingComma);
 71 |    };
 72 |   });
 73 | 
 74 |  parser.extend("parseBindingListItem", function(nextMethod) {
 75 |    return function(param) {
 76 |     let type = parseType.call(this);
 77 |     if (type) {
 78 |      // console.log(type);
 79 |      param.types = type;
 80 |     }
 81 |     return param;
 82 |     // return nextMethod.call(this, param);
 83 |    }
 84 |   });
 85 | 
 86 |  parser.extend("parseFunctionParams", function(nextMethod) {
 87 |    return function(node) {
 88 |     // NOTE(goto): this is a major hack, we should probably override
 89 |     // parseFunction, but that's really long, so, overriding
 90 |     // parseFunctionParams that happens just before parseFunctionBody
 91 |     // even if the : return type declaration are technically outside
 92 |     // of the function parameter list. oh well.
 93 |     this.expect(tt.parenL);
 94 |     node.params = this.parseBindingList(tt.parenR, false, this.options.ecmaVersion >= 8);
 95 |     this.checkYieldAwaitInDefaultParams();
 96 |     let type = parseType.call(this);
 97 |     if (type) {
 98 |      // console.log("hello");
 99 |      // console.log(type);
100 |      node.returns = type;
101 |     }
102 |      // return nextMethod.call(this, node);
103 |    };
104 |   });
105 | 
106 |  parser.extend("readWord", function(nextMethod) {
107 |    return function(code) {
108 |     let word = this.readWord1();
109 |     let type = tt.name;
110 |     if (this.keywords.test(word) || reserved[word]) {
111 |      if (this.containsEsc) {
112 |       this.raiseRecoverable(this.start, "Escape sequence in keyword " + word);
113 |      }
114 |      type = keywordTypes[word];
115 |     }
116 |     return this.finishToken(type, word);
117 |    }
118 |   })
119 | };
120 | 
121 | function parse(code) {
122 |  var comments = [];
123 |  let tokens = [];
124 | 
125 |  var ast = acorn.parse(code, {
126 |    plugins: {types: true},
127 |    // collect ranges for each node
128 |    ranges: true,
129 |    // collect comments in Esprima's format
130 |    onComment: comments,
131 |    // collect token ranges
132 |    onToken: tokens
133 |   });
134 | 
135 |  // attach comments using collected information
136 |  escodegen.attachComments(ast, comments, tokens);
137 | 
138 |  return ast;
139 | }
140 | 
141 | // https://github.com/google/closure-compiler/wiki/Annotating-JavaScript-for-the-Closure-Compiler#type-expressions
142 | function transpile(code) {
143 |  let ast = parse(code);
144 | 
145 |  walk.simple(ast, {
146 |    FunctionDeclaration(declaration) {
147 |     let labels = declaration.params.map(({name, types}) => { 
148 |       return {name: name, label: types.label};
149 |      });
150 | 
151 |     let block = ["*"];
152 | 
153 |     for (let {name, label} of labels) {
154 |      block.push(` * @param {${label}} ${name}`);
155 |     }
156 |     
157 |     if (declaration.returns) {
158 |      block.push(` * @return {${declaration.returns.label}}`);
159 |     }
160 | 
161 |     block.push(" ");
162 | 
163 | 
164 |     declaration.leadingComments = 
165 |      declaration.leadingComments || [];
166 |     declaration.leadingComments.push({
167 |       type: "Block",
168 |       value: block.join("\n")
169 |     });
170 |    },
171 |    VariableDeclaration(declaration) {
172 |     if (declaration.declarations &&
173 |         declaration.declarations[0].types) {
174 |      let type = declaration.declarations[0].types;
175 |      declaration.leadingComments = 
176 |       declaration.leadingComments || [];
177 |      let label = type.label;
178 |      if (label == "any") {
179 |       label = "*";
180 |      } else if (label == "object") {
181 |       label = "Object";
182 |      } else if (label == "void") {
183 |       throw new Error("closure doesn't have void");
184 |      }
185 |      declaration.leadingComments.push({
186 |        type: "Block",
187 |        value: `*\n * @type {${label}}\n `
188 |       });
189 |     }
190 |    }
191 |   });
192 | 
193 |  let result = escodegen.generate(ast, {comment: true});
194 |  return result;
195 | }
196 | 
197 | describe("Parser", function() {
198 |   it("Parsing variable declarations", function() {
199 |     let ast = parse(`
200 |       // hello world
201 |       var x: number = 42;
202 |     `);
203 | 
204 |     // generate code
205 |     let result = escodegen.generate(ast, {comment: true});
206 | 
207 |     assertThat(result).equalsTo(`
208 | // hello world
209 | var x = 42; 
210 |     `);
211 |   });
212 | 
213 |   it("Parsing primitives in variable declarations", function() {
214 |     parse("var x: number = 42;");
215 |     parse("var x: boolean = true;");
216 |     parse("var x: string = 'hello';");
217 |     parse("var x: void;");
218 |     parse("var x: any = 'hi';");
219 |     parse("var x: undefined;");
220 |     parse("var x: null;");
221 |     parse("var x: object = {};");
222 |   });
223 | 
224 |   it("Transpiling primitives in variable declarations", function() {
225 |     assertThat(transpile("var x: number = 42;"))
226 |      .equalsTo("/**\n * @type {number}\n */\nvar x = 42;");
227 |     assertThat(transpile("var x: boolean = true;"))
228 |      .equalsTo("/**\n * @type {boolean}\n */\nvar x = true;");
229 |     assertThat(transpile("var x: string = 'hello';"))
230 |      .equalsTo("/**\n * @type {string}\n */\nvar x = 'hello';");
231 |     assertThat(transpile("var x: any = 'hi';"))
232 |      .equalsTo("/**\n * @type {*}\n */\nvar x = 'hi';");
233 |     assertThat(transpile("var x: object = {};"))
234 |      .equalsTo("/**\n * @type {Object}\n */\nvar x = {};");
235 |     assertThat(transpile("var x: undefined;"))
236 |      .equalsTo("/**\n * @type {undefined}\n */\nvar x;");
237 |     assertThat(transpile("var x: null;"))
238 |      .equalsTo("/**\n * @type {null}\n */\nvar x;");
239 | 
240 |     try {
241 |      transpile("var x: void;");
242 |      fail("void isn't represented in closure");
243 |     } catch (e) {
244 |     }
245 |   });
246 | 
247 |   it("Parsing comments", function() {
248 |     let result = transpile(`
249 | /** hello world **/
250 | var x: number = 42;
251 | `);
252 | 
253 |     assertThat(result).equalsTo(`
254 | /** hello world **/
255 | /**
256 |  * @type {number}
257 |  */
258 | var x = 42;
259 |     `);
260 |   });
261 | 
262 |   it("Parsing params in function declarations", function() {
263 |     parse("function add(a: number, b: string) {}");
264 |     parse("function add(a: boolean, b: object) {}");
265 |     parse("function add(a: null, b: undefined) {}");
266 |     parse("function add(a: any, b: void) {}");
267 |   });
268 | 
269 |   it("Transpiling params in function declarations", function() {
270 |     assertThat(transpile("function add(a: number, b: string) {}"))
271 |      .equalsTo(`
272 | /**
273 |  * @param {number} a
274 |  * @param {string} b
275 |  */
276 | function add(a, b) {
277 | }
278 | `);
279 |   });
280 | 
281 |   it("Parsing return types in function declarations", function() {
282 |     parse("function add(): number {}");
283 |   });
284 | 
285 |   it("Transpiling returns in function declarations", function() {
286 |     assertThat(transpile("function add(): number {}"))
287 |      .equalsTo(`
288 | /**
289 |  * @return {number}
290 |  */
291 | function add() {
292 | }
293 | `);
294 |   });
295 | 
296 |   function assertThat(x) {
297 |    return {
298 |     equalsTo(y) {
299 |      Assert.equal(x.trim(), y.trim());
300 |     }
301 |    }
302 |   }
303 |  });
304 | 
305 | 


--------------------------------------------------------------------------------