├── .arcconfig
├── .arclint
├── .gitignore
├── Gruntfile.js
├── LICENSE.txt
├── README.md
├── experimenter.html
├── kas.js
├── lint_blacklist.txt
├── package.json
├── src
    ├── compare.js
    ├── nodes.js
    ├── parser-generator.js
    ├── parser.js
    ├── unitparser.js
    └── unitvalue.jison
├── test.html
└── yarn.lock


/.arcconfig:
--------------------------------------------------------------------------------
1 | {
2 |     "conduit_uri": "https://phabricator.khanacademy.org/",
3 |     "lint.engine": "ArcanistConfigurationDrivenLintEngine"
4 | }
5 | 


--------------------------------------------------------------------------------
/.arclint:
--------------------------------------------------------------------------------
 1 | {
 2 |   "linters": {
 3 |     "khan-linter": {
 4 |       "type": "script-and-regex",
 5 |       "script-and-regex.script": "ka-lint --always-exit-0 --blacklist=yes --propose-arc-fixes",
 6 |       "script-and-regex.regex": "\/^((?P<file>[^:]*):(?P<line>\\d+):((?P<char>\\d+):)? (?P<name>((?P<error>E)|(?P<warning>W))\\S+) (?P<message>[^\\x00\n]*)(\\x00(?P<original>[^\\x00]*)\\x00(?P<replacement>[^\\x00]*)\\x00)?)|(?P<ignore>SKIPPING.*)$\/m"
 7 |     }
 8 |   }
 9 | }
10 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules/


--------------------------------------------------------------------------------
/Gruntfile.js:
--------------------------------------------------------------------------------
 1 | module.exports = function(grunt) {
 2 | 
 3 | var srcFiles = [
 4 |     "src/parser.js",
 5 |     "src/unitparser.js",
 6 |     "src/nodes.js",
 7 |     "src/compare.js"
 8 | ];
 9 | 
10 | grunt.initConfig({
11 |     pkg: grunt.file.readJSON("package.json"),
12 |     concat: {
13 |         options: {
14 |             banner: "/*! KAS | https://github.com/Khan/KAS */\n"
15 |         },
16 |         dist: {
17 |             src: srcFiles,
18 |             dest: "kas.js"
19 |         }
20 |     },
21 |     execute: {
22 |         parser: {
23 |             src: ['src/parser-generator.js']
24 |         }
25 |     }
26 | });
27 | 
28 | grunt.loadNpmTasks("grunt-contrib-concat");
29 | grunt.loadNpmTasks('grunt-execute');
30 | grunt.registerTask("default", ["concat"]);
31 | grunt.registerTask("parser", ["execute:parser"]);
32 | 
33 | };
34 | 


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2014 Khan Academy
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | KAS
 2 | ===
 3 | 
 4 | A lightweight JavaScript CAS for comparing expressions and equations.
 5 | It is used throughout [Khan Academy](https://khanacademy.org)'s interactive exercises.
 6 | 
 7 | What can it do?
 8 | ---------------
 9 | 
10 | It can parse plain text math, LaTeX, or a mix of both:
11 | 
12 | ```js
13 | var expr = KAS.parse("3x \\frac{42}{42} sin^2y").expr;
14 | expr.print();
15 | // "3*x*42/42*sin(y)^(2)"
16 | ```
17 | 
18 | It can evaluate expressions:
19 | 
20 | ```js
21 | var expr = KAS.parse("(x^2+y^2)^.5").expr;
22 | expr.eval({x: 3, y: 4});
23 | // 5
24 | ```
25 | 
26 | It can compare expressions and equations:
27 | 
28 | ```js
29 | var expr1 = KAS.parse("(1-x)(-1-6x)").expr;
30 | var expr2 = KAS.parse("(6x+1)(x-1)").expr;
31 | KAS.compare(expr1, expr2).equal;
32 | // true
33 | 
34 | var eq1 = KAS.parse("2w+50/w=25").expr;
35 | var eq2 = KAS.parse("w(12.5-w)=25").expr;
36 | KAS.compare(eq1, eq2).equal;
37 | // true
38 | ```
39 | 
40 | It can perform basic transforms that always simplify an expression:
41 | 
42 | ```js
43 | var expr = KAS.parse("1+1+x+x+x+y").expr;
44 | expr.collect().print();
45 | // "2+3*x+y"
46 | 
47 | var expr = KAS.parse("b^(2*y*log_b x)").expr;
48 | expr.collect().print();
49 | // "x^(2*y)"
50 | ```
51 | 
52 | It can perform non-simplifying transforms on an expression:
53 | 
54 | ```js
55 | var expr = KAS.parse("ab(c+d)e^f").expr;
56 | expr.print();
57 | // "a*b*(c+d)*e^(f)"
58 | expr.expand().print();
59 | // "a*b*e^(f)*c+a*b*e^(f)*d"
60 | expr.expand().factor().print();
61 | // "a*b*e^(f)*(c+d)"
62 | ```
63 | 
64 | It can combine the above abilities to perform powerful simplification:
65 | 
66 | ```js
67 | var expr = KAS.parse("((nx^5)^5)/(n^-2x^2)^-3").expr;
68 | expr.print();
69 | // "(n*x^(5))^(5)*(n^(-2)*x^(2))^(-1*-3)"
70 | expr.simplify().print();
71 | // "n^(-1)*x^(31)"
72 | 
73 | var expr = KAS.parse("(15np-25mp)/(15p^2-5p)+(20mp+10p^2)/(15p^2-5p)").expr;
74 | expr.print();
75 | // "(15*n*p+-25*m*p)*(15*p^(2)+-5*p)^(-1)+(20*m*p+10*p^(2))*(15*p^(2)+-5*p)^(-1)"
76 | expr.simplify().print();
77 | // "(-1+3*p)^(-1)*(3*n+-1*m+2*p)"
78 | ```
79 | 
80 | How to build the library
81 | ------------------------
82 |     npm install
83 |     npm run build
84 | 
85 | How to build the parser
86 | -----------------------
87 | First, make any changes in `src/parser-generator.js`
88 | 
89 |     npm install
90 |     npm run build:parser
91 | 
92 | License
93 | -------
94 | [MIT License](http://opensource.org/licenses/MIT)
95 | 


--------------------------------------------------------------------------------
/experimenter.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 |     <head>
 4 |         <title>KAS Experimenter</title>
 5 |         <!-- Include Underscore -->
 6 |         <script src="node_modules/underscore/underscore.js"></script>
 7 |         <!-- Include KAS -->
 8 |         <script src="src/parser.js"></script>
 9 |         <script src="src/nodes.js"></script>
10 |         <script src="src/compare.js"></script>
11 |         <style>
12 |             * {
13 |                 font-family: "Courier New"
14 |             }
15 |             body {
16 |                 font-size: 28px;
17 |             }
18 |             #input {
19 |                 width: 100%;
20 |                 font-size: 72px;
21 |             }
22 |             .label {
23 |                 display: inline-block;
24 |                 margin-right:30px;
25 |                 width:400px;
26 |                 vertical-align: top;
27 |             }
28 |             .value {
29 |                 display: inline-block;
30 |             }
31 |             .code {
32 |                 font-size: 12px;
33 |             }
34 |         </style>
35 |     </head>
36 |     <body>
37 |         <input type="text" id="input"></input>
38 |         <div id="output"></div>
39 |         <script>
40 |             window.onload = function() {
41 |                 var input = document.getElementById("input");
42 |                 var out = document.getElementById("output");
43 | 
44 |                 if ("oninput" in input) {
45 |                     input.addEventListener("input", reprocess, false);
46 |                 } else {
47 |                     input.attachEvent("onkeyup", reprocess);
48 |                 }
49 | 
50 |                 function addInfo(el, label, value) {
51 |                     el.innerHTML += "<div>"
52 |                         + "<div class='label'>" + label + "</div>"
53 |                         + "<div class='value'>" + value + "</div>"
54 |                         + "</div>";
55 |                 }
56 | 
57 |                 function reprocess() {
58 |                     out.innerHTML = "";
59 |                     var parsed = KAS.parse(input.value, {}).expr;
60 |                     if (input.value === "") { return; }
61 |                     if (parsed === undefined) { return; }
62 |                     addInfo(out, "AST Representation:", parsed.repr());
63 |                     addInfo(out, "Printed Representation:", parsed.normalize().print());
64 |                     addInfo(out, "TeX Representation:", parsed.tex());
65 |                     addInfo(out, "Simplified?", parsed.isSimplified() ? "Yes" : "No");
66 |                     addInfo(out, "Simplified", parsed.simplify().normalize().print());
67 |                     addInfo(out, "JSON Representation:", "<pre class='code'>"
68 |                         + JSON.stringify(parsed, null, 2)
69 |                         + "</pre>");
70 |                     addInfo(out, "Compiled", parsed.compile().toString());
71 |                 }
72 |             };
73 |         </script>
74 |     </body>
75 | </html>
76 | 


--------------------------------------------------------------------------------
/lint_blacklist.txt:
--------------------------------------------------------------------------------
1 | node_modules/
2 | src/parser.js
3 | kas.js
4 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "kas",
 3 |   "version": "0.2.2",
 4 |   "description": "A lightweight JavaScript CAS for comparing expressions and equations.",
 5 |   "main": "kas.js",
 6 |   "scripts": {
 7 |     "test": "node testrunner",
 8 |     "build": "grunt",
 9 |     "build:parser": "grunt parser"
10 |   },
11 |   "repository": {
12 |     "type": "git",
13 |     "url": "https://github.com/Khan/KAS.git"
14 |   },
15 |   "keywords": [
16 |     "parsing",
17 |     "equation",
18 |     "expression",
19 |     "algebra",
20 |     "symbolic"
21 |   ],
22 |   "author": "alopatin",
23 |   "license": "MIT",
24 |   "bugs": {
25 |     "url": "https://github.com/Khan/KAS/issues"
26 |   },
27 |   "dependencies": {
28 |     "underscore": "1.4.4"
29 |   },
30 |   "devDependencies": {
31 |     "grunt": "^1.0.3",
32 |     "grunt-contrib-concat": "~0.1.3",
33 |     "grunt-execute": "~0.1.5",
34 |     "jison": "0.4.15",
35 |     "qunit": "^2.8.0",
36 |     "qunit-assert-close": "^2.1.2"
37 |   }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/compare.js:
--------------------------------------------------------------------------------
 1 | (function(KAS) {
 2 |     // Assumes that both expressions have already been parsed
 3 |     // TODO(alex): be able to pass a random() function to compare()
 4 |     KAS.compare = function(expr1, expr2, options) {
 5 |         var defaults = {
 6 |             form: false, // Check that the two expressions have the same form
 7 |             simplify: false, // Check that the second expression is simplified
 8 |         };
 9 | 
10 |         /* Options that could be added in the future:
11 |          * - Allow ratios: e.g. 3/1 and 3 should both be accepted for something
12 |          *   like slope
13 |          * - Allow student to choose their own variable names
14 |          */
15 | 
16 |         if (options !== undefined) {
17 |             // eslint-disable-next-line no-undef
18 |             options = _.extend(defaults, options);
19 |         } else {
20 |             options = defaults;
21 |         }
22 | 
23 |         // TODO(CP-1614): Figure out how to make these messages translatable
24 | 
25 |         // Variable check
26 |         var vars = expr1.sameVars(expr2);
27 |         if (!vars.equal) {
28 |             var message;
29 |             if (vars.equalIgnoringCase) {
30 |                 message =
31 |                     "Check your variables; one or more are using " +
32 |                     "the wrong case (upper or lower).";
33 |             } else {
34 |                 message =
35 |                     "Check your variables; you may have used the wrong " +
36 |                     "letter for one or more of them.";
37 |             }
38 |             return {
39 |                 equal: false,
40 |                 wrongVariableCase: vars.equalIgnoringCase,
41 |                 wrongVariableNames: !vars.equalIgnoringCase,
42 |                 message: message,
43 |             };
44 |         }
45 | 
46 |         // Semantic check
47 |         if (!expr1.compare(expr2)) {
48 |             return {equal: false, message: null};
49 |         }
50 | 
51 |         // Syntactic check
52 |         if (options.form && !expr1.sameForm(expr2)) {
53 |             return {
54 |                 equal: false,
55 |                 message: "Your answer is not in the correct form.",
56 |             };
57 |         }
58 | 
59 |         // Syntactic check
60 |         if (options.simplify && !expr1.isSimplified()) {
61 |             return {
62 |                 equal: false,
63 |                 message: "Your answer is not fully expanded and simplified.",
64 |             };
65 |         }
66 | 
67 |         return {equal: true, message: null};
68 |     };
69 | })(KAS);
70 | 


--------------------------------------------------------------------------------
/src/parser-generator.js:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env node
  2 | 
  3 | /* TODO(charlie): fix these lint errors (http://eslint.org/docs/rules): */
  4 | /* eslint-disable no-var, comma-dangle, max-len, comma-spacing */
  5 | 
  6 | var fs = require("fs");
  7 | var path = require("path");
  8 | var jison = require("jison");
  9 | 
 10 | var grammar = {
 11 |     lex: {
 12 |         rules: [
 13 |             ["\\s+",                "/* skip whitespace */"],
 14 |             ["\\\\space",           "/* skip \\space */"],
 15 |             ["\\\\ ",               "/* skip '\\ ' */"],
 16 |             ["[0-9]+\\.?",          "return \"INT\""],
 17 |             ["([0-9]+)?\\.[0-9]+",  "return \"FLOAT\""],
 18 |             ["\\*\\*",              "return \"^\""],
 19 |             ["\\*",                 "return \"*\""],
 20 |             ["\\\\cdot|\u00b7",     "return \"*\""],
 21 |             ["\\\\times|\u00d7",    "return \"*\""],
 22 |             ["\\\\ast",             "return \"*\""],
 23 |             ["\\/",                 "return \"/\""],
 24 |             ["\\\\div|\u00F7",      "return \"/\""],
 25 |             ["-",                   "return \"-\""],
 26 |             ["\u2212",              "return \"-\""],    // minus
 27 |             ["\\+",                 "return \"+\""],
 28 |             ["\\^",                 "return \"^\""],
 29 |             ["\\(",                 "return \"(\""],
 30 |             ["\\)",                 "return \")\""],
 31 |             ["\\\\left\\(",         "return \"(\""],
 32 |             ["\\\\right\\)",        "return \")\""],
 33 |             ["\\[",                 "return \"[\""],
 34 |             ["\\]",                 "return \"]\""],
 35 |             ["\\{",                 "return \"{\""],
 36 |             ["\\}",                 "return \"}\""],
 37 |             ["\\\\left\\{",         "return \"{\""],
 38 |             ["\\\\right\\}",        "return \"}\""],
 39 |             ["_",                   "return \"_\""],
 40 |             ["\\|",                 "return \"|\""],
 41 |             ["\\\\left\\|",         "return \"LEFT|\""],
 42 |             ["\\\\right\\|",        "return \"RIGHT|\""],
 43 |             ["\\!",                 "return \"!\""],    // not yet interpreted
 44 |             ["<=|>=|<>|<|>|=",      "return \"SIGN\""],
 45 |             ["\\\\le",              "yytext = \"<=\"; return \"SIGN\""],
 46 |             ["\\\\ge",              "yytext = \">=\"; return \"SIGN\""],
 47 |             ["\\\\leq",             "yytext = \"<=\"; return \"SIGN\""],
 48 |             ["\\\\geq",             "yytext = \">=\"; return \"SIGN\""],
 49 |             ["=\\/=",               "yytext = \"<>\"; return \"SIGN\""],
 50 |             ["\\\\ne",              "yytext = \"<>\"; return \"SIGN\""],
 51 |             ["\\\\neq",             "yytext = \"<>\"; return \"SIGN\""],
 52 |             ["\u2260",              "yytext = \"<>\"; return \"SIGN\""],    // ne
 53 |             ["\u2264",              "yytext = \"<=\"; return \"SIGN\""],    // le
 54 |             ["\u2265",              "yytext = \">=\"; return \"SIGN\""],    // ge
 55 |             ["\\\\frac",            "return \"FRAC\""],
 56 |             ["\\\\dfrac",           "return \"FRAC\""],
 57 |             ["sqrt|\\\\sqrt",       "return \"sqrt\""],
 58 |             ["abs|\\\\abs",         "return \"abs\""],
 59 |             ["ln|\\\\ln",           "return \"ln\""],
 60 |             ["log|\\\\log",         "return \"log\""],
 61 |             ["sin|cos|tan",         "return \"TRIG\""],
 62 |             ["csc|sec|cot",         "return \"TRIG\""],
 63 |             ["sinh|cosh|tanh",      "return \"TRIG\""],
 64 |             ["csch|sech|coth",      "return \"TRIG\""],
 65 |             ["\\\\sin",             "yytext = \"sin\"; return \"TRIG\""],
 66 |             ["\\\\cos",             "yytext = \"cos\"; return \"TRIG\""],
 67 |             ["\\\\tan",             "yytext = \"tan\"; return \"TRIG\""],
 68 |             ["\\\\csc",             "yytext = \"csc\"; return \"TRIG\""],
 69 |             ["\\\\sec",             "yytext = \"sec\"; return \"TRIG\""],
 70 |             ["\\\\cot",             "yytext = \"cot\"; return \"TRIG\""],
 71 |             ["\\\\arcsin",          "yytext = \"arcsin\"; return \"TRIG\""],
 72 |             ["\\\\arccos",          "yytext = \"arccos\"; return \"TRIG\""],
 73 |             ["\\\\arctan",          "yytext = \"arctan\"; return \"TRIG\""],
 74 |             ["\\\\arccsc",          "yytext = \"arccsc\"; return \"TRIG\""],
 75 |             ["\\\\arcsec",          "yytext = \"arcsec\"; return \"TRIG\""],
 76 |             ["\\\\arccot",          "yytext = \"arccot\"; return \"TRIG\""],
 77 |             ["arcsin|arccos|arctan","return \"TRIGINV\""],
 78 |             ["arccsc|arcsec|arccot","return \"TRIGINV\""],
 79 |             ["\\\\sinh",            "yytext = \"sinh\"; return \"TRIG\""],
 80 |             ["\\\\cosh",            "yytext = \"cosh\"; return \"TRIG\""],
 81 |             ["\\\\tanh",            "yytext = \"tanh\"; return \"TRIG\""],
 82 |             ["\\\\csch",            "yytext = \"csch\"; return \"TRIG\""],
 83 |             ["\\\\sech",            "yytext = \"sech\"; return \"TRIG\""],
 84 |             ["\\\\coth",            "yytext = \"tanh\"; return \"TRIG\""],
 85 |             ["pi",                  "return \"CONST\""],
 86 |             ["\u03C0",              "yytext = \"pi\"; return \"CONST\""],   // pi
 87 |             ["\\\\pi",              "yytext = \"pi\"; return \"CONST\""],
 88 |             ["theta",               "return \"VAR\""],
 89 |             ["\u03B8",              "yytext = \"theta\"; return \"VAR\""],  // theta
 90 |             ["\\\\theta",           "yytext = \"theta\"; return \"VAR\""],
 91 |             ["phi",                 "return \"VAR\""],
 92 |             ["\u03C6",              "yytext = \"phi\"; return \"VAR\""],  // phi
 93 |             ["\\\\phi",             "yytext = \"phi\"; return \"VAR\""],
 94 |             ["[a-zA-Z]",            "return yy.symbolLexer(yytext)"],
 95 |             ["$",                   "return \"EOF\""],
 96 |             [".",                   "return \"INVALID\""]
 97 |         ],
 98 |         options: {
 99 |             flex: true              // pick longest matching token
100 |         }
101 |     },
102 |     operators: [
103 |         ["right", "|"],
104 |         ["left", "+", "-"],
105 |         ["left", "*", "/"],
106 |         ["left", "UMINUS"],
107 |         ["right", "^"]
108 |     ],
109 |     start: "equation",
110 |     bnf: {
111 |         "equation": [
112 |             ["expression SIGN expression EOF", "return new yy.Eq($1, $2, $3);"],
113 |             ["expression EOF", "return $1;"],
114 |             ["EOF", "return new yy.Add([]);"]
115 |         ],
116 |         "expression": [
117 |             ["additive", "$$ = $1;"]
118 |         ],
119 |         "additive": [
120 |             ["additive + multiplicative", "$$ = yy.Add.createOrAppend($1, $3);"],
121 |             ["additive - multiplicative", "$$ = yy.Add.createOrAppend($1, yy.Mul.handleNegative($3, \"subtract\"));"],
122 |             ["multiplicative", "$$ = $1;", {prec: "+"}]
123 |         ],
124 |         "multiplicative": [
125 |             // the second term in an implicit multiplication cannot be negative
126 |             ["multiplicative triglog", "$$ = yy.Mul.fold(yy.Mul.createOrAppend($1, $2));"],
127 |             ["multiplicative * negative", "$$ = yy.Mul.fold(yy.Mul.createOrAppend($1, $3));"],
128 |             ["multiplicative / negative", "$$ = yy.Mul.fold(yy.Mul.handleDivide($1, $3));"],
129 |             ["negative", "$$ = $1;"]
130 |         ],
131 |         "negative": [
132 |             ["- negative", "$$ = yy.Mul.handleNegative($2);", {prec: "UMINUS"}],
133 |             ["triglog", "$$ = $1;"]
134 |         ],
135 |         "trig": [
136 |             ["TRIG", "$$ = [yytext];"]
137 |         ],
138 |         "trigfunc": [
139 |             ["trig", "$$ = $1;"],
140 |             ["trig ^ negative", "$$ = $1.concat($3);"],
141 |             ["TRIGINV", "$$ = [yytext];"]
142 |         ],
143 |         "logbase": [
144 |             ["ln", "$$ = yy.Log.natural();"],
145 |             ["log", "$$ = yy.Log.common();"],
146 |             ["log _ subscriptable", "$$ = $3;"]
147 |         ],
148 |         "triglog": [
149 |             ["trigfunc negative", "$$ = yy.Trig.create($1, $2);"],
150 |             ["logbase negative", "$$ = yy.Log.create($1, $2);"],
151 |             ["power", "$$ = $1;"]
152 |         ],
153 |         "power": [
154 |             ["primitive ^ negative", "$$ = new yy.Pow($1, $3);"],
155 |             ["primitive", "$$ = $1;"]
156 |         ],
157 |         "variable": [
158 |             ["VAR", "$$ = yytext;"]
159 |         ],
160 |         "subscriptable": [
161 |             ["variable _ subscriptable", "$$ = new yy.Var($1, $3);"],
162 |             ["variable", "$$ = new yy.Var($1);"],
163 |             ["CONST", "$$ = new yy.Const(yytext.toLowerCase());"],
164 |             ["INT", "$$ = yy.Int.create(Number(yytext));"],
165 |             ["FLOAT", "$$ = yy.Float.create(Number(yytext));"],
166 |             ["{ additive }", "$$ = $2.completeParse();"],
167 |             ["( additive )", "$$ = $2.completeParse().addHint('parens');"] // this probably shouldn't be a hint...
168 |         ],
169 |         "function": [
170 |             ["FUNC", "$$ = yytext;"]
171 |         ],
172 |         "invocation": [
173 |             ["sqrt ( additive )", "$$ = yy.Pow.sqrt($3);"],
174 |             ["sqrt { additive }", "$$ = yy.Pow.sqrt($3);"],
175 |             ["sqrt [ additive ] { additive }", "$$ = new yy.Pow.nthroot($6, $3);"],
176 |             ["abs ( additive )", "$$ = new yy.Abs($3);"],
177 |             ["| additive |", "$$ = new yy.Abs($2);"],
178 |             ["LEFT| additive RIGHT|", "$$ = new yy.Abs($2);"],
179 |             ["function ( additive )", "$$ = new yy.Func($1, $3);"]
180 |         ],
181 |         "primitive": [
182 |             ["subscriptable", "$$ = $1;"],
183 |             ["invocation", "$$ = $1;"],
184 |             ["FRAC { additive } { additive }", "$$ = yy.Mul.handleDivide($3, $6);"]
185 |         ]
186 |     }
187 | };
188 | 
189 | var prelude = "// This is a @gene" + "rated file\n" +
190 |               "var _, KAS = {};\n\n" +
191 |               "if (typeof module === \"object\" && module.exports) {\n" +
192 |               "    _ = require(\"underscore\");\n" +
193 |               "    module.exports = KAS;\n" +
194 |               "} else {\n" +
195 |               "    _ = window._;\n" +
196 |               "    window.KAS = KAS;\n" +
197 |               "}\n\n" +
198 |               "(function(KAS) {\n\n";
199 | var parser = (new jison.Generator(grammar)).generate({moduleType: "js"});
200 | // NOTE(jeresig): We need to comment out these two labels as they appear to be
201 | // invalid ES5 (they also aren't referenced anywhere so this seems safe).
202 | parser = parser.replace(/(_token_stack:)/g, "//$1");
203 | var postlude = "\n\nKAS.parser = parser;\n})(KAS);";
204 | 
205 | fs.writeFileSync(path.resolve(__dirname, "parser.js"), prelude + parser + postlude);
206 | 
207 | var unitPrelude = "// this is a @gene" + "rated file\n" +
208 |                   "(function(KAS) {\n\n";
209 | var unitEpilogue = "\n\nKAS.unitParser = parser;\n" +
210 |                    "})(KAS);";
211 | 
212 | var unitParserInfile = path.resolve(__dirname, "unitvalue.jison");
213 | var unitParserOutfile = path.resolve(__dirname, "unitparser.js");
214 | 
215 | var unitParserSource = fs.readFileSync(unitParserInfile);
216 | var unitParser = new jison.Generator(unitParserSource.toString());
217 | var generatedParser = unitParser.generate({ moduleType: "js" });
218 | // NOTE(jeresig): We need to comment out these two labels as they appear to be
219 | // invalid ES5 (they also aren't referenced anywhere so this seems safe).
220 | generatedParser = generatedParser.replace(/(_token_stack:)/g, "//$1");
221 | fs.writeFileSync(unitParserOutfile,
222 |                  unitPrelude + generatedParser + unitEpilogue);
223 | 


--------------------------------------------------------------------------------
/src/parser.js:
--------------------------------------------------------------------------------
  1 | // This is a @generated file
  2 | var _, KAS = {};
  3 | 
  4 | if (typeof module === "object" && module.exports) {
  5 |     _ = require("underscore");
  6 |     module.exports = KAS;
  7 | } else {
  8 |     _ = window._;
  9 |     window.KAS = KAS;
 10 | }
 11 | 
 12 | (function(KAS) {
 13 | 
 14 | /* parser generated by jison 0.4.15 */
 15 | /*
 16 |   Returns a Parser object of the following structure:
 17 | 
 18 |   Parser: {
 19 |     yy: {}
 20 |   }
 21 | 
 22 |   Parser.prototype: {
 23 |     yy: {},
 24 |     trace: function(),
 25 |     symbols_: {associative list: name ==> number},
 26 |     terminals_: {associative list: number ==> name},
 27 |     productions_: [...],
 28 |     performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$),
 29 |     table: [...],
 30 |     defaultActions: {...},
 31 |     parseError: function(str, hash),
 32 |     parse: function(input),
 33 | 
 34 |     lexer: {
 35 |         EOF: 1,
 36 |         parseError: function(str, hash),
 37 |         setInput: function(input),
 38 |         input: function(),
 39 |         unput: function(str),
 40 |         more: function(),
 41 |         less: function(n),
 42 |         pastInput: function(),
 43 |         upcomingInput: function(),
 44 |         showPosition: function(),
 45 |         test_match: function(regex_match_array, rule_index),
 46 |         next: function(),
 47 |         lex: function(),
 48 |         begin: function(condition),
 49 |         popState: function(),
 50 |         _currentRules: function(),
 51 |         topState: function(),
 52 |         pushState: function(condition),
 53 | 
 54 |         options: {
 55 |             ranges: boolean           (optional: true ==> token location info will include a .range[] member)
 56 |             flex: boolean             (optional: true ==> flex-like lexing behaviour where the rules are tested exhaustively to find the longest match)
 57 |             backtrack_lexer: boolean  (optional: true ==> lexer regexes are tested in order and for each matching regex the action code is invoked; the lexer terminates the scan when a token is returned by the action code)
 58 |         },
 59 | 
 60 |         performAction: function(yy, yy_, $avoiding_name_collisions, YY_START),
 61 |         rules: [...],
 62 |         conditions: {associative list: name ==> set},
 63 |     }
 64 |   }
 65 | 
 66 | 
 67 |   token location info (@$, _$, etc.): {
 68 |     first_line: n,
 69 |     last_line: n,
 70 |     first_column: n,
 71 |     last_column: n,
 72 |     range: [start_number, end_number]       (where the numbers are indexes into the input string, regular zero-based)
 73 |   }
 74 | 
 75 | 
 76 |   the parseError function receives a 'hash' object with these members for lexer and parser errors: {
 77 |     text:        (matched text)
 78 |     token:       (the produced terminal token, if any)
 79 |     line:        (yylineno)
 80 |   }
 81 |   while parser (grammar) errors will also provide these members, i.e. parser errors deliver a superset of attributes: {
 82 |     loc:         (yylloc)
 83 |     expected:    (string describing the set of expected tokens)
 84 |     recoverable: (boolean: TRUE when the parser has a error recovery rule available for this particular error)
 85 |   }
 86 | */
 87 | var parser = (function(){
 88 | var o=function(k,v,o,l){for(o=o||{},l=k.length;l--;o[k[l]]=v);return o},$V0=[1,7],$V1=[1,17],$V2=[1,13],$V3=[1,14],$V4=[1,15],$V5=[1,32],$V6=[1,22],$V7=[1,23],$V8=[1,24],$V9=[1,25],$Va=[1,26],$Vb=[1,33],$Vc=[1,27],$Vd=[1,28],$Ve=[1,29],$Vf=[1,30],$Vg=[1,20],$Vh=[1,36],$Vi=[1,37],$Vj=[5,6,8,10,33,35,41,43,45],$Vk=[1,39],$Vl=[1,40],$Vm=[5,6,8,10,12,14,16,19,21,22,28,29,30,31,32,33,34,35,37,39,41,42,43,44,45,46],$Vn=[10,16,19,21,22,28,29,30,31,32,34,37,39,42,43,44,46],$Vo=[5,6,8,10,12,14,16,18,19,21,22,28,29,30,31,32,33,34,35,37,39,41,42,43,44,45,46];
 89 | var parser = {trace: function trace () { },
 90 | yy: {},
 91 | symbols_: {"error":2,"equation":3,"expression":4,"SIGN":5,"EOF":6,"additive":7,"+":8,"multiplicative":9,"-":10,"triglog":11,"*":12,"negative":13,"/":14,"trig":15,"TRIG":16,"trigfunc":17,"^":18,"TRIGINV":19,"logbase":20,"ln":21,"log":22,"_":23,"subscriptable":24,"power":25,"primitive":26,"variable":27,"VAR":28,"CONST":29,"INT":30,"FLOAT":31,"{":32,"}":33,"(":34,")":35,"function":36,"FUNC":37,"invocation":38,"sqrt":39,"[":40,"]":41,"abs":42,"|":43,"LEFT|":44,"RIGHT|":45,"FRAC":46,"$accept":0,"$end":1},
 92 | terminals_: {2:"error",5:"SIGN",6:"EOF",8:"+",10:"-",12:"*",14:"/",16:"TRIG",18:"^",19:"TRIGINV",21:"ln",22:"log",23:"_",28:"VAR",29:"CONST",30:"INT",31:"FLOAT",32:"{",33:"}",34:"(",35:")",37:"FUNC",39:"sqrt",40:"[",41:"]",42:"abs",43:"|",44:"LEFT|",45:"RIGHT|",46:"FRAC"},
 93 | productions_: [0,[3,4],[3,2],[3,1],[4,1],[7,3],[7,3],[7,1],[9,2],[9,3],[9,3],[9,1],[13,2],[13,1],[15,1],[17,1],[17,3],[17,1],[20,1],[20,1],[20,3],[11,2],[11,2],[11,1],[25,3],[25,1],[27,1],[24,3],[24,1],[24,1],[24,1],[24,1],[24,3],[24,3],[36,1],[38,4],[38,4],[38,7],[38,4],[38,3],[38,3],[38,4],[26,1],[26,1],[26,7]],
 94 | performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate /* action[1] */, $$ /* vstack */, _$ /* lstack */) {
 95 | /* this == yyval */
 96 | 
 97 | var $0 = $$.length - 1;
 98 | switch (yystate) {
 99 | case 1:
100 | return new yy.Eq($$[$0-3], $$[$0-2], $$[$0-1]);
101 | break;
102 | case 2:
103 | return $$[$0-1];
104 | break;
105 | case 3:
106 | return new yy.Add([]);
107 | break;
108 | case 4: case 7: case 11: case 13: case 15: case 20: case 23: case 25: case 42: case 43:
109 | this.$ = $$[$0];
110 | break;
111 | case 5:
112 | this.$ = yy.Add.createOrAppend($$[$0-2], $$[$0]);
113 | break;
114 | case 6:
115 | this.$ = yy.Add.createOrAppend($$[$0-2], yy.Mul.handleNegative($$[$0], "subtract"));
116 | break;
117 | case 8:
118 | this.$ = yy.Mul.fold(yy.Mul.createOrAppend($$[$0-1], $$[$0]));
119 | break;
120 | case 9:
121 | this.$ = yy.Mul.fold(yy.Mul.createOrAppend($$[$0-2], $$[$0]));
122 | break;
123 | case 10:
124 | this.$ = yy.Mul.fold(yy.Mul.handleDivide($$[$0-2], $$[$0]));
125 | break;
126 | case 12:
127 | this.$ = yy.Mul.handleNegative($$[$0]);
128 | break;
129 | case 14: case 17:
130 | this.$ = [yytext];
131 | break;
132 | case 16:
133 | this.$ = $$[$0-2].concat($$[$0]);
134 | break;
135 | case 18:
136 | this.$ = yy.Log.natural();
137 | break;
138 | case 19:
139 | this.$ = yy.Log.common();
140 | break;
141 | case 21:
142 | this.$ = yy.Trig.create($$[$0-1], $$[$0]);
143 | break;
144 | case 22:
145 | this.$ = yy.Log.create($$[$0-1], $$[$0]);
146 | break;
147 | case 24:
148 | this.$ = new yy.Pow($$[$0-2], $$[$0]);
149 | break;
150 | case 26: case 34:
151 | this.$ = yytext;
152 | break;
153 | case 27:
154 | this.$ = new yy.Var($$[$0-2], $$[$0]);
155 | break;
156 | case 28:
157 | this.$ = new yy.Var($$[$0]);
158 | break;
159 | case 29:
160 | this.$ = new yy.Const(yytext.toLowerCase());
161 | break;
162 | case 30:
163 | this.$ = yy.Int.create(Number(yytext));
164 | break;
165 | case 31:
166 | this.$ = yy.Float.create(Number(yytext));
167 | break;
168 | case 32:
169 | this.$ = $$[$0-1].completeParse();
170 | break;
171 | case 33:
172 | this.$ = $$[$0-1].completeParse().addHint('parens');
173 | break;
174 | case 35: case 36:
175 | this.$ = yy.Pow.sqrt($$[$0-1]);
176 | break;
177 | case 37:
178 | this.$ = new yy.Pow.nthroot($$[$0-1], $$[$0-4]);
179 | break;
180 | case 38: case 39: case 40:
181 | this.$ = new yy.Abs($$[$0-1]);
182 | break;
183 | case 41:
184 | this.$ = new yy.Func($$[$0-3], $$[$0-1]);
185 | break;
186 | case 44:
187 | this.$ = yy.Mul.handleDivide($$[$0-4], $$[$0-1]);
188 | break;
189 | }
190 | },
191 | table: [{3:1,4:2,6:[1,3],7:4,9:5,10:$V0,11:8,13:6,15:12,16:$V1,17:9,19:$V2,20:10,21:$V3,22:$V4,24:18,25:11,26:16,27:21,28:$V5,29:$V6,30:$V7,31:$V8,32:$V9,34:$Va,36:31,37:$Vb,38:19,39:$Vc,42:$Vd,43:$Ve,44:$Vf,46:$Vg},{1:[3]},{5:[1,34],6:[1,35]},{1:[2,3]},o([5,6],[2,4],{8:$Vh,10:$Vi}),o($Vj,[2,7],{17:9,20:10,25:11,15:12,26:16,24:18,38:19,27:21,36:31,11:38,12:$Vk,14:$Vl,16:$V1,19:$V2,21:$V3,22:$V4,28:$V5,29:$V6,30:$V7,31:$V8,32:$V9,34:$Va,37:$Vb,39:$Vc,42:$Vd,44:$Vf,46:$Vg}),o($Vm,[2,11]),{10:$V0,11:8,13:41,15:12,16:$V1,17:9,19:$V2,20:10,21:$V3,22:$V4,24:18,25:11,26:16,27:21,28:$V5,29:$V6,30:$V7,31:$V8,32:$V9,34:$Va,36:31,37:$Vb,38:19,39:$Vc,42:$Vd,43:$Ve,44:$Vf,46:$Vg},o($Vm,[2,13]),{10:$V0,11:8,13:42,15:12,16:$V1,17:9,19:$V2,20:10,21:$V3,22:$V4,24:18,25:11,26:16,27:21,28:$V5,29:$V6,30:$V7,31:$V8,32:$V9,34:$Va,36:31,37:$Vb,38:19,39:$Vc,42:$Vd,43:$Ve,44:$Vf,46:$Vg},{10:$V0,11:8,13:43,15:12,16:$V1,17:9,19:$V2,20:10,21:$V3,22:$V4,24:18,25:11,26:16,27:21,28:$V5,29:$V6,30:$V7,31:$V8,32:$V9,34:$Va,36:31,37:$Vb,38:19,39:$Vc,42:$Vd,43:$Ve,44:$Vf,46:$Vg},o($Vm,[2,23]),o($Vn,[2,15],{18:[1,44]}),o($Vn,[2,17]),o($Vn,[2,18]),o($Vn,[2,19],{23:[1,45]}),o($Vm,[2,25],{18:[1,46]}),o([10,16,18,19,21,22,28,29,30,31,32,34,37,39,42,43,44,46],[2,14]),o($Vo,[2,42]),o($Vo,[2,43]),{32:[1,47]},o($Vo,[2,28],{23:[1,48]}),o($Vo,[2,29]),o($Vo,[2,30]),o($Vo,[2,31]),{7:49,9:5,10:$V0,11:8,13:6,15:12,16:$V1,17:9,19:$V2,20:10,21:$V3,22:$V4,24:18,25:11,26:16,27:21,28:$V5,29:$V6,30:$V7,31:$V8,32:$V9,34:$Va,36:31,37:$Vb,38:19,39:$Vc,42:$Vd,43:$Ve,44:$Vf,46:$Vg},{7:50,9:5,10:$V0,11:8,13:6,15:12,16:$V1,17:9,19:$V2,20:10,21:$V3,22:$V4,24:18,25:11,26:16,27:21,28:$V5,29:$V6,30:$V7,31:$V8,32:$V9,34:$Va,36:31,37:$Vb,38:19,39:$Vc,42:$Vd,43:$Ve,44:$Vf,46:$Vg},{32:[1,52],34:[1,51],40:[1,53]},{34:[1,54]},{7:55,9:5,10:$V0,11:8,13:6,15:12,16:$V1,17:9,19:$V2,20:10,21:$V3,22:$V4,24:18,25:11,26:16,27:21,28:$V5,29:$V6,30:$V7,31:$V8,32:$V9,34:$Va,36:31,37:$Vb,38:19,39:$Vc,42:$Vd,43:$Ve,44:$Vf,46:$Vg},{7:56,9:5,10:$V0,11:8,13:6,15:12,16:$V1,17:9,19:$V2,20:10,21:$V3,22:$V4,24:18,25:11,26:16,27:21,28:$V5,29:$V6,30:$V7,31:$V8,32:$V9,34:$Va,36:31,37:$Vb,38:19,39:$Vc,42:$Vd,43:$Ve,44:$Vf,46:$Vg},{34:[1,57]},o([5,6,8,10,12,14,16,18,19,21,22,23,28,29,30,31,32,33,34,35,37,39,41,42,43,44,45,46],[2,26]),{34:[2,34]},{4:58,7:4,9:5,10:$V0,11:8,13:6,15:12,16:$V1,17:9,19:$V2,20:10,21:$V3,22:$V4,24:18,25:11,26:16,27:21,28:$V5,29:$V6,30:$V7,31:$V8,32:$V9,34:$Va,36:31,37:$Vb,38:19,39:$Vc,42:$Vd,43:$Ve,44:$Vf,46:$Vg},{1:[2,2]},{9:59,10:$V0,11:8,13:6,15:12,16:$V1,17:9,19:$V2,20:10,21:$V3,22:$V4,24:18,25:11,26:16,27:21,28:$V5,29:$V6,30:$V7,31:$V8,32:$V9,34:$Va,36:31,37:$Vb,38:19,39:$Vc,42:$Vd,43:$Ve,44:$Vf,46:$Vg},{9:60,10:$V0,11:8,13:6,15:12,16:$V1,17:9,19:$V2,20:10,21:$V3,22:$V4,24:18,25:11,26:16,27:21,28:$V5,29:$V6,30:$V7,31:$V8,32:$V9,34:$Va,36:31,37:$Vb,38:19,39:$Vc,42:$Vd,43:$Ve,44:$Vf,46:$Vg},o($Vm,[2,8]),{10:$V0,11:8,13:61,15:12,16:$V1,17:9,19:$V2,20:10,21:$V3,22:$V4,24:18,25:11,26:16,27:21,28:$V5,29:$V6,30:$V7,31:$V8,32:$V9,34:$Va,36:31,37:$Vb,38:19,39:$Vc,42:$Vd,43:$Ve,44:$Vf,46:$Vg},{10:$V0,11:8,13:62,15:12,16:$V1,17:9,19:$V2,20:10,21:$V3,22:$V4,24:18,25:11,26:16,27:21,28:$V5,29:$V6,30:$V7,31:$V8,32:$V9,34:$Va,36:31,37:$Vb,38:19,39:$Vc,42:$Vd,43:$Ve,44:$Vf,46:$Vg},o($Vm,[2,12]),o($Vm,[2,21]),o($Vm,[2,22]),{10:$V0,11:8,13:63,15:12,16:$V1,17:9,19:$V2,20:10,21:$V3,22:$V4,24:18,25:11,26:16,27:21,28:$V5,29:$V6,30:$V7,31:$V8,32:$V9,34:$Va,36:31,37:$Vb,38:19,39:$Vc,42:$Vd,43:$Ve,44:$Vf,46:$Vg},{24:64,27:21,28:$V5,29:$V6,30:$V7,31:$V8,32:$V9,34:$Va},{10:$V0,11:8,13:65,15:12,16:$V1,17:9,19:$V2,20:10,21:$V3,22:$V4,24:18,25:11,26:16,27:21,28:$V5,29:$V6,30:$V7,31:$V8,32:$V9,34:$Va,36:31,37:$Vb,38:19,39:$Vc,42:$Vd,43:$Ve,44:$Vf,46:$Vg},{7:66,9:5,10:$V0,11:8,13:6,15:12,16:$V1,17:9,19:$V2,20:10,21:$V3,22:$V4,24:18,25:11,26:16,27:21,28:$V5,29:$V6,30:$V7,31:$V8,32:$V9,34:$Va,36:31,37:$Vb,38:19,39:$Vc,42:$Vd,43:$Ve,44:$Vf,46:$Vg},{24:67,27:21,28:$V5,29:$V6,30:$V7,31:$V8,32:$V9,34:$Va},{8:$Vh,10:$Vi,33:[1,68]},{8:$Vh,10:$Vi,35:[1,69]},{7:70,9:5,10:$V0,11:8,13:6,15:12,16:$V1,17:9,19:$V2,20:10,21:$V3,22:$V4,24:18,25:11,26:16,27:21,28:$V5,29:$V6,30:$V7,31:$V8,32:$V9,34:$Va,36:31,37:$Vb,38:19,39:$Vc,42:$Vd,43:$Ve,44:$Vf,46:$Vg},{7:71,9:5,10:$V0,11:8,13:6,15:12,16:$V1,17:9,19:$V2,20:10,21:$V3,22:$V4,24:18,25:11,26:16,27:21,28:$V5,29:$V6,30:$V7,31:$V8,32:$V9,34:$Va,36:31,37:$Vb,38:19,39:$Vc,42:$Vd,43:$Ve,44:$Vf,46:$Vg},{7:72,9:5,10:$V0,11:8,13:6,15:12,16:$V1,17:9,19:$V2,20:10,21:$V3,22:$V4,24:18,25:11,26:16,27:21,28:$V5,29:$V6,30:$V7,31:$V8,32:$V9,34:$Va,36:31,37:$Vb,38:19,39:$Vc,42:$Vd,43:$Ve,44:$Vf,46:$Vg},{7:73,9:5,10:$V0,11:8,13:6,15:12,16:$V1,17:9,19:$V2,20:10,21:$V3,22:$V4,24:18,25:11,26:16,27:21,28:$V5,29:$V6,30:$V7,31:$V8,32:$V9,34:$Va,36:31,37:$Vb,38:19,39:$Vc,42:$Vd,43:$Ve,44:$Vf,46:$Vg},{8:$Vh,10:$Vi,43:[1,74]},{8:$Vh,10:$Vi,45:[1,75]},{7:76,9:5,10:$V0,11:8,13:6,15:12,16:$V1,17:9,19:$V2,20:10,21:$V3,22:$V4,24:18,25:11,26:16,27:21,28:$V5,29:$V6,30:$V7,31:$V8,32:$V9,34:$Va,36:31,37:$Vb,38:19,39:$Vc,42:$Vd,43:$Ve,44:$Vf,46:$Vg},{6:[1,77]},o($Vj,[2,5],{17:9,20:10,25:11,15:12,26:16,24:18,38:19,27:21,36:31,11:38,12:$Vk,14:$Vl,16:$V1,19:$V2,21:$V3,22:$V4,28:$V5,29:$V6,30:$V7,31:$V8,32:$V9,34:$Va,37:$Vb,39:$Vc,42:$Vd,44:$Vf,46:$Vg}),o($Vj,[2,6],{17:9,20:10,25:11,15:12,26:16,24:18,38:19,27:21,36:31,11:38,12:$Vk,14:$Vl,16:$V1,19:$V2,21:$V3,22:$V4,28:$V5,29:$V6,30:$V7,31:$V8,32:$V9,34:$Va,37:$Vb,39:$Vc,42:$Vd,44:$Vf,46:$Vg}),o($Vm,[2,9]),o($Vm,[2,10]),o($Vn,[2,16]),o($Vn,[2,20]),o($Vm,[2,24]),{8:$Vh,10:$Vi,33:[1,78]},o($Vo,[2,27]),o($Vo,[2,32]),o($Vo,[2,33]),{8:$Vh,10:$Vi,35:[1,79]},{8:$Vh,10:$Vi,33:[1,80]},{8:$Vh,10:$Vi,41:[1,81]},{8:$Vh,10:$Vi,35:[1,82]},o($Vo,[2,39]),o($Vo,[2,40]),{8:$Vh,10:$Vi,35:[1,83]},{1:[2,1]},{32:[1,84]},o($Vo,[2,35]),o($Vo,[2,36]),{32:[1,85]},o($Vo,[2,38]),o($Vo,[2,41]),{7:86,9:5,10:$V0,11:8,13:6,15:12,16:$V1,17:9,19:$V2,20:10,21:$V3,22:$V4,24:18,25:11,26:16,27:21,28:$V5,29:$V6,30:$V7,31:$V8,32:$V9,34:$Va,36:31,37:$Vb,38:19,39:$Vc,42:$Vd,43:$Ve,44:$Vf,46:$Vg},{7:87,9:5,10:$V0,11:8,13:6,15:12,16:$V1,17:9,19:$V2,20:10,21:$V3,22:$V4,24:18,25:11,26:16,27:21,28:$V5,29:$V6,30:$V7,31:$V8,32:$V9,34:$Va,36:31,37:$Vb,38:19,39:$Vc,42:$Vd,43:$Ve,44:$Vf,46:$Vg},{8:$Vh,10:$Vi,33:[1,88]},{8:$Vh,10:$Vi,33:[1,89]},o($Vo,[2,44]),o($Vo,[2,37])],
192 | defaultActions: {3:[2,3],33:[2,34],35:[2,2],77:[2,1]},
193 | parseError: function parseError (str, hash) {
194 |     if (hash.recoverable) {
195 |         this.trace(str);
196 |     } else {
197 |         throw new Error(str);
198 |     }
199 | },
200 | parse: function parse(input) {
201 |     var self = this, stack = [0], tstack = [], vstack = [null], lstack = [], table = this.table, yytext = '', yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF = 1;
202 |     var args = lstack.slice.call(arguments, 1);
203 |     var lexer = Object.create(this.lexer);
204 |     var sharedState = { yy: {} };
205 |     for (var k in this.yy) {
206 |         if (Object.prototype.hasOwnProperty.call(this.yy, k)) {
207 |             sharedState.yy[k] = this.yy[k];
208 |         }
209 |     }
210 |     lexer.setInput(input, sharedState.yy);
211 |     sharedState.yy.lexer = lexer;
212 |     sharedState.yy.parser = this;
213 |     if (typeof lexer.yylloc == 'undefined') {
214 |         lexer.yylloc = {};
215 |     }
216 |     var yyloc = lexer.yylloc;
217 |     lstack.push(yyloc);
218 |     var ranges = lexer.options && lexer.options.ranges;
219 |     if (typeof sharedState.yy.parseError === 'function') {
220 |         this.parseError = sharedState.yy.parseError;
221 |     } else {
222 |         this.parseError = Object.getPrototypeOf(this).parseError;
223 |     }
224 |     function popStack(n) {
225 |         stack.length = stack.length - 2 * n;
226 |         vstack.length = vstack.length - n;
227 |         lstack.length = lstack.length - n;
228 |     }
229 |     //_token_stack:
230 |         function lex() {
231 |             var token;
232 |             token = lexer.lex() || EOF;
233 |             if (typeof token !== 'number') {
234 |                 token = self.symbols_[token] || token;
235 |             }
236 |             return token;
237 |         }
238 |     var symbol, preErrorSymbol, state, action, a, r, yyval = {}, p, len, newState, expected;
239 |     while (true) {
240 |         state = stack[stack.length - 1];
241 |         if (this.defaultActions[state]) {
242 |             action = this.defaultActions[state];
243 |         } else {
244 |             if (symbol === null || typeof symbol == 'undefined') {
245 |                 symbol = lex();
246 |             }
247 |             action = table[state] && table[state][symbol];
248 |         }
249 |                     if (typeof action === 'undefined' || !action.length || !action[0]) {
250 |                 var errStr = '';
251 |                 expected = [];
252 |                 for (p in table[state]) {
253 |                     if (this.terminals_[p] && p > TERROR) {
254 |                         expected.push('\'' + this.terminals_[p] + '\'');
255 |                     }
256 |                 }
257 |                 if (lexer.showPosition) {
258 |                     errStr = 'Parse error on line ' + (yylineno + 1) + ':\n' + lexer.showPosition() + '\nExpecting ' + expected.join(', ') + ', got \'' + (this.terminals_[symbol] || symbol) + '\'';
259 |                 } else {
260 |                     errStr = 'Parse error on line ' + (yylineno + 1) + ': Unexpected ' + (symbol == EOF ? 'end of input' : '\'' + (this.terminals_[symbol] || symbol) + '\'');
261 |                 }
262 |                 this.parseError(errStr, {
263 |                     text: lexer.match,
264 |                     token: this.terminals_[symbol] || symbol,
265 |                     line: lexer.yylineno,
266 |                     loc: yyloc,
267 |                     expected: expected
268 |                 });
269 |             }
270 |         if (action[0] instanceof Array && action.length > 1) {
271 |             throw new Error('Parse Error: multiple actions possible at state: ' + state + ', token: ' + symbol);
272 |         }
273 |         switch (action[0]) {
274 |         case 1:
275 |             stack.push(symbol);
276 |             vstack.push(lexer.yytext);
277 |             lstack.push(lexer.yylloc);
278 |             stack.push(action[1]);
279 |             symbol = null;
280 |             if (!preErrorSymbol) {
281 |                 yyleng = lexer.yyleng;
282 |                 yytext = lexer.yytext;
283 |                 yylineno = lexer.yylineno;
284 |                 yyloc = lexer.yylloc;
285 |                 if (recovering > 0) {
286 |                     recovering--;
287 |                 }
288 |             } else {
289 |                 symbol = preErrorSymbol;
290 |                 preErrorSymbol = null;
291 |             }
292 |             break;
293 |         case 2:
294 |             len = this.productions_[action[1]][1];
295 |             yyval.$ = vstack[vstack.length - len];
296 |             yyval._$ = {
297 |                 first_line: lstack[lstack.length - (len || 1)].first_line,
298 |                 last_line: lstack[lstack.length - 1].last_line,
299 |                 first_column: lstack[lstack.length - (len || 1)].first_column,
300 |                 last_column: lstack[lstack.length - 1].last_column
301 |             };
302 |             if (ranges) {
303 |                 yyval._$.range = [
304 |                     lstack[lstack.length - (len || 1)].range[0],
305 |                     lstack[lstack.length - 1].range[1]
306 |                 ];
307 |             }
308 |             r = this.performAction.apply(yyval, [
309 |                 yytext,
310 |                 yyleng,
311 |                 yylineno,
312 |                 sharedState.yy,
313 |                 action[1],
314 |                 vstack,
315 |                 lstack
316 |             ].concat(args));
317 |             if (typeof r !== 'undefined') {
318 |                 return r;
319 |             }
320 |             if (len) {
321 |                 stack = stack.slice(0, -1 * len * 2);
322 |                 vstack = vstack.slice(0, -1 * len);
323 |                 lstack = lstack.slice(0, -1 * len);
324 |             }
325 |             stack.push(this.productions_[action[1]][0]);
326 |             vstack.push(yyval.$);
327 |             lstack.push(yyval._$);
328 |             newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
329 |             stack.push(newState);
330 |             break;
331 |         case 3:
332 |             return true;
333 |         }
334 |     }
335 |     return true;
336 | }};
337 | /* generated by jison-lex 0.3.4 */
338 | var lexer = (function(){
339 | var lexer = ({
340 | 
341 | EOF:1,
342 | 
343 | parseError:function parseError(str, hash) {
344 |         if (this.yy.parser) {
345 |             this.yy.parser.parseError(str, hash);
346 |         } else {
347 |             throw new Error(str);
348 |         }
349 |     },
350 | 
351 | // resets the lexer, sets new input
352 | setInput:function (input, yy) {
353 |         this.yy = yy || this.yy || {};
354 |         this._input = input;
355 |         this._more = this._backtrack = this.done = false;
356 |         this.yylineno = this.yyleng = 0;
357 |         this.yytext = this.matched = this.match = '';
358 |         this.conditionStack = ['INITIAL'];
359 |         this.yylloc = {
360 |             first_line: 1,
361 |             first_column: 0,
362 |             last_line: 1,
363 |             last_column: 0
364 |         };
365 |         if (this.options.ranges) {
366 |             this.yylloc.range = [0,0];
367 |         }
368 |         this.offset = 0;
369 |         return this;
370 |     },
371 | 
372 | // consumes and returns one char from the input
373 | input:function () {
374 |         var ch = this._input[0];
375 |         this.yytext += ch;
376 |         this.yyleng++;
377 |         this.offset++;
378 |         this.match += ch;
379 |         this.matched += ch;
380 |         var lines = ch.match(/(?:\r\n?|\n).*/g);
381 |         if (lines) {
382 |             this.yylineno++;
383 |             this.yylloc.last_line++;
384 |         } else {
385 |             this.yylloc.last_column++;
386 |         }
387 |         if (this.options.ranges) {
388 |             this.yylloc.range[1]++;
389 |         }
390 | 
391 |         this._input = this._input.slice(1);
392 |         return ch;
393 |     },
394 | 
395 | // unshifts one char (or a string) into the input
396 | unput:function (ch) {
397 |         var len = ch.length;
398 |         var lines = ch.split(/(?:\r\n?|\n)/g);
399 | 
400 |         this._input = ch + this._input;
401 |         this.yytext = this.yytext.substr(0, this.yytext.length - len);
402 |         //this.yyleng -= len;
403 |         this.offset -= len;
404 |         var oldLines = this.match.split(/(?:\r\n?|\n)/g);
405 |         this.match = this.match.substr(0, this.match.length - 1);
406 |         this.matched = this.matched.substr(0, this.matched.length - 1);
407 | 
408 |         if (lines.length - 1) {
409 |             this.yylineno -= lines.length - 1;
410 |         }
411 |         var r = this.yylloc.range;
412 | 
413 |         this.yylloc = {
414 |             first_line: this.yylloc.first_line,
415 |             last_line: this.yylineno + 1,
416 |             first_column: this.yylloc.first_column,
417 |             last_column: lines ?
418 |                 (lines.length === oldLines.length ? this.yylloc.first_column : 0)
419 |                  + oldLines[oldLines.length - lines.length].length - lines[0].length :
420 |               this.yylloc.first_column - len
421 |         };
422 | 
423 |         if (this.options.ranges) {
424 |             this.yylloc.range = [r[0], r[0] + this.yyleng - len];
425 |         }
426 |         this.yyleng = this.yytext.length;
427 |         return this;
428 |     },
429 | 
430 | // When called from action, caches matched text and appends it on next action
431 | more:function () {
432 |         this._more = true;
433 |         return this;
434 |     },
435 | 
436 | // When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead.
437 | reject:function () {
438 |         if (this.options.backtrack_lexer) {
439 |             this._backtrack = true;
440 |         } else {
441 |             return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n' + this.showPosition(), {
442 |                 text: "",
443 |                 token: null,
444 |                 line: this.yylineno
445 |             });
446 | 
447 |         }
448 |         return this;
449 |     },
450 | 
451 | // retain first n characters of the match
452 | less:function (n) {
453 |         this.unput(this.match.slice(n));
454 |     },
455 | 
456 | // displays already matched input, i.e. for error messages
457 | pastInput:function () {
458 |         var past = this.matched.substr(0, this.matched.length - this.match.length);
459 |         return (past.length > 20 ? '...':'') + past.substr(-20).replace(/\n/g, "");
460 |     },
461 | 
462 | // displays upcoming input, i.e. for error messages
463 | upcomingInput:function () {
464 |         var next = this.match;
465 |         if (next.length < 20) {
466 |             next += this._input.substr(0, 20-next.length);
467 |         }
468 |         return (next.substr(0,20) + (next.length > 20 ? '...' : '')).replace(/\n/g, "");
469 |     },
470 | 
471 | // displays the character position where the lexing error occurred, i.e. for error messages
472 | showPosition:function () {
473 |         var pre = this.pastInput();
474 |         var c = new Array(pre.length + 1).join("-");
475 |         return pre + this.upcomingInput() + "\n" + c + "^";
476 |     },
477 | 
478 | // test the lexed token: return FALSE when not a match, otherwise return token
479 | test_match:function(match, indexed_rule) {
480 |         var token,
481 |             lines,
482 |             backup;
483 | 
484 |         if (this.options.backtrack_lexer) {
485 |             // save context
486 |             backup = {
487 |                 yylineno: this.yylineno,
488 |                 yylloc: {
489 |                     first_line: this.yylloc.first_line,
490 |                     last_line: this.last_line,
491 |                     first_column: this.yylloc.first_column,
492 |                     last_column: this.yylloc.last_column
493 |                 },
494 |                 yytext: this.yytext,
495 |                 match: this.match,
496 |                 matches: this.matches,
497 |                 matched: this.matched,
498 |                 yyleng: this.yyleng,
499 |                 offset: this.offset,
500 |                 _more: this._more,
501 |                 _input: this._input,
502 |                 yy: this.yy,
503 |                 conditionStack: this.conditionStack.slice(0),
504 |                 done: this.done
505 |             };
506 |             if (this.options.ranges) {
507 |                 backup.yylloc.range = this.yylloc.range.slice(0);
508 |             }
509 |         }
510 | 
511 |         lines = match[0].match(/(?:\r\n?|\n).*/g);
512 |         if (lines) {
513 |             this.yylineno += lines.length;
514 |         }
515 |         this.yylloc = {
516 |             first_line: this.yylloc.last_line,
517 |             last_line: this.yylineno + 1,
518 |             first_column: this.yylloc.last_column,
519 |             last_column: lines ?
520 |                          lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length :
521 |                          this.yylloc.last_column + match[0].length
522 |         };
523 |         this.yytext += match[0];
524 |         this.match += match[0];
525 |         this.matches = match;
526 |         this.yyleng = this.yytext.length;
527 |         if (this.options.ranges) {
528 |             this.yylloc.range = [this.offset, this.offset += this.yyleng];
529 |         }
530 |         this._more = false;
531 |         this._backtrack = false;
532 |         this._input = this._input.slice(match[0].length);
533 |         this.matched += match[0];
534 |         token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]);
535 |         if (this.done && this._input) {
536 |             this.done = false;
537 |         }
538 |         if (token) {
539 |             return token;
540 |         } else if (this._backtrack) {
541 |             // recover context
542 |             for (var k in backup) {
543 |                 this[k] = backup[k];
544 |             }
545 |             return false; // rule action called reject() implying the next rule should be tested instead.
546 |         }
547 |         return false;
548 |     },
549 | 
550 | // return next match in input
551 | next:function () {
552 |         if (this.done) {
553 |             return this.EOF;
554 |         }
555 |         if (!this._input) {
556 |             this.done = true;
557 |         }
558 | 
559 |         var token,
560 |             match,
561 |             tempMatch,
562 |             index;
563 |         if (!this._more) {
564 |             this.yytext = '';
565 |             this.match = '';
566 |         }
567 |         var rules = this._currentRules();
568 |         for (var i = 0; i < rules.length; i++) {
569 |             tempMatch = this._input.match(this.rules[rules[i]]);
570 |             if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
571 |                 match = tempMatch;
572 |                 index = i;
573 |                 if (this.options.backtrack_lexer) {
574 |                     token = this.test_match(tempMatch, rules[i]);
575 |                     if (token !== false) {
576 |                         return token;
577 |                     } else if (this._backtrack) {
578 |                         match = false;
579 |                         continue; // rule action called reject() implying a rule MISmatch.
580 |                     } else {
581 |                         // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
582 |                         return false;
583 |                     }
584 |                 } else if (!this.options.flex) {
585 |                     break;
586 |                 }
587 |             }
588 |         }
589 |         if (match) {
590 |             token = this.test_match(match, rules[index]);
591 |             if (token !== false) {
592 |                 return token;
593 |             }
594 |             // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
595 |             return false;
596 |         }
597 |         if (this._input === "") {
598 |             return this.EOF;
599 |         } else {
600 |             return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. Unrecognized text.\n' + this.showPosition(), {
601 |                 text: "",
602 |                 token: null,
603 |                 line: this.yylineno
604 |             });
605 |         }
606 |     },
607 | 
608 | // return next match that has a token
609 | lex:function lex () {
610 |         var r = this.next();
611 |         if (r) {
612 |             return r;
613 |         } else {
614 |             return this.lex();
615 |         }
616 |     },
617 | 
618 | // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
619 | begin:function begin (condition) {
620 |         this.conditionStack.push(condition);
621 |     },
622 | 
623 | // pop the previously active lexer condition state off the condition stack
624 | popState:function popState () {
625 |         var n = this.conditionStack.length - 1;
626 |         if (n > 0) {
627 |             return this.conditionStack.pop();
628 |         } else {
629 |             return this.conditionStack[0];
630 |         }
631 |     },
632 | 
633 | // produce the lexer rule set which is active for the currently active lexer condition state
634 | _currentRules:function _currentRules () {
635 |         if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {
636 |             return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
637 |         } else {
638 |             return this.conditions["INITIAL"].rules;
639 |         }
640 |     },
641 | 
642 | // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
643 | topState:function topState (n) {
644 |         n = this.conditionStack.length - 1 - Math.abs(n || 0);
645 |         if (n >= 0) {
646 |             return this.conditionStack[n];
647 |         } else {
648 |             return "INITIAL";
649 |         }
650 |     },
651 | 
652 | // alias for begin(condition)
653 | pushState:function pushState (condition) {
654 |         this.begin(condition);
655 |     },
656 | 
657 | // return the number of states currently on the stack
658 | stateStackSize:function stateStackSize() {
659 |         return this.conditionStack.length;
660 |     },
661 | options: {"flex":true},
662 | performAction: function anonymous(yy,yy_,$avoiding_name_collisions,YY_START) {
663 | var YYSTATE=YY_START;
664 | switch($avoiding_name_collisions) {
665 | case 0:/* skip whitespace */
666 | break;
667 | case 1:/* skip \space */
668 | break;
669 | case 2:/* skip '\ ' */
670 | break;
671 | case 3:return "INT"
672 | break;
673 | case 4:return "FLOAT"
674 | break;
675 | case 5:return "^"
676 | break;
677 | case 6:return "*"
678 | break;
679 | case 7:return "*"
680 | break;
681 | case 8:return "*"
682 | break;
683 | case 9:return "*"
684 | break;
685 | case 10:return "/"
686 | break;
687 | case 11:return "/"
688 | break;
689 | case 12:return "-"
690 | break;
691 | case 13:return "-"
692 | break;
693 | case 14:return "+"
694 | break;
695 | case 15:return "^"
696 | break;
697 | case 16:return "("
698 | break;
699 | case 17:return ")"
700 | break;
701 | case 18:return "("
702 | break;
703 | case 19:return ")"
704 | break;
705 | case 20:return "["
706 | break;
707 | case 21:return "]"
708 | break;
709 | case 22:return "{"
710 | break;
711 | case 23:return "}"
712 | break;
713 | case 24:return "{"
714 | break;
715 | case 25:return "}"
716 | break;
717 | case 26:return "_"
718 | break;
719 | case 27:return "|"
720 | break;
721 | case 28:return "LEFT|"
722 | break;
723 | case 29:return "RIGHT|"
724 | break;
725 | case 30:return "!"
726 | break;
727 | case 31:return "SIGN"
728 | break;
729 | case 32:yy_.yytext = "<="; return "SIGN"
730 | break;
731 | case 33:yy_.yytext = ">="; return "SIGN"
732 | break;
733 | case 34:yy_.yytext = "<="; return "SIGN"
734 | break;
735 | case 35:yy_.yytext = ">="; return "SIGN"
736 | break;
737 | case 36:yy_.yytext = "<>"; return "SIGN"
738 | break;
739 | case 37:yy_.yytext = "<>"; return "SIGN"
740 | break;
741 | case 38:yy_.yytext = "<>"; return "SIGN"
742 | break;
743 | case 39:yy_.yytext = "<>"; return "SIGN"
744 | break;
745 | case 40:yy_.yytext = "<="; return "SIGN"
746 | break;
747 | case 41:yy_.yytext = ">="; return "SIGN"
748 | break;
749 | case 42:return "FRAC"
750 | break;
751 | case 43:return "FRAC"
752 | break;
753 | case 44:return "sqrt"
754 | break;
755 | case 45:return "abs"
756 | break;
757 | case 46:return "ln"
758 | break;
759 | case 47:return "log"
760 | break;
761 | case 48:return "TRIG"
762 | break;
763 | case 49:return "TRIG"
764 | break;
765 | case 50:return "TRIG"
766 | break;
767 | case 51:return "TRIG"
768 | break;
769 | case 52:yy_.yytext = "sin"; return "TRIG"
770 | break;
771 | case 53:yy_.yytext = "cos"; return "TRIG"
772 | break;
773 | case 54:yy_.yytext = "tan"; return "TRIG"
774 | break;
775 | case 55:yy_.yytext = "csc"; return "TRIG"
776 | break;
777 | case 56:yy_.yytext = "sec"; return "TRIG"
778 | break;
779 | case 57:yy_.yytext = "cot"; return "TRIG"
780 | break;
781 | case 58:yy_.yytext = "arcsin"; return "TRIG"
782 | break;
783 | case 59:yy_.yytext = "arccos"; return "TRIG"
784 | break;
785 | case 60:yy_.yytext = "arctan"; return "TRIG"
786 | break;
787 | case 61:yy_.yytext = "arccsc"; return "TRIG"
788 | break;
789 | case 62:yy_.yytext = "arcsec"; return "TRIG"
790 | break;
791 | case 63:yy_.yytext = "arccot"; return "TRIG"
792 | break;
793 | case 64:return "TRIGINV"
794 | break;
795 | case 65:return "TRIGINV"
796 | break;
797 | case 66:yy_.yytext = "sinh"; return "TRIG"
798 | break;
799 | case 67:yy_.yytext = "cosh"; return "TRIG"
800 | break;
801 | case 68:yy_.yytext = "tanh"; return "TRIG"
802 | break;
803 | case 69:yy_.yytext = "csch"; return "TRIG"
804 | break;
805 | case 70:yy_.yytext = "sech"; return "TRIG"
806 | break;
807 | case 71:yy_.yytext = "tanh"; return "TRIG"
808 | break;
809 | case 72:return "CONST"
810 | break;
811 | case 73:yy_.yytext = "pi"; return "CONST"
812 | break;
813 | case 74:yy_.yytext = "pi"; return "CONST"
814 | break;
815 | case 75:return "VAR"
816 | break;
817 | case 76:yy_.yytext = "theta"; return "VAR"
818 | break;
819 | case 77:yy_.yytext = "theta"; return "VAR"
820 | break;
821 | case 78:return "VAR"
822 | break;
823 | case 79:yy_.yytext = "phi"; return "VAR"
824 | break;
825 | case 80:yy_.yytext = "phi"; return "VAR"
826 | break;
827 | case 81:return yy.symbolLexer(yy_.yytext)
828 | break;
829 | case 82:return "EOF"
830 | break;
831 | case 83:return "INVALID"
832 | break;
833 | case 84:console.log(yy_.yytext);
834 | break;
835 | }
836 | },
837 | rules: [/^(?:\s+)/,/^(?:\\space)/,/^(?:\\ )/,/^(?:[0-9]+\.?)/,/^(?:([0-9]+)?\.[0-9]+)/,/^(?:\*\*)/,/^(?:\*)/,/^(?:\\cdot|·)/,/^(?:\\times|×)/,/^(?:\\ast)/,/^(?:\/)/,/^(?:\\div|÷)/,/^(?:-)/,/^(?:−)/,/^(?:\+)/,/^(?:\^)/,/^(?:\()/,/^(?:\))/,/^(?:\\left\()/,/^(?:\\right\))/,/^(?:\[)/,/^(?:\])/,/^(?:\{)/,/^(?:\})/,/^(?:\\left\{)/,/^(?:\\right\})/,/^(?:_)/,/^(?:\|)/,/^(?:\\left\|)/,/^(?:\\right\|)/,/^(?:\!)/,/^(?:<=|>=|<>|<|>|=)/,/^(?:\\le)/,/^(?:\\ge)/,/^(?:\\leq)/,/^(?:\\geq)/,/^(?:=\/=)/,/^(?:\\ne)/,/^(?:\\neq)/,/^(?:≠)/,/^(?:≤)/,/^(?:≥)/,/^(?:\\frac)/,/^(?:\\dfrac)/,/^(?:sqrt|\\sqrt)/,/^(?:abs|\\abs)/,/^(?:ln|\\ln)/,/^(?:log|\\log)/,/^(?:sin|cos|tan)/,/^(?:csc|sec|cot)/,/^(?:sinh|cosh|tanh)/,/^(?:csch|sech|coth)/,/^(?:\\sin)/,/^(?:\\cos)/,/^(?:\\tan)/,/^(?:\\csc)/,/^(?:\\sec)/,/^(?:\\cot)/,/^(?:\\arcsin)/,/^(?:\\arccos)/,/^(?:\\arctan)/,/^(?:\\arccsc)/,/^(?:\\arcsec)/,/^(?:\\arccot)/,/^(?:arcsin|arccos|arctan)/,/^(?:arccsc|arcsec|arccot)/,/^(?:\\sinh)/,/^(?:\\cosh)/,/^(?:\\tanh)/,/^(?:\\csch)/,/^(?:\\sech)/,/^(?:\\coth)/,/^(?:pi)/,/^(?:π)/,/^(?:\\pi)/,/^(?:theta)/,/^(?:θ)/,/^(?:\\theta)/,/^(?:phi)/,/^(?:φ)/,/^(?:\\phi)/,/^(?:[a-zA-Z])/,/^(?:$)/,/^(?:.)/,/^(?:.)/],
838 | conditions: {"INITIAL":{"rules":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84],"inclusive":true}}
839 | });
840 | return lexer;
841 | })();
842 | parser.lexer = lexer;
843 | function Parser () {
844 |   this.yy = {};
845 | }
846 | Parser.prototype = parser;parser.Parser = Parser;
847 | return new Parser;
848 | })();
849 | 
850 | KAS.parser = parser;
851 | })(KAS);


--------------------------------------------------------------------------------
/src/unitparser.js:
--------------------------------------------------------------------------------
  1 | // this is a @generated file
  2 | (function(KAS) {
  3 | 
  4 | /* parser generated by jison 0.4.15 */
  5 | /*
  6 |   Returns a Parser object of the following structure:
  7 | 
  8 |   Parser: {
  9 |     yy: {}
 10 |   }
 11 | 
 12 |   Parser.prototype: {
 13 |     yy: {},
 14 |     trace: function(),
 15 |     symbols_: {associative list: name ==> number},
 16 |     terminals_: {associative list: number ==> name},
 17 |     productions_: [...],
 18 |     performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$),
 19 |     table: [...],
 20 |     defaultActions: {...},
 21 |     parseError: function(str, hash),
 22 |     parse: function(input),
 23 | 
 24 |     lexer: {
 25 |         EOF: 1,
 26 |         parseError: function(str, hash),
 27 |         setInput: function(input),
 28 |         input: function(),
 29 |         unput: function(str),
 30 |         more: function(),
 31 |         less: function(n),
 32 |         pastInput: function(),
 33 |         upcomingInput: function(),
 34 |         showPosition: function(),
 35 |         test_match: function(regex_match_array, rule_index),
 36 |         next: function(),
 37 |         lex: function(),
 38 |         begin: function(condition),
 39 |         popState: function(),
 40 |         _currentRules: function(),
 41 |         topState: function(),
 42 |         pushState: function(condition),
 43 | 
 44 |         options: {
 45 |             ranges: boolean           (optional: true ==> token location info will include a .range[] member)
 46 |             flex: boolean             (optional: true ==> flex-like lexing behaviour where the rules are tested exhaustively to find the longest match)
 47 |             backtrack_lexer: boolean  (optional: true ==> lexer regexes are tested in order and for each matching regex the action code is invoked; the lexer terminates the scan when a token is returned by the action code)
 48 |         },
 49 | 
 50 |         performAction: function(yy, yy_, $avoiding_name_collisions, YY_START),
 51 |         rules: [...],
 52 |         conditions: {associative list: name ==> set},
 53 |     }
 54 |   }
 55 | 
 56 | 
 57 |   token location info (@$, _$, etc.): {
 58 |     first_line: n,
 59 |     last_line: n,
 60 |     first_column: n,
 61 |     last_column: n,
 62 |     range: [start_number, end_number]       (where the numbers are indexes into the input string, regular zero-based)
 63 |   }
 64 | 
 65 | 
 66 |   the parseError function receives a 'hash' object with these members for lexer and parser errors: {
 67 |     text:        (matched text)
 68 |     token:       (the produced terminal token, if any)
 69 |     line:        (yylineno)
 70 |   }
 71 |   while parser (grammar) errors will also provide these members, i.e. parser errors deliver a superset of attributes: {
 72 |     loc:         (yylloc)
 73 |     expected:    (string describing the set of expected tokens)
 74 |     recoverable: (boolean: TRUE when the parser has a error recovery rule available for this particular error)
 75 |   }
 76 | */
 77 | var parser = (function(){
 78 | var o=function(k,v,o,l){for(o=o||{},l=k.length;l--;o[k[l]]=v);return o},$V0=[1,11],$V1=[1,9],$V2=[8,17],$V3=[6,11],$V4=[6,11,13,17];
 79 | var parser = {trace: function trace () { },
 80 | yy: {},
 81 | symbols_: {"error":2,"unitvalue":3,"magnitude":4,"unit":5,"EOF":6,"float":7,"POW":8,"int":9,"multatoms":10,"DIV":11,"expatom":12,"MUL":13,"atom":14,"^":15,"nat":16,"ATOM":17,"FLOAT":18,"NAT":19,"NEG":20,"$accept":0,"$end":1},
 82 | terminals_: {2:"error",6:"EOF",8:"POW",11:"DIV",13:"MUL",15:"^",17:"ATOM",18:"FLOAT",19:"NAT",20:"NEG"},
 83 | productions_: [0,[3,3],[3,2],[4,3],[4,1],[5,3],[5,1],[10,3],[10,2],[10,1],[12,3],[12,1],[14,1],[7,1],[7,1],[16,1],[9,2],[9,1]],
 84 | performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate /* action[1] */, $$ /* vstack */, _$ /* lstack */) {
 85 | /* this == yyval */
 86 | 
 87 | var $0 = $$.length - 1;
 88 | switch (yystate) {
 89 | case 1:
 90 | 
 91 |             return {
 92 |                 type: "unitMagnitude",
 93 |                 magnitude: $$[$0-2],
 94 |                 unit: $$[$0-1],
 95 |             };
 96 |         
 97 | break;
 98 | case 2:
 99 | 
100 |             return {
101 |                 type: "unitStandalone",
102 |                 unit: $$[$0-1],
103 |             }
104 |         
105 | break;
106 | case 3:
107 | 
108 |             this.$ = $$[$0-2] + "e" + $$[$0];
109 |         
110 | break;
111 | case 4: case 13: case 14: case 15: case 17:
112 |  this.$ = $$[$0]; 
113 | break;
114 | case 5:
115 | 
116 |             this.$ = {
117 |                 num: $$[$0-2],
118 |                 denom: $$[$0],
119 |             };
120 |         
121 | break;
122 | case 6:
123 | 
124 |             this.$ = {
125 |                 num: $$[$0],
126 |                 denom: null,
127 |             };
128 |         
129 | break;
130 | case 7:
131 |  this.$ = [$$[$0-2]].concat($$[$0]); 
132 | break;
133 | case 8:
134 |  this.$ = [$$[$0-1]].concat($$[$0]); 
135 | break;
136 | case 9:
137 |  this.$ = [$$[$0]]; 
138 | break;
139 | case 10:
140 | 
141 |             this.$ = {
142 |                 name: $$[$0-2],
143 |                 pow: $$[$0],
144 |             };
145 |         
146 | break;
147 | case 11:
148 | 
149 |             this.$ = {
150 |                 name: $$[$0],
151 |                 pow: 1,
152 |             };
153 |         
154 | break;
155 | case 12:
156 |  this.$ = yytext; 
157 | break;
158 | case 16:
159 |  this.$ = "-" + $$[$0]; 
160 | break;
161 | }
162 | },
163 | table: [{3:1,4:2,5:3,7:4,10:5,12:8,14:10,16:7,17:$V0,18:[1,6],19:$V1},{1:[3]},{5:12,10:5,12:8,14:10,17:$V0},{6:[1,13]},{8:[1,14],17:[2,4]},{6:[2,6],11:[1,15]},o($V2,[2,13]),o($V2,[2,14]),o($V3,[2,9],{12:8,14:10,10:17,13:[1,16],17:$V0}),o([6,8,11,13,17],[2,15]),o($V4,[2,11],{15:[1,18]}),o([6,11,13,15,17],[2,12]),{6:[1,19]},{1:[2,2]},{9:20,19:[1,22],20:[1,21]},{10:23,12:8,14:10,17:$V0},{10:24,12:8,14:10,17:$V0},o($V3,[2,8]),{16:25,19:$V1},{1:[2,1]},{17:[2,3]},{19:[1,26]},{17:[2,17]},{6:[2,5]},o($V3,[2,7]),o($V4,[2,10]),{17:[2,16]}],
164 | defaultActions: {13:[2,2],19:[2,1],20:[2,3],22:[2,17],23:[2,5],26:[2,16]},
165 | parseError: function parseError (str, hash) {
166 |     if (hash.recoverable) {
167 |         this.trace(str);
168 |     } else {
169 |         throw new Error(str);
170 |     }
171 | },
172 | parse: function parse(input) {
173 |     var self = this, stack = [0], tstack = [], vstack = [null], lstack = [], table = this.table, yytext = '', yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF = 1;
174 |     var args = lstack.slice.call(arguments, 1);
175 |     var lexer = Object.create(this.lexer);
176 |     var sharedState = { yy: {} };
177 |     for (var k in this.yy) {
178 |         if (Object.prototype.hasOwnProperty.call(this.yy, k)) {
179 |             sharedState.yy[k] = this.yy[k];
180 |         }
181 |     }
182 |     lexer.setInput(input, sharedState.yy);
183 |     sharedState.yy.lexer = lexer;
184 |     sharedState.yy.parser = this;
185 |     if (typeof lexer.yylloc == 'undefined') {
186 |         lexer.yylloc = {};
187 |     }
188 |     var yyloc = lexer.yylloc;
189 |     lstack.push(yyloc);
190 |     var ranges = lexer.options && lexer.options.ranges;
191 |     if (typeof sharedState.yy.parseError === 'function') {
192 |         this.parseError = sharedState.yy.parseError;
193 |     } else {
194 |         this.parseError = Object.getPrototypeOf(this).parseError;
195 |     }
196 |     function popStack(n) {
197 |         stack.length = stack.length - 2 * n;
198 |         vstack.length = vstack.length - n;
199 |         lstack.length = lstack.length - n;
200 |     }
201 |     //_token_stack:
202 |         function lex() {
203 |             var token;
204 |             token = lexer.lex() || EOF;
205 |             if (typeof token !== 'number') {
206 |                 token = self.symbols_[token] || token;
207 |             }
208 |             return token;
209 |         }
210 |     var symbol, preErrorSymbol, state, action, a, r, yyval = {}, p, len, newState, expected;
211 |     while (true) {
212 |         state = stack[stack.length - 1];
213 |         if (this.defaultActions[state]) {
214 |             action = this.defaultActions[state];
215 |         } else {
216 |             if (symbol === null || typeof symbol == 'undefined') {
217 |                 symbol = lex();
218 |             }
219 |             action = table[state] && table[state][symbol];
220 |         }
221 |                     if (typeof action === 'undefined' || !action.length || !action[0]) {
222 |                 var errStr = '';
223 |                 expected = [];
224 |                 for (p in table[state]) {
225 |                     if (this.terminals_[p] && p > TERROR) {
226 |                         expected.push('\'' + this.terminals_[p] + '\'');
227 |                     }
228 |                 }
229 |                 if (lexer.showPosition) {
230 |                     errStr = 'Parse error on line ' + (yylineno + 1) + ':\n' + lexer.showPosition() + '\nExpecting ' + expected.join(', ') + ', got \'' + (this.terminals_[symbol] || symbol) + '\'';
231 |                 } else {
232 |                     errStr = 'Parse error on line ' + (yylineno + 1) + ': Unexpected ' + (symbol == EOF ? 'end of input' : '\'' + (this.terminals_[symbol] || symbol) + '\'');
233 |                 }
234 |                 this.parseError(errStr, {
235 |                     text: lexer.match,
236 |                     token: this.terminals_[symbol] || symbol,
237 |                     line: lexer.yylineno,
238 |                     loc: yyloc,
239 |                     expected: expected
240 |                 });
241 |             }
242 |         if (action[0] instanceof Array && action.length > 1) {
243 |             throw new Error('Parse Error: multiple actions possible at state: ' + state + ', token: ' + symbol);
244 |         }
245 |         switch (action[0]) {
246 |         case 1:
247 |             stack.push(symbol);
248 |             vstack.push(lexer.yytext);
249 |             lstack.push(lexer.yylloc);
250 |             stack.push(action[1]);
251 |             symbol = null;
252 |             if (!preErrorSymbol) {
253 |                 yyleng = lexer.yyleng;
254 |                 yytext = lexer.yytext;
255 |                 yylineno = lexer.yylineno;
256 |                 yyloc = lexer.yylloc;
257 |                 if (recovering > 0) {
258 |                     recovering--;
259 |                 }
260 |             } else {
261 |                 symbol = preErrorSymbol;
262 |                 preErrorSymbol = null;
263 |             }
264 |             break;
265 |         case 2:
266 |             len = this.productions_[action[1]][1];
267 |             yyval.$ = vstack[vstack.length - len];
268 |             yyval._$ = {
269 |                 first_line: lstack[lstack.length - (len || 1)].first_line,
270 |                 last_line: lstack[lstack.length - 1].last_line,
271 |                 first_column: lstack[lstack.length - (len || 1)].first_column,
272 |                 last_column: lstack[lstack.length - 1].last_column
273 |             };
274 |             if (ranges) {
275 |                 yyval._$.range = [
276 |                     lstack[lstack.length - (len || 1)].range[0],
277 |                     lstack[lstack.length - 1].range[1]
278 |                 ];
279 |             }
280 |             r = this.performAction.apply(yyval, [
281 |                 yytext,
282 |                 yyleng,
283 |                 yylineno,
284 |                 sharedState.yy,
285 |                 action[1],
286 |                 vstack,
287 |                 lstack
288 |             ].concat(args));
289 |             if (typeof r !== 'undefined') {
290 |                 return r;
291 |             }
292 |             if (len) {
293 |                 stack = stack.slice(0, -1 * len * 2);
294 |                 vstack = vstack.slice(0, -1 * len);
295 |                 lstack = lstack.slice(0, -1 * len);
296 |             }
297 |             stack.push(this.productions_[action[1]][0]);
298 |             vstack.push(yyval.$);
299 |             lstack.push(yyval._$);
300 |             newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
301 |             stack.push(newState);
302 |             break;
303 |         case 3:
304 |             return true;
305 |         }
306 |     }
307 |     return true;
308 | }};
309 | /* generated by jison-lex 0.3.4 */
310 | var lexer = (function(){
311 | var lexer = ({
312 | 
313 | EOF:1,
314 | 
315 | parseError:function parseError(str, hash) {
316 |         if (this.yy.parser) {
317 |             this.yy.parser.parseError(str, hash);
318 |         } else {
319 |             throw new Error(str);
320 |         }
321 |     },
322 | 
323 | // resets the lexer, sets new input
324 | setInput:function (input, yy) {
325 |         this.yy = yy || this.yy || {};
326 |         this._input = input;
327 |         this._more = this._backtrack = this.done = false;
328 |         this.yylineno = this.yyleng = 0;
329 |         this.yytext = this.matched = this.match = '';
330 |         this.conditionStack = ['INITIAL'];
331 |         this.yylloc = {
332 |             first_line: 1,
333 |             first_column: 0,
334 |             last_line: 1,
335 |             last_column: 0
336 |         };
337 |         if (this.options.ranges) {
338 |             this.yylloc.range = [0,0];
339 |         }
340 |         this.offset = 0;
341 |         return this;
342 |     },
343 | 
344 | // consumes and returns one char from the input
345 | input:function () {
346 |         var ch = this._input[0];
347 |         this.yytext += ch;
348 |         this.yyleng++;
349 |         this.offset++;
350 |         this.match += ch;
351 |         this.matched += ch;
352 |         var lines = ch.match(/(?:\r\n?|\n).*/g);
353 |         if (lines) {
354 |             this.yylineno++;
355 |             this.yylloc.last_line++;
356 |         } else {
357 |             this.yylloc.last_column++;
358 |         }
359 |         if (this.options.ranges) {
360 |             this.yylloc.range[1]++;
361 |         }
362 | 
363 |         this._input = this._input.slice(1);
364 |         return ch;
365 |     },
366 | 
367 | // unshifts one char (or a string) into the input
368 | unput:function (ch) {
369 |         var len = ch.length;
370 |         var lines = ch.split(/(?:\r\n?|\n)/g);
371 | 
372 |         this._input = ch + this._input;
373 |         this.yytext = this.yytext.substr(0, this.yytext.length - len);
374 |         //this.yyleng -= len;
375 |         this.offset -= len;
376 |         var oldLines = this.match.split(/(?:\r\n?|\n)/g);
377 |         this.match = this.match.substr(0, this.match.length - 1);
378 |         this.matched = this.matched.substr(0, this.matched.length - 1);
379 | 
380 |         if (lines.length - 1) {
381 |             this.yylineno -= lines.length - 1;
382 |         }
383 |         var r = this.yylloc.range;
384 | 
385 |         this.yylloc = {
386 |             first_line: this.yylloc.first_line,
387 |             last_line: this.yylineno + 1,
388 |             first_column: this.yylloc.first_column,
389 |             last_column: lines ?
390 |                 (lines.length === oldLines.length ? this.yylloc.first_column : 0)
391 |                  + oldLines[oldLines.length - lines.length].length - lines[0].length :
392 |               this.yylloc.first_column - len
393 |         };
394 | 
395 |         if (this.options.ranges) {
396 |             this.yylloc.range = [r[0], r[0] + this.yyleng - len];
397 |         }
398 |         this.yyleng = this.yytext.length;
399 |         return this;
400 |     },
401 | 
402 | // When called from action, caches matched text and appends it on next action
403 | more:function () {
404 |         this._more = true;
405 |         return this;
406 |     },
407 | 
408 | // When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead.
409 | reject:function () {
410 |         if (this.options.backtrack_lexer) {
411 |             this._backtrack = true;
412 |         } else {
413 |             return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n' + this.showPosition(), {
414 |                 text: "",
415 |                 token: null,
416 |                 line: this.yylineno
417 |             });
418 | 
419 |         }
420 |         return this;
421 |     },
422 | 
423 | // retain first n characters of the match
424 | less:function (n) {
425 |         this.unput(this.match.slice(n));
426 |     },
427 | 
428 | // displays already matched input, i.e. for error messages
429 | pastInput:function () {
430 |         var past = this.matched.substr(0, this.matched.length - this.match.length);
431 |         return (past.length > 20 ? '...':'') + past.substr(-20).replace(/\n/g, "");
432 |     },
433 | 
434 | // displays upcoming input, i.e. for error messages
435 | upcomingInput:function () {
436 |         var next = this.match;
437 |         if (next.length < 20) {
438 |             next += this._input.substr(0, 20-next.length);
439 |         }
440 |         return (next.substr(0,20) + (next.length > 20 ? '...' : '')).replace(/\n/g, "");
441 |     },
442 | 
443 | // displays the character position where the lexing error occurred, i.e. for error messages
444 | showPosition:function () {
445 |         var pre = this.pastInput();
446 |         var c = new Array(pre.length + 1).join("-");
447 |         return pre + this.upcomingInput() + "\n" + c + "^";
448 |     },
449 | 
450 | // test the lexed token: return FALSE when not a match, otherwise return token
451 | test_match:function(match, indexed_rule) {
452 |         var token,
453 |             lines,
454 |             backup;
455 | 
456 |         if (this.options.backtrack_lexer) {
457 |             // save context
458 |             backup = {
459 |                 yylineno: this.yylineno,
460 |                 yylloc: {
461 |                     first_line: this.yylloc.first_line,
462 |                     last_line: this.last_line,
463 |                     first_column: this.yylloc.first_column,
464 |                     last_column: this.yylloc.last_column
465 |                 },
466 |                 yytext: this.yytext,
467 |                 match: this.match,
468 |                 matches: this.matches,
469 |                 matched: this.matched,
470 |                 yyleng: this.yyleng,
471 |                 offset: this.offset,
472 |                 _more: this._more,
473 |                 _input: this._input,
474 |                 yy: this.yy,
475 |                 conditionStack: this.conditionStack.slice(0),
476 |                 done: this.done
477 |             };
478 |             if (this.options.ranges) {
479 |                 backup.yylloc.range = this.yylloc.range.slice(0);
480 |             }
481 |         }
482 | 
483 |         lines = match[0].match(/(?:\r\n?|\n).*/g);
484 |         if (lines) {
485 |             this.yylineno += lines.length;
486 |         }
487 |         this.yylloc = {
488 |             first_line: this.yylloc.last_line,
489 |             last_line: this.yylineno + 1,
490 |             first_column: this.yylloc.last_column,
491 |             last_column: lines ?
492 |                          lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length :
493 |                          this.yylloc.last_column + match[0].length
494 |         };
495 |         this.yytext += match[0];
496 |         this.match += match[0];
497 |         this.matches = match;
498 |         this.yyleng = this.yytext.length;
499 |         if (this.options.ranges) {
500 |             this.yylloc.range = [this.offset, this.offset += this.yyleng];
501 |         }
502 |         this._more = false;
503 |         this._backtrack = false;
504 |         this._input = this._input.slice(match[0].length);
505 |         this.matched += match[0];
506 |         token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]);
507 |         if (this.done && this._input) {
508 |             this.done = false;
509 |         }
510 |         if (token) {
511 |             return token;
512 |         } else if (this._backtrack) {
513 |             // recover context
514 |             for (var k in backup) {
515 |                 this[k] = backup[k];
516 |             }
517 |             return false; // rule action called reject() implying the next rule should be tested instead.
518 |         }
519 |         return false;
520 |     },
521 | 
522 | // return next match in input
523 | next:function () {
524 |         if (this.done) {
525 |             return this.EOF;
526 |         }
527 |         if (!this._input) {
528 |             this.done = true;
529 |         }
530 | 
531 |         var token,
532 |             match,
533 |             tempMatch,
534 |             index;
535 |         if (!this._more) {
536 |             this.yytext = '';
537 |             this.match = '';
538 |         }
539 |         var rules = this._currentRules();
540 |         for (var i = 0; i < rules.length; i++) {
541 |             tempMatch = this._input.match(this.rules[rules[i]]);
542 |             if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
543 |                 match = tempMatch;
544 |                 index = i;
545 |                 if (this.options.backtrack_lexer) {
546 |                     token = this.test_match(tempMatch, rules[i]);
547 |                     if (token !== false) {
548 |                         return token;
549 |                     } else if (this._backtrack) {
550 |                         match = false;
551 |                         continue; // rule action called reject() implying a rule MISmatch.
552 |                     } else {
553 |                         // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
554 |                         return false;
555 |                     }
556 |                 } else if (!this.options.flex) {
557 |                     break;
558 |                 }
559 |             }
560 |         }
561 |         if (match) {
562 |             token = this.test_match(match, rules[index]);
563 |             if (token !== false) {
564 |                 return token;
565 |             }
566 |             // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
567 |             return false;
568 |         }
569 |         if (this._input === "") {
570 |             return this.EOF;
571 |         } else {
572 |             return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. Unrecognized text.\n' + this.showPosition(), {
573 |                 text: "",
574 |                 token: null,
575 |                 line: this.yylineno
576 |             });
577 |         }
578 |     },
579 | 
580 | // return next match that has a token
581 | lex:function lex () {
582 |         var r = this.next();
583 |         if (r) {
584 |             return r;
585 |         } else {
586 |             return this.lex();
587 |         }
588 |     },
589 | 
590 | // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
591 | begin:function begin (condition) {
592 |         this.conditionStack.push(condition);
593 |     },
594 | 
595 | // pop the previously active lexer condition state off the condition stack
596 | popState:function popState () {
597 |         var n = this.conditionStack.length - 1;
598 |         if (n > 0) {
599 |             return this.conditionStack.pop();
600 |         } else {
601 |             return this.conditionStack[0];
602 |         }
603 |     },
604 | 
605 | // produce the lexer rule set which is active for the currently active lexer condition state
606 | _currentRules:function _currentRules () {
607 |         if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {
608 |             return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
609 |         } else {
610 |             return this.conditions["INITIAL"].rules;
611 |         }
612 |     },
613 | 
614 | // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
615 | topState:function topState (n) {
616 |         n = this.conditionStack.length - 1 - Math.abs(n || 0);
617 |         if (n >= 0) {
618 |             return this.conditionStack[n];
619 |         } else {
620 |             return "INITIAL";
621 |         }
622 |     },
623 | 
624 | // alias for begin(condition)
625 | pushState:function pushState (condition) {
626 |         this.begin(condition);
627 |     },
628 | 
629 | // return the number of states currently on the stack
630 | stateStackSize:function stateStackSize() {
631 |         return this.conditionStack.length;
632 |     },
633 | options: {},
634 | performAction: function anonymous(yy,yy_,$avoiding_name_collisions,YY_START) {
635 | var YYSTATE=YY_START;
636 | switch($avoiding_name_collisions) {
637 | case 0:return 11;
638 | break;
639 | case 1:return '(';
640 | break;
641 | case 2:return ')';
642 | break;
643 | case 3:return 8;
644 | break;
645 | case 4:return 15;
646 | break;
647 | case 5:return 13;
648 | break;
649 | case 6:return 18;
650 | break;
651 | case 7:return 19;
652 | break;
653 | case 8:return 20;
654 | break;
655 | case 9:return 17;
656 | break;
657 | case 10:return 17;
658 | break;
659 | case 11:return 17;
660 | break;
661 | case 12:/* skip whitespace */
662 | break;
663 | case 13:return 6;
664 | break;
665 | }
666 | },
667 | rules: [/^(?:\/)/,/^(?:\()/,/^(?:\))/,/^(?:(\*|x|\u00d7|\u2219|\u22c5|\u00b7)\s*10\s*\^)/,/^(?:\^)/,/^(?:\*)/,/^(?:[0-9]+\.[0-9]+)/,/^(?:[0-9]+)/,/^(?:-)/,/^(?:\u00b0( ?)[cCfF])/,/^(?:fl\.? oz\.?)/,/^(?:[\u00b5]?([A-Za-z-]+|[\u2103\u2109\u212b]))/,/^(?:\s+)/,/^(?:$)/],
668 | conditions: {"INITIAL":{"rules":[0,1,2,3,4,5,6,7,8,9,10,11,12,13],"inclusive":true}}
669 | });
670 | return lexer;
671 | })();
672 | parser.lexer = lexer;
673 | function Parser () {
674 |   this.yy = {};
675 | }
676 | Parser.prototype = parser;parser.Parser = Parser;
677 | return new Parser;
678 | })();
679 | 
680 | KAS.unitParser = parser;
681 | })(KAS);


--------------------------------------------------------------------------------
/src/unitvalue.jison:
--------------------------------------------------------------------------------
  1 | /* Parse unit-tagged values. Examples:
  2 |  * - 5.3x10^5 kg m / s^2
  3 |  * - 5 mmHg
  4 |  * - (3 * 10) (kg m) / s^2
  5 |  */
  6 | 
  7 | %lex
  8 | 
  9 | /*
 10 | 00b5 - micro
 11 | 212b - angstrom
 12 | 00b0 - degree
 13 | 2103 - degree celcius
 14 | 2109 - degree fahrenheit
 15 | */
 16 | 
 17 | %%
 18 | "/"                                               return 'DIV';
 19 | "("                                               return '(';
 20 | ")"                                               return ')';
 21 | 
 22 | /*
 23 | The "x 10^" part of scientific notation. Accept this as one token to
 24 | disambiguate "x", "10", and "^", rather than parse them as confusing tokens
 25 | which could mean different things depending on context.
 26 | 
 27 | To be safe we accept the following:
 28 |   - *
 29 |   - x
 30 |   - interpunct (00b7)
 31 |   - bullet (2219)
 32 |   - dot (22c5)
 33 |   - multiplication sign (00d7)
 34 |  */
 35 | ("*"|"x"|"\u00d7"|"\u2219"|"\u22c5"|"\u00b7")\s*"10"\s*"^" return 'POW';
 36 | 
 37 | /*
 38 | At this point we can safely tokenize these things since they can no longer
 39 | appear as part of "x 10^".
 40 |  */
 41 | "^"                                               return '^';
 42 | "*"                                               return 'MUL';
 43 | [0-9]+"."[0-9]+                                   return 'FLOAT';
 44 | [0-9]+                                            return 'NAT';
 45 | "-"                                               return 'NEG';
 46 | 
 47 | /*
 48 | Atom, meaning a single unit without exponent.
 49 | 
 50 | Symbols:
 51 |   - 00b0 - degree sign
 52 |   - 2103 - degree celcius
 53 |   - 2109 - degree fahrenheit
 54 |   - 212b - angstrom
 55 |   - 00b5 - micro
 56 |  */
 57 | "\u00b0"(" "?)[cCfF]                              return 'ATOM';
 58 | "fl""."?" oz""."?                                 return 'ATOM';
 59 | [\u00b5]?([A-Za-z-]+|[\u2103\u2109\u212b])        return 'ATOM';
 60 | 
 61 | \s+                                               /* skip whitespace */
 62 | <<EOF>>                                           return 'EOF';
 63 | 
 64 | /lex
 65 | 
 66 | %start unitvalue
 67 | 
 68 | %%
 69 | 
 70 | unitvalue
 71 |     : magnitude unit EOF
 72 |         %{
 73 |             return {
 74 |                 type: "unitMagnitude",
 75 |                 magnitude: $1,
 76 |                 unit: $2,
 77 |             };
 78 |         }%
 79 |     | unit EOF
 80 |         %{
 81 |             return {
 82 |                 type: "unitStandalone",
 83 |                 unit: $1,
 84 |             }
 85 |         }%
 86 |     ;
 87 | 
 88 | magnitude
 89 |     : float POW int
 90 |         %{
 91 |             $$ = $1 + "e" + $3;
 92 |         }%
 93 |     | float
 94 |         { $$ = $1; }
 95 |     ;
 96 | 
 97 | unit
 98 |     : multatoms DIV multatoms
 99 |         %{
100 |             $$ = {
101 |                 num: $1,
102 |                 denom: $3,
103 |             };
104 |         }%
105 |     | multatoms
106 |         %{
107 |             $$ = {
108 |                 num: $1,
109 |                 denom: null,
110 |             };
111 |         }%
112 |     ;
113 | 
114 | multatoms
115 |     : expatom MUL multatoms
116 |         { $$ = [$1].concat($3); }
117 |     | expatom multatoms
118 |         { $$ = [$1].concat($2); }
119 |     | expatom
120 |         { $$ = [$1]; }
121 |     ;
122 | 
123 | expatom
124 |     : atom '^' nat
125 |         %{
126 |             $$ = {
127 |                 name: $1,
128 |                 pow: $3,
129 |             };
130 |         }%
131 |     | atom
132 |         %{
133 |             $$ = {
134 |                 name: $1,
135 |                 pow: 1,
136 |             };
137 |         }%
138 |     ;
139 | 
140 | atom
141 |     : ATOM
142 |     { $$ = yytext; }
143 |     ;
144 | 
145 | float
146 |     : FLOAT
147 |         { $$ = $1; }
148 |     | nat
149 |         { $$ = $1; }
150 |     ;
151 | 
152 | nat : NAT
153 |         { $$ = $1; }
154 |     ;
155 | 
156 | int
157 |     : NEG NAT
158 |         { $$ = "-" + $2; }
159 |     | NAT
160 |         { $$ = $1; }
161 |     ;
162 | 


--------------------------------------------------------------------------------
/test.html:
--------------------------------------------------------------------------------
   1 | <!DOCTYPE html>
   2 | <html>
   3 | <head>
   4 |     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
   5 |     <title>KAS Browser Tests</title>
   6 | 
   7 |     <!-- Include QUnit -->
   8 |     <link rel="stylesheet" href="node_modules/qunit/qunit/qunit.css" type="text/css" media="screen">
   9 |     <script src="node_modules/qunit/qunit/qunit.js"></script>
  10 |     <script src="node_modules/qunit-assert-close/qunit-assert-close.js"></script>
  11 | 
  12 |     <!-- Include Underscore -->
  13 |     <script src="node_modules/underscore/underscore.js"></script>
  14 | 
  15 |     <!-- Include KAS -->
  16 |     <script src="src/parser.js"></script>
  17 |     <script src="src/unitparser.js"></script>
  18 |     <script src="src/nodes.js"></script>
  19 |     <script src="src/compare.js"></script>
  20 | </head>
  21 | <body>
  22 | 
  23 | <h1 id="qunit-header">KAS Browser Tests</h1>
  24 | <h2 id="qunit-banner"></h2>
  25 | <div id="qunit-testrunner-toolbar"></div>
  26 | <h2 id="qunit-userAgent"></h2>
  27 | <ol id="qunit-tests"></ol>
  28 | 
  29 | <div id="qunit-fixture">
  30 |     <div id="solutionarea">
  31 |     </div>
  32 |     <div class="problem">
  33 |     </div>
  34 | </div>
  35 | 
  36 | <script type="text/javascript">
  37 | (function(KAS) {
  38 | 
  39 |     var parse = function(input, options) {
  40 |         return KAS.parse(input, options).expr;
  41 |     };
  42 | 
  43 | 
  44 |     QUnit.module("parsing");
  45 | 
  46 |     var print = function(assert, input, expected, options) {
  47 |         var message = input + " parses as " + expected;
  48 |         assert.close(parse(input, options).print(), expected, 1e-9, message);
  49 |     };
  50 | 
  51 |     QUnit.test("empty", function(assert) {
  52 |         print(assert, "", "");
  53 |     });
  54 | 
  55 |     QUnit.test("positive and negative primitives", function(assert) {
  56 |         print(assert, "0", "0");
  57 |         print(assert, "1.", "1");
  58 |         print(assert, "3.14", "3.14");
  59 |         print(assert, ".14", "0.14");
  60 |         print(assert, "pi", "pi");
  61 |         print(assert, "e", "e");
  62 |         print(assert, "x", "x");
  63 |         print(assert, "theta", "theta");
  64 | 
  65 |         print(assert, "-0", "-1*0");
  66 |         print(assert, "-1.", "-1");
  67 |         print(assert, "-3.14", "-3.14");
  68 |         print(assert, "-.14", "-0.14");
  69 |         print(assert, "-pi", "-1*pi");
  70 |         print(assert, "-e", "-1*e");
  71 |         print(assert, "-theta", "-1*theta");
  72 |     });
  73 | 
  74 |     QUnit.test("LaTeX constants", function(assert) {
  75 |         print(assert, "\\theta", "theta");
  76 |         print(assert, "\\pi", "pi");
  77 |         print(assert, "\\phi", "phi");
  78 |     });
  79 | 
  80 |     QUnit.test("ignore TeX spaces", function(assert) {
  81 |         print(assert, "a\\space b", "a*b");
  82 |         print(assert, "a\\ b", "a*b");
  83 |     });
  84 | 
  85 |     QUnit.test("positive and negative rationals", function(assert) {
  86 |         print(assert, "1/2", "1/2");
  87 |         print(assert, "-1/2", "-1/2");
  88 |         print(assert, "1/-2", "-1/2");
  89 |         print(assert, "-1/-2", "-1*-1/2");
  90 |         print(assert, "42/42", "42/42");
  91 |         print(assert, "42/1", "42/1");
  92 |         print(assert, "0/42", "0/42");
  93 | 
  94 |         print(assert, "2 (1/2)", "2*1/2");
  95 |         print(assert, "1/2 1/2", "1/2*1/2");
  96 |         print(assert, "-1/2", "-1/2");
  97 |         print(assert, "1/2 2", "1/2*2");
  98 |     });
  99 | 
 100 |     QUnit.test("rationals using \\frac", function(assert) {
 101 |         print(assert, "\\frac{1}{2}", "1/2");
 102 |         print(assert, "\\frac{-1}{2}", "-1/2");
 103 |         print(assert, "\\frac{1}{-2}", "-1/2");
 104 |         print(assert, "\\frac{-1}{-2}", "-1*-1/2");
 105 |         print(assert, "\\frac{42}{42}", "42/42");
 106 |         print(assert, "\\frac{42}{1}", "42/1");
 107 |         print(assert, "\\frac{0}{42}", "0/42");
 108 | 
 109 |         print(assert, "2\\frac{1}{2}", "2*1/2");
 110 |         print(assert, "\\frac{1}{2}\\frac{1}{2}", "1/2*1/2");
 111 |         print(assert, "-\\frac{1}{2}", "-1/2");
 112 |         print(assert, "\\frac{1}{2}2", "1/2*2");
 113 |     });
 114 | 
 115 |     QUnit.test("rationals using \\dfrac", function(assert) {
 116 |         print(assert, "\\dfrac{1}{2}", "1/2");
 117 |         print(assert, "\\dfrac{-1}{2}", "-1/2");
 118 |         print(assert, "\\dfrac{1}{-2}", "-1/2");
 119 |         print(assert, "\\dfrac{-1}{-2}", "-1*-1/2");
 120 |         print(assert, "\\dfrac{42}{42}", "42/42");
 121 |         print(assert, "\\dfrac{42}{1}", "42/1");
 122 |         print(assert, "\\dfrac{0}{42}", "0/42");
 123 | 
 124 |         print(assert, "2\\dfrac{1}{2}", "2*1/2");
 125 |         print(assert, "\\dfrac{1}{2}\\dfrac{1}{2}", "1/2*1/2");
 126 |         print(assert, "-\\dfrac{1}{2}", "-1/2");
 127 |         print(assert, "\\dfrac{1}{2}2", "1/2*2");
 128 |     });
 129 | 
 130 |     QUnit.test("parens", function(assert) {
 131 |         print(assert, "(0)", "0");
 132 |         print(assert, "(ab)", "a*b");
 133 |         print(assert, "(a/b)", "a*b^(-1)");
 134 |         print(assert, "(a^b)", "a^(b)");
 135 |         print(assert, "(ab)c", "a*b*c");
 136 |         print(assert, "a(bc)", "a*b*c");
 137 |         print(assert, "a+(b+c)", "a+b+c");
 138 |         print(assert, "(a+b)+c", "a+b+c");
 139 |         print(assert, "a(b+c)", "a*(b+c)");
 140 |         print(assert, "(a+b)^c", "(a+b)^(c)");
 141 |         print(assert, "(ab)^c", "(a*b)^(c)");
 142 |     });
 143 | 
 144 |     QUnit.test("subscripts", function(assert) {
 145 |         print(assert, "a", "a");
 146 |         print(assert, "a_0", "a_(0)");
 147 |         print(assert, "a_i", "a_(i)");
 148 |         print(assert, "a_n", "a_(n)");
 149 |         print(assert, "a_n+1", "a_(n)+1");
 150 |         print(assert, "a_(n+1)", "a_(n+1)");
 151 |         print(assert, "a_{n+1}", "a_(n+1)");
 152 |     });
 153 | 
 154 |     QUnit.test("negation", function(assert) {
 155 |         print(assert, "-x", "-1*x");
 156 |         print(assert, "--x", "-1*-1*x");
 157 |         print(assert, "---x", "-1*-1*-1*x");
 158 |         print(assert, "-1", "-1");
 159 |         print(assert, "--1", "-1*-1");
 160 |         print(assert, "---1", "-1*-1*-1");
 161 |         print(assert, "-3x", "-3*x");
 162 |         print(assert, "--3x", "-1*-3*x");
 163 |         print(assert, "-x*3", "x*-3");
 164 |         print(assert, "--x*3", "-1*x*-3");
 165 |         print(assert, "\u2212x", "-1*x");
 166 |     });
 167 | 
 168 |     QUnit.test("addition and subtraction", function(assert) {
 169 |         print(assert, "a+b", "a+b");
 170 |         print(assert, "a-b", "a+-1*b");
 171 |         print(assert, "a--b", "a+-1*-1*b");
 172 |         print(assert, "a---b", "a+-1*-1*-1*b");
 173 |         print(assert, "2-4", "2+-4");
 174 |         print(assert, "2--4", "2+-1*-4");
 175 |         print(assert, "2---4", "2+-1*-1*-4");
 176 |         print(assert, "2-x*4", "2+x*-4");
 177 |         print(assert, "1-2+a-b+pi-e", "1+-2+a+-1*b+pi+-1*e");
 178 |         print(assert, "x+1", "x+1");
 179 |         print(assert, "x-1", "x+-1");
 180 |         print(assert, "(x-1)", "x+-1");
 181 |         print(assert, "a(x-1)", "a*(x+-1)");
 182 |         print(assert, "a\u2212b", "a+-1*b");
 183 |     });
 184 | 
 185 |     QUnit.test("multiplication", function(assert) {
 186 |         print(assert, "a*b", "a*b");
 187 |         print(assert, "-a*b", "-1*a*b");
 188 |         print(assert, "a*-b", "a*-1*b");
 189 |         print(assert, "-ab", "-1*a*b");
 190 |         print(assert, "-a*b", "-1*a*b");
 191 |         print(assert, "-(ab)", "-1*a*b");
 192 |         print(assert, "a\u00b7b", "a*b");
 193 |         print(assert, "a\u00d7b", "a*b");
 194 |         print(assert, "a\\cdotb", "a*b");
 195 |         print(assert, "a\\timesb", "a*b");
 196 |         print(assert, "a\\astb", "a*b");
 197 |     })
 198 | 
 199 |     QUnit.test("division", function(assert) {
 200 |         print(assert, "a/b", "a*b^(-1)");
 201 |         print(assert, "a/bc", "a*b^(-1)*c");
 202 |         print(assert, "(ab)/c", "a*b*c^(-1)");
 203 |         print(assert, "ab/c", "a*b*c^(-1)");
 204 |         print(assert, "ab/cd", "a*b*c^(-1)*d");
 205 |         print(assert, "a\\divb", "a*b^(-1)");
 206 |         print(assert, "a\u00F7b", "a*b^(-1)");
 207 |     });
 208 | 
 209 |     QUnit.test("exponentiation", function(assert) {
 210 |         print(assert, "x^y", "x^(y)");
 211 |         print(assert, "x^y^z", "x^(y^(z))");
 212 |         print(assert, "x^yz", "x^(y)*z");
 213 |         print(assert, "-x^2", "-1*x^(2)");
 214 |         print(assert, "-(x^2)", "-1*x^(2)");
 215 |         print(assert, "0-x^2", "0+-1*x^(2)");
 216 |         print(assert, "x^-y", "x^(-1*y)");
 217 |         print(assert, "x^(-y)", "x^(-1*y)");
 218 |         print(assert, "x^-(y)", "x^(-1*y)");
 219 |         print(assert, "x^-(-y)", "x^(-1*-1*y)");
 220 |         print(assert, "x^--y", "x^(-1*-1*y)");
 221 |         print(assert, "x^-yz", "x^(-1*y)*z");
 222 |         print(assert, "x^-y^z", "x^(-1*y^(z))");
 223 |         print(assert, "x**y", "x^(y)");
 224 | 
 225 |         print(assert, "x^{a}", "x^(a)");
 226 |         print(assert, "x^{ab}", "x^(a*b)");
 227 |     });
 228 | 
 229 |     QUnit.test("square root", function(assert) {
 230 |         print(assert, "sqrt(x)", "x^(1/2)");
 231 |         print(assert, "sqrt(x)y", "x^(1/2)*y");
 232 |         print(assert, "1/sqrt(x)", "x^(-1/2)");
 233 |         print(assert, "1/sqrt(x)y", "x^(-1/2)*y");
 234 | 
 235 |         print(assert, "sqrt(2)/2", "2^(1/2)*1/2");
 236 |         print(assert, "sqrt(2)^2", "(2^(1/2))^(2)");
 237 | 
 238 |         print(assert, "\\sqrt(x)", "x^(1/2)");
 239 |         print(assert, "\\sqrt(x)y", "x^(1/2)*y");
 240 |         print(assert, "1/\\sqrt(x)", "x^(-1/2)");
 241 |         print(assert, "1/\\sqrt(x)y", "x^(-1/2)*y");
 242 | 
 243 |         print(assert, "\\sqrt(2)/2", "2^(1/2)*1/2");
 244 |         print(assert, "\\sqrt(2)^2", "(2^(1/2))^(2)");
 245 | 
 246 |         print(assert, "\\sqrt{2}", "2^(1/2)");
 247 |         print(assert, "\\sqrt{2+2}", "(2+2)^(1/2)");
 248 |     });
 249 | 
 250 |     QUnit.test("nth root", function(assert) {
 251 |         print(assert, "sqrt[3]{x}", "x^(1/3)");
 252 |         print(assert, "sqrt[4]{x}y", "x^(1/4)*y");
 253 |         print(assert, "1/sqrt[5]{x}", "x^(-1/5)");
 254 |         print(assert, "1/sqrt[7]{x}y", "x^(-1/7)*y");
 255 | 
 256 |         print(assert, "sqrt[3]{2}/2", "2^(1/3)*1/2");
 257 |         print(assert, "sqrt[3]{2}^2", "(2^(1/3))^(2)");
 258 | 
 259 |         print(assert, "\\sqrt[4]{x}", "x^(1/4)");
 260 |         print(assert, "\\sqrt[4]{x}y", "x^(1/4)*y");
 261 |         print(assert, "1/\\sqrt[4]{x}", "x^(-1/4)");
 262 |         print(assert, "1/\\sqrt[4]{x}y", "x^(-1/4)*y");
 263 | 
 264 |         print(assert, "\\sqrt[5]{2}/2", "2^(1/5)*1/2");
 265 |         print(assert, "\\sqrt[5]{2}^2", "(2^(1/5))^(2)");
 266 | 
 267 |         print(assert, "\\sqrt[6]{2}", "2^(1/6)");
 268 |         print(assert, "\\sqrt[6]{2+2}", "(2+2)^(1/6)");
 269 | 
 270 |         print(assert, "\\sqrt[2]{2}", "2^(1/2)");
 271 |         print(assert, "\\sqrt[2]{2+2}", "(2+2)^(1/2)");
 272 |     });
 273 | 
 274 |     QUnit.test("absolute value", function(assert) {
 275 |         print(assert, "abs(x)", "abs(x)");
 276 |         print(assert, "abs(abs(x))", "abs(abs(x))");
 277 |         print(assert, "abs(x)abs(y)", "abs(x)*abs(y)");
 278 | 
 279 |         print(assert, "|x|", "abs(x)");
 280 |         print(assert, "||x||", "abs(abs(x))");
 281 |         // TODO(alex): fix the below so it doesn't require an *
 282 |         // may require own lexer/preprocessor
 283 |         print(assert, "|x|*|y|", "abs(x)*abs(y)");
 284 | 
 285 |         print(assert, "\\abs(x)", "abs(x)");
 286 |         print(assert, "\\abs(\\abs(x))", "abs(abs(x))");
 287 |         print(assert, "\\abs(x)\\abs(y)", "abs(x)*abs(y)");
 288 | 
 289 |         print(assert, "\\left|x\\right|", "abs(x)");
 290 |         print(assert, "\\left|\\left|x\\right|\\right|", "abs(abs(x))");
 291 |         print(assert, "\\left|x\\right|\\left|y\\right|", "abs(x)*abs(y)");
 292 |     });
 293 | 
 294 |     QUnit.test("logarithms", function(assert) {
 295 |         print(assert, "lnx", "ln(x)");
 296 |         print(assert, "ln x", "ln(x)");
 297 |         print(assert, "ln x^y", "ln(x^(y))");
 298 |         print(assert, "ln xy", "ln(x*y)");
 299 |         print(assert, "ln x/y", "ln(x*y^(-1))");
 300 |         print(assert, "ln x+y", "ln(x)+y");
 301 |         print(assert, "ln x-y", "ln(x)+-1*y");
 302 | 
 303 |         print(assert, "ln xyz", "ln(x*y*z)");
 304 |         print(assert, "ln xy/z", "ln(x*y*z^(-1))");
 305 |         print(assert, "ln xy/z+1", "ln(x*y*z^(-1))+1");
 306 | 
 307 |         print(assert, "ln x(y)", "ln(x)*y");
 308 | 
 309 |         print(assert, "logx", "log_(10) (x)");
 310 |         print(assert, "log x", "log_(10) (x)");
 311 |         print(assert, "log_2x", "log_(2) (x)");
 312 |         print(assert, "log _ 2 x", "log_(2) (x)");
 313 |         print(assert, "log_bx_0", "log_(b) (x_(0))");
 314 |         print(assert, "log_x_0b", "log_(x_(0)) (b)");
 315 | 
 316 |         print(assert, "log_2.5x", "log_(2.5) (x)");
 317 | 
 318 |         print(assert, "ln ln x", "ln(ln(x))");
 319 |         print(assert, "ln x ln y", "ln(x)*ln(y)");
 320 |         print(assert, "ln x/ln y", "ln(x)*ln(y)^(-1)");
 321 | 
 322 |         print(assert, "\\lnx", "ln(x)");
 323 |         print(assert, "\\ln x", "ln(x)");
 324 |         print(assert, "\\ln x^y", "ln(x^(y))");
 325 |         print(assert, "\\ln xy", "ln(x*y)");
 326 |         print(assert, "\\ln x/y", "ln(x*y^(-1))");
 327 |         print(assert, "\\ln x+y", "ln(x)+y");
 328 |         print(assert, "\\ln x-y", "ln(x)+-1*y");
 329 | 
 330 |         print(assert, "\\logx", "log_(10) (x)");
 331 |         print(assert, "\\log x", "log_(10) (x)");
 332 |         print(assert, "\\log_2x", "log_(2) (x)");
 333 |         print(assert, "\\log _ 2 x", "log_(2) (x)");
 334 |         print(assert, "\\log_bx_0", "log_(b) (x_(0))");
 335 |         print(assert, "\\log_x_0b", "log_(x_(0)) (b)");
 336 | 
 337 |         print(assert, "\\log_2.5x", "log_(2.5) (x)");
 338 | 
 339 |         print(assert, "\\frac{\\logx}{y}", "log_(10) (x)*y^(-1)");
 340 |         print(assert, "\\frac{\\log x}{y}", "log_(10) (x)*y^(-1)");
 341 |     });
 342 | 
 343 |     QUnit.test("trig functions", function(assert) {
 344 |         var functions = [
 345 |             "sin", "cos", "tan",
 346 |             "csc", "sec", "cot"
 347 |         ];
 348 | 
 349 |         var inverses = _.map(functions, function(func) {
 350 |             return "arc" + func;
 351 |         });
 352 | 
 353 |         _.each(functions.concat(inverses), function(func) {
 354 |             print(assert, func + "x", func + "(x)");
 355 |             print(assert, "\\" + func + "x", func + "(x)");
 356 |         });
 357 | 
 358 |         print(assert, "sin^-1 x", "arcsin(x)");
 359 |         print(assert, "\\sin^-1 x", "arcsin(x)");
 360 | 
 361 |         print(assert, "(sinx)^2", "sin(x)^(2)");
 362 |         print(assert, "sin^2x", "sin(x)^(2)");
 363 |         print(assert, "sin^2(x)", "sin(x)^(2)");
 364 |         print(assert, "sin^2 x", "sin(x)^(2)");
 365 |         print(assert, "(sin^2x)", "sin(x)^(2)");
 366 | 
 367 |         print(assert, "sin xy", "sin(x*y)");
 368 |         print(assert, "sin x(y)", "sin(x)*y");
 369 |         print(assert, "sin x/y", "sin(x*y^(-1))");
 370 |         print(assert, "(sin x)/y", "sin(x)*y^(-1)");
 371 | 
 372 |         print(assert, "sin sin x", "sin(sin(x))");
 373 |         print(assert, "sin x sin y", "sin(x)*sin(y)");
 374 |         print(assert, "sin x/sin y", "sin(x)*sin(y)^(-1)");
 375 | 
 376 |         print(assert, "1/(sinx)^2", "sin(x)^(-2)");
 377 |         print(assert, "1/sin^2x", "sin(x)^(-2)");
 378 |         print(assert, "1/sin^2(x)", "sin(x)^(-2)");
 379 |         print(assert, "1/(sin^2x)", "sin(x)^(-2)");
 380 | 
 381 |         print(assert, "sin(theta)", "sin(theta)");
 382 |         print(assert, "\\sin(\\theta)", "sin(theta)");
 383 |     });
 384 | 
 385 |     QUnit.test("hyperbolic functions", function(assert) {
 386 |         print(assert, "sinh xy", "sinh(x*y)");
 387 |         print(assert, "1/(sinhx)^2", "sinh(x)^(-2)");
 388 |         print(assert, "\\sinh(\\theta)", "sinh(theta)");
 389 |     });
 390 | 
 391 |     QUnit.test("formulas", function(assert) {
 392 |         print(assert, "mx+b", "m*x+b");
 393 |         print(assert, "v^2/r", "v^(2)*r^(-1)");
 394 |         print(assert, "4/3pir^3", "4/3*pi*r^(3)");
 395 |         print(assert, "4/3\u03C0r^3", "4/3*pi*r^(3)");
 396 |         print(assert, "sin^2 x + cos^2 x = 1", "sin(x)^(2)+cos(x)^(2)=1");
 397 |     });
 398 | 
 399 |     QUnit.test("factors", function(assert) {
 400 |         print(assert, "(6x+1)(x-1)", "(6*x+1)*(x+-1)");
 401 |     });
 402 | 
 403 |     QUnit.test("whitespace", function(assert) {
 404 |         print(assert, "12/3", "12/3");
 405 |         print(assert, "12 /3", "12/3");
 406 |         print(assert, "12/ 3", "12/3");
 407 |         print(assert, "xy", "x*y");
 408 |         print(assert, "x y", "x*y");
 409 |     });
 410 | 
 411 |     QUnit.test("equations", function(assert) {
 412 |         print(assert, "y=x", "y=x");
 413 |         print(assert, "y=x^2", "y=x^(2)");
 414 |         print(assert, "1<2", "1<2");
 415 |         print(assert, "1<=2", "1<=2");
 416 |         print(assert, "1\\le2", "1<=2");
 417 |         print(assert, "2>1", "2>1");
 418 |         print(assert, "2>=1", "2>=1");
 419 |         print(assert, "2\\ge1", "2>=1");
 420 |         print(assert, "1<>2", "1<>2");
 421 |         print(assert, "1=/=2", "1<>2");
 422 |         print(assert, "1\\ne2", "1<>2");
 423 |         print(assert, "1\\neq2", "1<>2");
 424 |         print(assert, "a\u2260b", "a<>b");
 425 |         print(assert, "a\u2264b", "a<=b");
 426 |         print(assert, "a\u2265b", "a>=b");
 427 |     });
 428 | 
 429 |     QUnit.test("function variables", function(assert) {
 430 |         print(assert, "f(x)", "f*x");
 431 |         print(assert, "f(x)", "f(x)", {functions: ["f"]});
 432 |         print(assert, "f(x+y)", "f(x+y)", {functions: ["f"]});
 433 |         print(assert, "f(x)g(x)", "f(x)*g(x)", {functions: ["f", "g"]});
 434 |         print(assert, "f(g(h(x)))", "f(g(h(x)))", {functions: ["f", "g", "h"]});
 435 | 
 436 |         print(assert, "f\\left(x\\right)", "f*x");
 437 |         print(assert, "f\\left(x\\right)", "f(x)", {functions: ["f"]});
 438 |         print(assert, "f\\left(x+y\\right)", "f(x+y)", {functions: ["f"]});
 439 |         print(assert, "f\\left(x\\right)g\\left(x\\right)", "f(x)*g(x)", {functions: ["f", "g"]});
 440 |         print(assert, "f\\left(g\\left(h\\left(x\\right)\\right)\\right)", "f(g(h(x)))", {functions: ["f", "g", "h"]});
 441 |     });
 442 | 
 443 |     var repr = function(assert, input, expected, options) {
 444 |         var message = input + " parses as " + expected;
 445 |         assert.strictEqual(parse(input, options).repr(), expected, message);
 446 |     };
 447 | 
 448 |     QUnit.test("structure", function(assert) {
 449 |         repr(assert, "", "Add()");
 450 |         repr(assert, "1.", "1");
 451 |         repr(assert, "1/2", "1/2");
 452 |         repr(assert, "1/-2", "-1/2");
 453 |         repr(assert, "x/-2", "Mul(Var(x),-1/2)");
 454 |         repr(assert, "a+b", "Add(Var(a),Var(b))");
 455 |         repr(assert, "a+b+c", "Add(Var(a),Var(b),Var(c))");
 456 |         repr(assert, "a-b", "Add(Var(a),Mul(-1,Var(b)))");
 457 |         repr(assert, "a-b+c", "Add(Var(a),Mul(-1,Var(b)),Var(c))");
 458 |         repr(assert, "abc", "Mul(Var(a),Var(b),Var(c))");
 459 |         repr(assert, "a/bc", "Mul(Var(a),Pow(Var(b),-1),Var(c))");
 460 |         repr(assert, "a*(b+c)", "Mul(Var(a),Add(Var(b),Var(c)))");
 461 |         repr(assert, "x--y", "Add(Var(x),Mul(-1,-1,Var(y)))");
 462 |         repr(assert, "--y", "Mul(-1,-1,Var(y))");
 463 |         repr(assert, "e", "Const(e)");
 464 |         repr(assert, "2e", "Mul(2,Const(e))");
 465 |         repr(assert, "2e^x", "Mul(2,Pow(Const(e),Var(x)))");
 466 |         repr(assert, "cdef", "Mul(Var(c),Var(d),Const(e),Var(f))");
 467 |         repr(assert, "pi", "Const(pi)");
 468 |         repr(assert, "pi^2", "Pow(Const(pi),2)")
 469 |         repr(assert, "pir", "Mul(Const(pi),Var(r))");
 470 |         repr(assert, "pir^2", "Mul(Const(pi),Pow(Var(r),2))");
 471 |         repr(assert, "y=x^2", "Eq(Var(y),=,Pow(Var(x),2))");
 472 |         repr(assert, "log_2x", "Log(2,Var(x))");
 473 |         repr(assert, "f(x+y)", "Mul(Var(f),Add(Var(x),Var(y)))");
 474 |         repr(assert, "f(x+y)", "Func(f,Add(Var(x),Var(y)))", {functions: ["f"]});
 475 |         repr(assert, "sin(theta)", "Trig(sin,Var(theta))");
 476 |         repr(assert, "tanh(theta)", "Trig(tanh,Var(theta))");
 477 | 
 478 |         // verify that negative signs get folded into numbers
 479 |         repr(assert, "-x*3", "Mul(Var(x),-3)");
 480 |         repr(assert, "sin -x*3", "Trig(sin,Mul(Var(x),-3))");
 481 |     });
 482 | 
 483 | 
 484 |     QUnit.module("rendering");
 485 | 
 486 |     var tex = function(assert, input, expected, options) {
 487 |         var message = input + " renders as " + expected;
 488 |         assert.strictEqual(parse(input, options).tex(), expected, message);
 489 |     };
 490 | 
 491 |     QUnit.test("positive and negative primitives", function(assert) {
 492 |         tex(assert, "0", "0");
 493 |         tex(assert, "-1", "-1");
 494 |         tex(assert, "--1", "--1");
 495 |         tex(assert, "-2", "-2");
 496 |         tex(assert, "--2", "--2");
 497 |         tex(assert, "x", "x");
 498 |         tex(assert, "theta", "\\theta");
 499 |         tex(assert, "1/2", "\\frac{1}{2}");
 500 |         tex(assert, "-1/2", "-\\frac{1}{2}");
 501 |         tex(assert, "1/-2", "-\\frac{1}{2}");
 502 |         tex(assert, "-1/-2", "--\\frac{1}{2}");
 503 |     });
 504 | 
 505 |     QUnit.test("addition", function(assert) {
 506 |         tex(assert, "1-2", "1-2");
 507 |         tex(assert, "a+b", "a+b");
 508 |         tex(assert, "a-b", "a-b");
 509 |         tex(assert, "a-1b", "a-1b");
 510 |         tex(assert, "a+-b", "a+-b");
 511 |         tex(assert, "a+-1b", "a+-1b");
 512 |     });
 513 | 
 514 |     QUnit.test("multiplication", function(assert) {
 515 |         tex(assert, "ab", "ab");
 516 |         tex(assert, "a*b", "ab");
 517 |         tex(assert, "a/b", "\\frac{a}{b}");
 518 |         tex(assert, "a/bc/d", "\\frac{ac}{bd}");
 519 | 
 520 |         tex(assert, "1/(x+y)", "\\frac{1}{x+y}");
 521 |         tex(assert, "2/(x+y)", "\\frac{2}{x+y}");
 522 |         tex(assert, "(z+2)/(x+y)", "\\frac{z+2}{x+y}");
 523 |         tex(assert, "(z+2)/4", "\\frac{z+2}{4}");
 524 |     });
 525 | 
 526 |     QUnit.test("rational expressions", function(assert) {
 527 |         tex(assert, "x+1/2", "x+\\frac{1}{2}");
 528 |         tex(assert, "x-1/2", "x-\\frac{1}{2}");
 529 | 
 530 |         tex(assert, "1/2x", "\\frac{1}{2}x");
 531 |         tex(assert, "1/2x/y", "\\frac{1}{2}\\frac{x}{y}");
 532 |         tex(assert, "5*1/2x/y", "\\frac{1}{2}\\frac{5x}{y}");
 533 |         tex(assert, "1/2*4*x/y", "\\frac{1}{2}\\frac{4x}{y}");
 534 |         tex(assert, "-1/2x", "-\\frac{1}{2}x");
 535 |         tex(assert, "a-1/2x", "a-\\frac{1}{2}x");
 536 | 
 537 |         tex(assert, "1/(2x)", "\\frac{1}{2x}");
 538 |         tex(assert, "8/(7p^4)", "\\frac{8}{7p^{4}}");
 539 | 
 540 |         tex(assert, "x/2", "\\frac{x}{2}");
 541 |         tex(assert, "1x/2", "\\frac{1x}{2}");
 542 |         tex(assert, "-x/2", "-\\frac{x}{2}");
 543 |         tex(assert, "x/-2", "-\\frac{x}{2}");
 544 |         tex(assert, "x/-2/-3", "--\\frac{x}{2 \\cdot 3}");
 545 |         tex(assert, "--x/2/3", "--\\frac{x}{2 \\cdot 3}");
 546 |         tex(assert, "a-x/2", "a-\\frac{x}{2}");
 547 | 
 548 |         tex(assert, "1*-2", "1 \\cdot -2");
 549 |         tex(assert, "1*-2*3", "1 \\cdot -2 \\cdot 3");
 550 |         tex(assert, "1*-2*3/4", "1 \\cdot -2 \\cdot \\frac{3}{4}");
 551 |         tex(assert, "1*-2*3/4/5", "1 \\cdot -2 \\cdot \\frac{3}{4} \\cdot \\frac{1}{5}");
 552 |         tex(assert, "1/2*1/2", "\\frac{1}{2} \\cdot \\frac{1}{2}");
 553 |     });
 554 | 
 555 |     QUnit.test("exponentiation", function(assert) {
 556 |         tex(assert, "x^y", "x^{y}");
 557 |         tex(assert, "xy^z", "xy^{z}");
 558 |         tex(assert, "(xy)^z", "(xy)^{z}");
 559 |         tex(assert, "(x+y)^z", "(x+y)^{z}");
 560 |         tex(assert, "x^(yz)", "x^{yz}");
 561 |         tex(assert, "x^-(yz)", "x^{-yz}");
 562 |         tex(assert, "x^(y+z)", "x^{y+z}");
 563 |         tex(assert, "x^-(y+z)", "x^{-(y+z)}");
 564 |         tex(assert, "(x^y)^z", "(x^{y})^{z}");
 565 |         tex(assert, "pir^2", "\\pi r^{2}");
 566 |     });
 567 | 
 568 |     QUnit.test("square root", function(assert) {
 569 |         tex(assert, "sqrt(x)", "\\sqrt{x}");
 570 |         tex(assert, "sqrt(x)y", "\\sqrt{x}y");
 571 |         tex(assert, "1/sqrt(x)", "\\frac{1}{\\sqrt{x}}");
 572 |         tex(assert, "1/sqrt(x)y", "\\frac{y}{\\sqrt{x}}");
 573 | 
 574 |         tex(assert, "sqrt(2)/2", "\\frac{\\sqrt{2}}{2}");
 575 |         tex(assert, "sqrt(2)^2", "(\\sqrt{2})^{2}");
 576 |     });
 577 | 
 578 |     QUnit.test("nth root", function(assert) {
 579 |         // This is an unfortunate case, but only nth degree roots with integer
 580 |         // n's get nicely printed as tex.
 581 |         tex(assert, "sqrt[z]{x}", "x^{\\frac{1}{z}}");
 582 | 
 583 |         tex(assert, "sqrt[3]{x}", "\\sqrt[3]{x}");
 584 |         tex(assert, "sqrt[3]{x}z", "\\sqrt[3]{x}z");
 585 |         tex(assert, "1/sqrt[4]{x}", "\\frac{1}{\\sqrt[4]{x}}");
 586 |         tex(assert, "1/sqrt[4]{x}y", "\\frac{y}{\\sqrt[4]{x}}");
 587 | 
 588 |         tex(assert, "sqrt[9]{2}/2", "\\frac{\\sqrt[9]{2}}{2}");
 589 |         tex(assert, "sqrt[9]{2}^2", "(\\sqrt[9]{2})^{2}");
 590 |     });
 591 | 
 592 |     QUnit.test("absolute value", function(assert) {
 593 |         tex(assert, "|x|", "\\left|x\\right|");
 594 |         tex(assert, "|x|y", "\\left|x\\right|y");
 595 |     })
 596 | 
 597 |     QUnit.test("logarithms", function(assert) {
 598 |         tex(assert, "lnx", "\\ln(x)");
 599 |         tex(assert, "logx", "\\log_{10}(x)");
 600 |         tex(assert, "lnx^y", "\\ln(x^{y})");
 601 |         tex(assert, "logx^y", "\\log_{10}(x^{y})");
 602 |         tex(assert, "(lnx)^y", "[\\ln(x)]^{y}");
 603 |         tex(assert, "(logx)^y", "[\\log_{10}(x)]^{y}");
 604 |     });
 605 | 
 606 |     QUnit.test("trig functions", function(assert) {
 607 |         tex(assert, "sinx", "\\sin(x)");
 608 | 
 609 |         tex(assert, "arcsin x", "\\arcsin(x)");
 610 |         tex(assert, "sin^-1 x", "\\arcsin(x)");
 611 | 
 612 |         tex(assert, "(sinx)^2", "\\sin^{2}(x)");
 613 |         tex(assert, "sin^2 x", "\\sin^{2}(x)");
 614 | 
 615 |         tex(assert, "1/(sinx)^2", "\\frac{1}{\\sin^{2}(x)}");
 616 |         tex(assert, "1/sin^2x", "\\frac{1}{\\sin^{2}(x)}");
 617 | 
 618 |         tex(assert, "sin^2 x + cos^2 x = 1", "\\sin^{2}(x)+\\cos^{2}(x) = 1");
 619 |     });
 620 | 
 621 |     QUnit.test("hyperbolic functions", function(assert) {
 622 |         tex(assert, "sinhx", "\\sinh(x)");
 623 |         tex(assert, "sinh^2 x", "\\sinh^{2}(x)");
 624 |     });
 625 | 
 626 |     QUnit.test("multiplication with numbers", function(assert) {
 627 |         tex(assert, "4*10", "4 \\cdot 10");
 628 |         tex(assert, "10^5", "10^{5}");
 629 |         tex(assert, "4*10^5", "4 \\cdot 10^{5}");
 630 |         tex(assert, "10^5x", "10^{5}x");
 631 |         tex(assert, "4*10^5x", "4 \\cdot 10^{5}x");
 632 |         tex(assert, "x*(10+4)^5", "x(10+4)^{5}");
 633 | 
 634 |         tex(assert, "-1*2", "-1 \\cdot 2");
 635 |         tex(assert, "1*-2", "1 \\cdot -2");
 636 |         tex(assert, "-1*-2", "-1 \\cdot -2");
 637 |         tex(assert, "-1*2*3", "-1 \\cdot 2 \\cdot 3");
 638 |     });
 639 | 
 640 |     QUnit.test("inverses and division", function(assert) {
 641 |         tex(assert, "x^-1", "x^{-1}");
 642 |         tex(assert, "2x^-1", "2x^{-1}");
 643 |         tex(assert, "1/x", "\\frac{1}{x}");
 644 |         tex(assert, "-1/x", "\\frac{-1}{x}");
 645 |         tex(assert, "2/x", "\\frac{2}{x}");
 646 |         tex(assert, "1/x^2", "\\frac{1}{x^{2}}");
 647 |         tex(assert, "2/x^2", "\\frac{2}{x^{2}}");
 648 |         tex(assert, "1/1/x", "\\frac{1}{x}");
 649 |         tex(assert, "1/(1/x)", "\\frac{1}{\\frac{1}{x}}");
 650 |         tex(assert, "1/x/x", "\\frac{1}{xx}");
 651 |         tex(assert, "1/(x/x)", "\\frac{1}{\\frac{x}{x}}");
 652 |         tex(assert, "-1/1/x", "\\frac{-1}{x}");
 653 |         tex(assert, "-1/(1/x)", "\\frac{-1}{\\frac{1}{x}}");
 654 |         tex(assert, "-1/x/x", "\\frac{-1}{xx}");
 655 |         tex(assert, "-1/(x/x)", "\\frac{-1}{\\frac{x}{x}}");
 656 |     });
 657 | 
 658 |     QUnit.test("distributive property", function(assert) {
 659 |         tex(assert, "ab+c", "ab+c");
 660 |         tex(assert, "ab+ac", "ab+ac");
 661 |         tex(assert, "a(b+c)", "a(b+c)");
 662 |     });
 663 | 
 664 |     QUnit.test("numerical exponents", function(assert) {
 665 |         tex(assert, "9^4", "9^{4}");
 666 |         tex(assert, "-9^4", "-9^{4}");
 667 |         tex(assert, "1-9^4", "1-9^{4}");
 668 |     });
 669 | 
 670 |     QUnit.test("negating a Mul", function(assert) {
 671 |         tex(assert, "-3x", "-3x");
 672 |         tex(assert, "--3x", "--3x");
 673 |         tex(assert, "-x*3", "-3x");
 674 |         tex(assert, "--x*3", "--3x");
 675 |     });
 676 | 
 677 |     QUnit.test("equations", function(assert) {
 678 |         tex(assert, "y=x", "y = x");
 679 |         tex(assert, "y<x", "y < x");
 680 |         tex(assert, "y>x", "y > x");
 681 |         tex(assert, "y<>x", "y \\ne x");
 682 |         tex(assert, "y=/=x", "y \\ne x");
 683 |         tex(assert, "y<=x", "y \\le x");
 684 |         tex(assert, "y>=x", "y \\ge x");
 685 |         print(assert, "y \\le x", "y<=x");
 686 |         print(assert, "y \\leq x", "y<=x");
 687 |         print(assert, "y \\ge x", "y>=x");
 688 |         print(assert, "y \\geq x", "y>=x");
 689 |     });
 690 | 
 691 |     QUnit.test("function variables", function(assert) {
 692 |         tex(assert, "f(x)", "fx");
 693 |         tex(assert, "f(x)", "f(x)", {functions: ["f"]});
 694 |         tex(assert, "f(sin x)", "f(\\sin(x))", {functions: ["f"]});
 695 |         tex(assert, "sin f(x)", "\\sin(f(x))", {functions: ["f"]});
 696 |     });
 697 | 
 698 |     var texopt = function(assert, input, expected) {
 699 |         var options = {
 700 |             display: false,
 701 |             dynamic: false,
 702 |             times: false
 703 |         };
 704 |         var optlist = _.toArray(arguments).slice(2);
 705 |         _.each(optlist, function(opt) { options[opt] = true; });
 706 | 
 707 |         var message = input + " renders with options as " + expected;
 708 |         assert.strictEqual(parse(input).asTex(options), expected, message);
 709 |     };
 710 | 
 711 |     QUnit.test("options", function(assert) {
 712 |         texopt(assert, "x", "x");
 713 |         texopt(assert, "x", "\\displaystyle x", "display");
 714 |         texopt(assert, "a(b+c(d+e))", "a(b+c(d+e))");
 715 |         texopt(assert, "a(b+c(d+e))", "a\\left(b+c\\left(d+e\\right)\\right)", "dynamic");
 716 |         texopt(assert, "2*2", "2 \\cdot 2");
 717 |         texopt(assert, "2*2", "2 \\times 2", "times");
 718 | 
 719 |         texopt(assert, "1*2(3+4)", "\\displaystyle 1 \\times 2\\left(3+4\\right)",
 720 |             "display", "dynamic", "times");
 721 |     });
 722 | 
 723 | 
 724 |     QUnit.module("evaluating");
 725 | 
 726 |     var val = function(assert, input, expected, vars, functions) {
 727 |         if (vars === undefined) vars = {};
 728 |         var message = input + " evaluates as " + expected;
 729 |         assert.strictEqual(parse(input, {functions: functions}).eval(vars, {functions: functions}), expected, message);
 730 |     };
 731 | 
 732 |     QUnit.test("empty", function(assert) {
 733 |         val(assert, "", 0);
 734 |     });
 735 | 
 736 |     QUnit.test("simple expressions", function(assert) {
 737 |         val(assert, "1+2+3+4", 10);
 738 |         val(assert, "1+2-3+4", 4);
 739 |         val(assert, "1*2*3*4", 24);
 740 |         val(assert, "1*2/3*4", 2 + 2/3);
 741 |         val(assert, "4^3^2^1", 262144);
 742 |         val(assert, "-1", -1);
 743 |         val(assert, "--1", 1);
 744 |         val(assert, "---1", -1);
 745 |         val(assert, "2^-2", .25);
 746 |         val(assert, "8^(1/3)", 2);
 747 |         val(assert, "0^0", 1);
 748 |         val(assert, ".25*4", 1);
 749 |         val(assert, "ln e", 1);
 750 |         val(assert, "log 10", 1);
 751 |         val(assert, "log_2 2", 1);
 752 |     });
 753 | 
 754 |     QUnit.test("hyperbolic expressions", function(assert) {
 755 |         val(assert, "cosh(0.2)", 1.020066755619076);
 756 |         val(assert, "coth(0.2)", 5.066489563439473);
 757 |         val(assert, "csch(3 * 2)", 0.00495753481347936);
 758 |     });
 759 | 
 760 |     QUnit.test("variable expressions", function(assert) {
 761 |         val(assert, "x", 3, {x: 3});
 762 |         val(assert, "x^2", 9, {x: 3});
 763 |         val(assert, "(x^2+y^2)^.5", 5, {x: 3, y: 4});
 764 |         val(assert, "log x_0", 1, {x_0: 10});
 765 |         val(assert, "log x_0 + log x_1", 3, {x_0: 10, x_1: 100});
 766 |         val(assert, "log x_42", 1, {x_42: 10});
 767 |         val(assert, "x_a + x_bc", 7, {x_a: 1, x_b: 2, c: 3});
 768 |     });
 769 | 
 770 |     QUnit.test("function expressions", function(assert) {
 771 |         val(assert, "f(2)", 4, {"f": "2x"}, ["f"]);
 772 |         val(assert, "f(4+8)", 48, {"f": "4x"}, ["f"]);
 773 |         val(assert, "f(x-1)-f(x)", -7, {"f": "x^3", "x": 2}, ["f"]);
 774 |         val(assert, "g(1)", -1, {f: "x", g: "-f(x)"}, ["f", "g"]);
 775 |     });
 776 | 
 777 |     QUnit.module("compilation");
 778 | 
 779 |     var compile = function(assert, input, expected, vars, functions) {
 780 |         if (vars === undefined) vars = {};
 781 |         var func = parse(input, {functions: functions}).compile();
 782 |         var result;
 783 |         try {
 784 |             result = func(vars);
 785 |         } catch (e) {
 786 |             throw new Error("invalid function: " + func.toString());
 787 |         }
 788 |         var message = input + " should evaluate to " + expected +
 789 | 			", was " + result + "; by func: " + func.toString();
 790 |         assert.ok(Math.abs(result - expected) < 1e-9, message);
 791 |     };
 792 | 
 793 |     QUnit.test("empty", function(assert) {
 794 |         compile(assert, "", 0);
 795 |     });
 796 | 
 797 |     QUnit.test("simple expressions", function(assert) {
 798 |         compile(assert, "1+2+3+4", 10);
 799 |         compile(assert, "1+2-3+4", 4);
 800 |         compile(assert, "1*2*3*4", 24);
 801 |         compile(assert, "1*2/3*4", 2 + 2/3);
 802 |         compile(assert, "4^3^2^1", 262144);
 803 |         compile(assert, "-1", -1);
 804 |         compile(assert, "--1", 1);
 805 |         compile(assert, "---1", -1);
 806 |         compile(assert, "2^-2", .25);
 807 |         compile(assert, "8^(1/3)", 2);
 808 |         compile(assert, "0^0", 1);
 809 |         compile(assert, ".25*4", 1);
 810 |         compile(assert, "ln e", 1);
 811 |         compile(assert, "log 10", 1);
 812 |         compile(assert, "log_2 2", 1);
 813 |     });
 814 | 
 815 |     QUnit.test("variable expressions", function(assert) {
 816 |         compile(assert, "x", 3, {x: 3});
 817 |         compile(assert, "x^2", 9, {x: 3});
 818 |         compile(assert, "(x^2+y^2)^.5", 5, {x: 3, y: 4});
 819 |         compile(assert, "log x_0", 1, {x_0: 10});
 820 |         compile(assert, "log x_0 + log x_1", 3, {x_0: 10, x_1: 100});
 821 |         compile(assert, "log x_42", 1, {x_42: 10});
 822 |         compile(assert, "x_a + x_bc", 7, {x_a: 1, x_b: 2, c: 3});
 823 |     });
 824 | 
 825 |     QUnit.test("function expressions", function(assert) {
 826 |         compile(assert, "f(2)", 4, {"f": function(x) { return 2 * x; }}, ["f"]);
 827 |         compile(assert, "f(4+8)", 48, {"f": function(x) { return 4 * x; }}, ["f"]);
 828 |         compile(assert, "f(x-1)-f(x)", -7, {"f": function(x) { return Math.pow(x, 3); }, "x": 2}, ["f"]);
 829 |     });
 830 | 
 831 |     QUnit.test("trig expressions", function(assert) {
 832 |         compile(assert, "-2sin(pi x) + 4", 4, {x: 32});
 833 |         compile(assert, "sin(pi x)", 0, {x: 6});
 834 |         compile(assert, "sin(x)", 1, {x: Math.PI / 2});
 835 |         compile(assert, "sin(pi x)", -1, {x: 3/2});
 836 |         compile(assert, "cos(x)", 1, {x: 0});
 837 |         compile(assert, "cos x", -1, {x: Math.PI});
 838 |         compile(assert, "tan(x)", 0, {x: 0});
 839 |         compile(assert, "tan x", 1, {x: Math.PI / 4});
 840 |     });
 841 | 
 842 |     QUnit.module("checking form");
 843 | 
 844 |     var norm = function(assert, input, reference) {
 845 |         var actual = parse(input).normalize().print();
 846 |         var expected = parse(reference).normalize().print();
 847 |         var message = input + " is the same as " + reference;
 848 |         assert.strictEqual(actual, expected, message);
 849 |     };
 850 | 
 851 |     QUnit.test("normalize", function(assert) {
 852 |         norm(assert, "ab", "ba");
 853 |         norm(assert, "(ab)c", "(cb)a");
 854 | 
 855 |         var forms = [
 856 |             "(6x+1)(x-1)",
 857 |             "(1+6x)(x-1)",
 858 |             "(6x+1)(-1+x)",
 859 |             "(1+6x)(-1+x)",
 860 |             "(x-1)(6x+1)",
 861 |             "(x-1)(1+6x)",
 862 |             "(-1+x)(6x+1)",
 863 |             "(-1+x)(1+6x)"
 864 |         ];
 865 | 
 866 |         _.each(forms, function(form) {
 867 |             norm(assert, forms[0], form);
 868 |         });
 869 |     });
 870 | 
 871 |     var stripnorm = function(assert, input, reference) {
 872 |         var actual = parse(input).strip().normalize().print();
 873 |         var expected = parse(reference).strip().normalize().print();
 874 |         var message = input + " is the same as " + reference;
 875 |         assert.strictEqual(actual, expected, message);
 876 |     };
 877 | 
 878 |     QUnit.test("strip then normalize", function(assert) {
 879 |         stripnorm(assert, "ab", "ba");
 880 |         stripnorm(assert, "(ab)c", "(cb)a");
 881 | 
 882 |         var forms = [
 883 |             "(6x+1)(x-1)",
 884 |             "(1+6x)(x-1)",
 885 |             "(6x+1)(-1+x)",
 886 |             "(1+6x)(-1+x)",
 887 |             "(-6x-1)(-x+1)",
 888 |             "(-1-6x)(-x+1)",
 889 |             "(-6x-1)(1-x)",
 890 |             "(-1-6x)(1-x)",
 891 |             "(x-1)(6x+1)",
 892 |             "(x-1)(1+6x)",
 893 |             "(-1+x)(6x+1)",
 894 |             "(-1+x)(1+6x)",
 895 |             "(-x+1)(-6x-1)",
 896 |             "(-x+1)(-1-6x)",
 897 |             "(1-x)(-6x-1)",
 898 |             "(1-x)(-1-6x)",
 899 |             "-(6x+1)(1-x)",
 900 |             "-(-6x-1)(x-1)"
 901 |         ];
 902 | 
 903 |         _.each(forms, function(form) {
 904 |             stripnorm(assert, forms[0], form);
 905 |         });
 906 |     })
 907 | 
 908 | 
 909 |     QUnit.module("equation to expression");
 910 | 
 911 |     var asExpr = function(assert, input, reference) {
 912 |         var actual = parse(input).asExpr().simplify().normalize().print();
 913 |         var expected = parse(reference).normalize().print();
 914 |         var message = input + " as an expression is " + reference;
 915 |         assert.strictEqual(actual, expected, message);
 916 |     };
 917 | 
 918 |     QUnit.test("", function(assert) {
 919 |         var forms = [
 920 |             "y=2x-5",
 921 |             "-2x+5=-y",
 922 |             "2x-5<>y",
 923 |             "2x-y<>5",
 924 |             "(y+5)/2=x",
 925 |             "(y+5)/x=2",
 926 |             "1/2(y+5)=x",
 927 |             ".5(y+5)=x",
 928 |             "y-3=2(x-4)",
 929 |             "2y=4x-10",
 930 |             "yz=2xz-5z"
 931 |         ];
 932 | 
 933 |         _.each(forms, function(form) {
 934 |             if (form.indexOf("<>") !== -1) {
 935 |                 asExpr(assert, form, "-y+2x-5");
 936 |             } else {
 937 |                 asExpr(assert, form, "y-2x+5");
 938 |             }
 939 |         });
 940 | 
 941 |         var forms2 = [
 942 |             "1/3p-3=114",
 943 |             "1/3p=117",
 944 |             "p=351",
 945 |             "p-351=0",
 946 |         ];
 947 | 
 948 |         _.each(forms2, function(form) {
 949 |             asExpr(assert, form, "p-351");
 950 |         });
 951 |     });
 952 | 
 953 | 
 954 |     QUnit.module("comparing");
 955 | 
 956 |     var compare = function(assert, options, input, reference, expectedResult) {
 957 |         var actual = parse(input, {functions: ["f", "g", "h"]});
 958 |         var expected = parse(reference, {functions: ["f", "g", "h"]});
 959 |         var result = KAS.compare(actual, expected, options);
 960 |         if (expectedResult === undefined) expectedResult = true;
 961 |         var message = input + " is " + (expectedResult ? "" : "NOT ") + "the same as " + reference;
 962 |         assert.equal(result.equal, expectedResult, message);
 963 |     };
 964 | 
 965 |     QUnit.test("evaluate only", function(assert) {
 966 |         var comp = _.partial(compare, assert, {form: false});
 967 | 
 968 |         comp("2+2", "4");
 969 |         comp("a(b+c)", "ab+ac");
 970 |         comp("a/b", "a*b^-1");
 971 | 
 972 |         comp("1.2^2", "1.44");
 973 |         comp("1.3^2", "1.69");
 974 |         comp("1.4^2", "1.96");
 975 |         comp("1.5^2", "2.25");
 976 | 
 977 |         comp("1.2345^2", "1.52399025");
 978 |         comp("1.2345*1.2345", "1.52399025");
 979 |         comp("(1+.2345)^2", "1.52399025");
 980 |         comp("(-5)^(1/3)", "-1.709975946");
 981 |         comp("(-5)^(2/6)", "-1.709975946");
 982 |         comp("(-5)^(4/3)", "8.549879733");
 983 |         comp("(-5)^(-1/3)", "-0.584803547");
 984 | 
 985 |         comp("(-5)^(1/5)",  "-1.379729661");
 986 |         comp("(-5)^(0.2)",  "-1.379729661");
 987 | 
 988 |         comp("x^(1/5)", "x^(0.2)");
 989 |         comp("x^(8/5)", "x^(1.6)");
 990 | 
 991 |         comp("(1-x)(-1-6x)", "(6x+1)(x-1)");
 992 |         comp("y=x", "x", false);
 993 |         comp("x", "y=x", false);
 994 |         comp("y=x", "y=x");
 995 |         comp("y=x", "x=y");
 996 |         comp("y=x", "-y=-x");
 997 |         comp("y=x", "-x=-y");
 998 |         comp("y=x", "y=-x", false);
 999 |         comp("y=x", "-y=x", false);
1000 |         comp("y=x", "y=/=x", false);
1001 |         comp("y<x", "x>y");
1002 |         comp("y<=x", "x>=y");
1003 |         comp("y>x", "x<y");
1004 |         comp("y>x", "x>y", false);
1005 |         comp("y>=x", "x<=y");
1006 |         comp("a+b<c-d", "a+b-c+d<0");
1007 | 
1008 |         comp("y=mx+b", "-b-mx=-y");
1009 |         comp("y=mx+b", "y-b=mx");
1010 | 
1011 |         // all of these normalize to the same expression, set to zero
1012 |         var forms = [
1013 |             "y=2x-5",
1014 |             "2x-5=y",
1015 |             "2x-y=5",
1016 |             "(y+5)/2=x",
1017 |             "(y+5)/x=2",
1018 |             "1/2(y+5)=x",
1019 |             ".5(y+5)=x",
1020 |             "y-3=2(x-4)",
1021 |             "2y=4x-10",
1022 |             "yz=2xz-5z"
1023 |         ];
1024 | 
1025 |         _.each(forms, function(form) {
1026 |             comp(forms[0], form);
1027 |         });
1028 | 
1029 |         comp("3y=2x-15", "3/2(y+5)=x");
1030 | 
1031 |         var forms2 = [
1032 |             "1/3p-3=114",
1033 |             "1/3p=117",
1034 |             "p=351",
1035 |             "p-351=0",
1036 |         ];
1037 | 
1038 |         _.each(forms2, function(form) {
1039 |             comp(forms2[0], form);
1040 |         });
1041 | 
1042 |         comp("x", "xy/y");
1043 |         comp("e^x", "e^x");
1044 |         comp("e^x", "e^x + 1", false);
1045 | 
1046 |         var forms3 = [
1047 |             "x+x+x+6=12",
1048 |             "x+2x+6=12",
1049 |             "3x+6=12",
1050 |             "x+2x=6",
1051 |             "2x=6-x",
1052 |             "3x=6",
1053 |             "x=2"
1054 |         ];
1055 | 
1056 |         _.each(forms3, function(form) {
1057 |             comp(forms3[0], form);
1058 |         });
1059 | 
1060 |         comp("100/55.6=t", "t=100/55.6");
1061 |         comp("100/1.6^2=t", "t=100/1.6^2");
1062 |         comp("7/3x+x=15", "(2+1/3)x+x=15");
1063 |         comp("7/3x+x=15", "(1+1/3)x+x=15", false);
1064 | 
1065 |         // Symmetric equations
1066 |         comp("x^2+y^2=r^2", "r^2=x^2+y^2");
1067 |         comp("23^1.5=110.304", "110.304=23^1.5");
1068 | 
1069 |         // TODO(alex): make sure that I have both positive and negative
1070 |         // test cases for all functionality
1071 |         comp("6.12*10^-2", "6.12*10^-2");
1072 |         comp("6.12*10^-2", "6.12*10^-6", false);
1073 | 
1074 |         comp("3^-x", "(1/3)^x");
1075 |         comp("(1/3)^-x", "3^x");
1076 |         comp("(3)^-x", "3^x", false);
1077 | 
1078 |         comp("5.6=x+0.4+5.2", "5.6=x+0.4+5.2");
1079 | 
1080 |         // Reciprocal trig functions
1081 |         comp("csc x", "1/sin x");
1082 |         comp("sec x", "1/cos x");
1083 |         comp("cot x", "1/tan x");
1084 |         comp("arccsc x", "arcsin (1/x)");
1085 |         comp("arcsec x", "arccos (1/x)");
1086 |         comp("arccot x", "arctan (1/x)");
1087 | 
1088 |         // Reciprocal hyperbolic trig functions
1089 |         comp("csch x", "1/sinh x");
1090 |         comp("sech x", "1/cosh x");
1091 |         comp("coth x", "1/tanh x");
1092 | 
1093 |         // Make sure trig functions that are the same for all integer values
1094 |         // are not the same
1095 |         comp("-2sin(pi x) + 4", "4", false);
1096 |         comp("2sin(pi x) + 4", "-2sin(pi x) + 4", false);
1097 |         comp("sin(pi x)", "0", false);
1098 |         comp("0", "sin(pi x)", false);
1099 |         comp("cos(pi x)", "cos(2 pi x)", false);
1100 |         comp("sin(pi x)", "sin(500pi x)", false);
1101 |         comp("sin(500pi x)", "sin(pi x)", false);
1102 | 
1103 |         // Check that floating point error isn't killing us
1104 |         // TODO(jack): These don't seem to test much; make better tests
1105 |         comp("0", "sin(7pi)");
1106 |         comp("sin(7pi)", "0");
1107 |         comp("0", "sin(500pi)");
1108 |         comp("sin(500pi)", "0");
1109 | 
1110 |         // Handle denominators the same way regardless of a fraction's format
1111 |         comp("x=1.2^2", "x=1.44");
1112 |         comp("x=1.2^2", "x=36/25");
1113 |         comp("x=1.44", "x=36/25");
1114 |         comp("x=1.44", "x=35/25", false);
1115 | 
1116 |         comp("x=1.2^(2y)", "x=1.44^y");
1117 |         comp("x=1.2^(2y)", "x=(36/25)^y");
1118 |         comp("x=1.44^y", "x=(36/25)^y");
1119 | 
1120 |         comp("x=1.3^2", "x=1.69");
1121 |         comp("x=1.4^2", "x=1.96");
1122 |         comp("x=1.5^2", "x=2.25");
1123 |         comp("x=1.5^2", "x=2.25");
1124 | 
1125 |         comp("x=1.2345^2", "x=1.52399025");
1126 |         comp("x=1.2345*1.2345", "x=1.52399025");
1127 |         comp("x=(1+.2345)^2", "x=1.52399025");
1128 |         comp("x=(1+.2345)^2", "x=1.52399022", false);
1129 | 
1130 |         // Varying small and large comparisons
1131 |         comp("1.1234567891235 * 10^200", "1.1234567891234 * 10^200");
1132 |         comp("1.1234567891235 * 10^200", "0.10", false);
1133 |         comp("0.10", "1.1234567891235 * 10^200", false);
1134 |         comp("0.50", "0.51", false);
1135 |         comp("0.51", "0.50", false);
1136 | 
1137 |         comp("1.00", "1.00");
1138 |         comp("0.9", "1.1", false);
1139 |         comp("1.1", "0.9", false);
1140 | 
1141 |         // Real-world examples of equivalent equations that are now accepted
1142 |         comp("12(1-r)^2+58(1-r)=10", "(1-r)(70-12r)=10");
1143 |         comp("720m+480(m-5)=42000", "720m+480m-2400=42000");
1144 |         comp("2w+50/w=25", "w(12.5-w)=25");
1145 |         comp("(n*(8+4n))/2>19206", "6n+2n(n-1)>19206");
1146 | 
1147 |         // Correctly handle exponents with negative bases and variables in exponent
1148 |         comp("( 2)^n", "( 2)^(n-1)", false);
1149 |         comp("( 2)^n", "( 2)^(n)");
1150 |         comp("( 2)^n", "( 2)^(n+1)", false);
1151 | 
1152 |         comp("(-2)^n", "(-2)^(n-1)", false);
1153 |         comp("(-2)^n", "(-2)^(n)");
1154 |         comp("(-2)^n", "(-2)^(n+1)", false);
1155 | 
1156 |         comp("(-2)^(a)", "(-2)^(ab)", false);
1157 |         comp("(-2)^(a)", "(-2)^(a^b)", false);
1158 | 
1159 |         // This is incorrect, but accurately captures the current behavior
1160 |         // See comment in `Expr.compare()` for more details
1161 |         comp("(-2)^(n+0.1)", "(-2)^(n+1.1)");
1162 |     });
1163 | 
1164 |     QUnit.test("simplify can't yet handle these", function(assert) {
1165 |         var comp = _.partial(compare, assert, {form: false});
1166 | 
1167 |         comp("sin(x + 2pi)", "sin(x)");
1168 |         comp("y = sin(x + 2pi)", "y = sin(x)");
1169 |         comp("sin^2(x)+cos^2(x)", "x/x");
1170 |         comp("y = sin^2(x)+cos^2(x)", "y = x/x");
1171 |     });
1172 | 
1173 |     QUnit.test("partially evaluating functions", function(assert) {
1174 |         var comp = _.partial(compare, assert, {form: false});
1175 | 
1176 |         comp("f(x)", "f(x)");
1177 |         comp("f(x)", "g(x)", false);
1178 |         comp("f(g(x))", "f(g(x))");
1179 |         comp("sin(f(3x-x))/cos(f(x+x))", "tan(f(2x))");
1180 |         comp("f(x) = sin(x + 2pi)", "f(x) = sin(x)");
1181 |         comp("f(x) = sin^2(x)+cos^2(x)", "f(x) = 1");
1182 |         comp("f(x) = ln|x|+c", "f(x)-ln|x|-c = 0");
1183 |     });
1184 | 
1185 |     QUnit.test("evaluating and comparing form", function(assert) {
1186 |         var comp = _.partial(compare, assert, {form: false});
1187 | 
1188 |         comp("ab", "ba");
1189 |         comp("(ab)c", "(cb)a");
1190 | 
1191 |         var forms = [
1192 |             "(6x+1)(x-1)",
1193 |             "(1+6x)(x-1)",
1194 |             "(6x+1)(-1+x)",
1195 |             "(1+6x)(-1+x)",
1196 |             "(-6x-1)(-x+1)",
1197 |             "(-1-6x)(-x+1)",
1198 |             "(-6x-1)(1-x)",
1199 |             "(-1-6x)(1-x)",
1200 |             "(x-1)(6x+1)",
1201 |             "(x-1)(1+6x)",
1202 |             "(-1+x)(6x+1)",
1203 |             "(-1+x)(1+6x)",
1204 |             "(-x+1)(-6x-1)",
1205 |             "(-x+1)(-1-6x)",
1206 |             "(1-x)(-6x-1)",
1207 |             "(1-x)(-1-6x)",
1208 |             "-(6x+1)(1-x)",
1209 |             "-(-6x-1)(x-1)"
1210 |         ];
1211 | 
1212 |         _.each(forms, function(form) {
1213 |             comp(forms[0], form);
1214 |         });
1215 | 
1216 |         comp("(6x+1)(x+1)", "(6x+1)(x-1)", false);
1217 |         comp("a-b-c", "c+b+a", false);
1218 | 
1219 |         comp("(6x+1)(x+1)", "(6x+1)(x-1)", false);
1220 |         comp("a-b-c", "c+b+a", false);
1221 |         comp("mx+b", "b+mx");
1222 | 
1223 |         comp("y=mx+b", "-b-mx=-y");
1224 |         comp("y=mx+b", "y-b=mx", false);
1225 | 
1226 |         comp("y-3=2(x-4)", "y=2x-5", false);
1227 |         comp("y-3=2(x-4)", "2x-y=5", false);
1228 |         comp("y=2x-5", "2x-y=5", false);
1229 |     });
1230 | 
1231 | 
1232 |     QUnit.module("findGCD");
1233 | 
1234 |     var findGCD = function(assert, a, b, reference) {
1235 |         var actual = parse(a).findGCD(parse(b)).repr();
1236 |         var expected = parse(reference).repr();
1237 | 
1238 |         var message = "(" + a + ").findGCD(" + b + ") = " + expected;
1239 |         assert.strictEqual(actual, expected, message);
1240 |     };
1241 | 
1242 |     QUnit.test("findGCD on ints", function(assert) {
1243 |         findGCD(assert, "40", "30", "10");
1244 |         findGCD(assert, "14", "21", "7");
1245 |         findGCD(assert, "13", "26", "13");
1246 |     });
1247 | 
1248 |     QUnit.test("findGCD on rationals", function(assert) {
1249 |         findGCD(assert, "40/3", "55/6", "5/6");
1250 |         findGCD(assert, "3/4", "1/2", "1/4");
1251 |         findGCD(assert, "3/7", "12/22", "3/77");
1252 |         findGCD(assert, "3/10", "4/15", "1/30");
1253 |         findGCD(assert, "2/3", "23/6", "1/6");
1254 |         findGCD(assert, "2/3", "22/6", "1/3");
1255 | 
1256 |         findGCD(assert, "2/3", "2", "2/3");
1257 |         findGCD(assert, "2/3", "3", "1/3");
1258 |         findGCD(assert, "1/2", "4", "1/2");
1259 |         findGCD(assert, "4", "3/4", "1/4");
1260 |         findGCD(assert, "3", "3/4", "3/4");
1261 |     });
1262 | 
1263 |     QUnit.test("findGCD on floats", function(assert) {
1264 |         // Feel free to change this when we do something other
1265 |         // than a naive "return 1" for floats
1266 |         findGCD(assert, "1.23", "1.42", "1");
1267 |         findGCD(assert, "1", String(Math.PI), "1");
1268 |     });
1269 | 
1270 |     QUnit.module("transforming");
1271 | 
1272 |     var factor = function(assert, input, reference) {
1273 |         var actual = parse(input).factor().normalize().repr();
1274 |         var expected = parse(reference).normalize().repr();
1275 |         var message = input + " factors as " + reference;
1276 |         assert.strictEqual(actual, expected, message);
1277 |     };
1278 | 
1279 |     QUnit.test("factoring Adds", function(assert) {
1280 |         factor(assert, "2+2", "2(1+1)");
1281 |         factor(assert, "-2-2", "-2(1+1)");
1282 |         factor(assert, "2x+2", "2(x+1)");
1283 |         factor(assert, "x^3+x^2", "x^2(x+1)");
1284 |         factor(assert, "2x+xy", "x(2+y)");
1285 |         factor(assert, "2xy+xy^2", "xy(2+y)");
1286 |         factor(assert, "2+2/3", "2/3(3+1)");  // a little questionable, but 2/3 is what
1287 |                                       // wolframalpha returns for the gcd, so
1288 |                                       // we pull it out
1289 |         factor(assert, "2x+1.1", "2x+1.1");
1290 |     });
1291 | 
1292 |     QUnit.test("factoring Muls", function(assert) {
1293 |         factor(assert, "(2x+2)/(x+1)", "2 (x+1)/(x+1)");
1294 |         factor(assert, "(x+1)/(2x+2)", "1/2 (x+1)/(x+1)");
1295 |     });
1296 | 
1297 |     QUnit.test("factoring Pows", function(assert) {
1298 |         factor(assert, "x^y+x^(2y)", "x^y(1+x^y)");
1299 |         factor(assert, "x^y+x^z", "x^y+x^z");
1300 |     });
1301 | 
1302 |     var expand = function(assert, input, reference) {
1303 |         var actual = parse(input).expand().normalize().print();
1304 |         var expected = parse(reference).normalize().print();
1305 |         var message = input + " expands as " + reference;
1306 |         assert.strictEqual(actual, expected, message);
1307 |     };
1308 | 
1309 |     var expandrepr = function(assert, input, expected) {
1310 |         var actual = parse(input).expand().repr();
1311 |         var message = input + " expands as " + expected;
1312 |         assert.strictEqual(actual, expected, message);
1313 |     };
1314 | 
1315 |     var expandtex = function(assert, input, expected) {
1316 |         var actual = parse(input).expand().tex();
1317 |         var message = input + " expands and is rendered as " + expected;
1318 |         assert.strictEqual(actual, expected, message);
1319 |     };
1320 | 
1321 |     QUnit.test("distribute over multiplication", function(assert) {
1322 |         expand(assert, "a(b+c)", "ab+ac");
1323 |         expandtex(assert, "a(b+c)", "ab+ac");
1324 |         expandrepr(assert, "a(b+c)", "Add(Mul(Var(a),Var(b)),Mul(Var(a),Var(c)))");
1325 | 
1326 |         expand(assert, "a(b-c)", "ab-ac");
1327 |         expandtex(assert, "a(b-c)", "ab-ac");
1328 |         expandrepr(assert, "a(b-c)", "Add(Mul(Var(a),Var(b)),Mul(Var(a),-1,Var(c)))");
1329 | 
1330 |         expand(assert, "a(b+c)d", "abd+acd");
1331 |         expandrepr(assert, "a(b+c)d", "Add(Mul(Var(a),Var(d),Var(b)),Mul(Var(a),Var(d),Var(c)))");
1332 | 
1333 |         expand(assert, "(a+b)(c+d)", "ac+ad+bc+bd");
1334 |         expand(assert, "(a+b)(c+d)ef", "acef+adef+bcef+bdef");
1335 |         expand(assert, "(a+b)c^d", "ac^d+bc^d");
1336 |         expand(assert, "ab(c+d)e^f", "abce^f+abde^f");
1337 | 
1338 |         expand(assert, "(a+b(c+d))e", "ae+bce+bde");
1339 |         expandrepr(assert, "(a+b(c+d))e", "Add(Mul(Const(e),Var(a)),Mul(Const(e),Var(b),Var(c)),Mul(Const(e),Var(b),Var(d)))");
1340 |     });
1341 | 
1342 |     QUnit.test("distribute over rational expressions", function(assert) {
1343 |         expand(assert, "(a+b)/(c+d)", "(a+b)/(c+d)");
1344 |         expand(assert, "(a+b)/(c+d)*a", "(aa+ab)/(c+d)");
1345 |         expand(assert, "(a+b)/(c+d)*1/e", "(a+b)/(ce+de)");
1346 |         expand(assert, "(a+b)/(c+d)*a/e", "(aa+ab)/(ce+de)");
1347 |     });
1348 | 
1349 |     QUnit.test("expand exponentiation", function(assert) {
1350 |         expand(assert, "(ab)^2", "a^2 b^2");
1351 |         expand(assert, "2*(ab)^2", "2 a^2 b^2");
1352 |         expand(assert, "(a+b)^2", "a^2+2ab+b^2");
1353 | 
1354 |         expand(assert, "(ab)^-2", "a^-2 b^-2");
1355 |         expand(assert, "2*(ab)^-2", "2 a^-2 b^-2");
1356 |         expand(assert, "(a+b)^-2", "(a^2+2ab+b^2)^-1");
1357 |     });
1358 | 
1359 |     QUnit.test("expand absolute value", function(assert) {
1360 |         expand(assert, "|a+b|", "|a+b|");
1361 |         expand(assert, "|ab|", "|a|*|b|");
1362 |     });
1363 | 
1364 |     QUnit.test("expand logarithms", function(assert) {
1365 |         expand(assert, "ln(xy)", "lnx+lny");
1366 |         expand(assert, "log_b(x)", "lnx/lnb");
1367 |         expand(assert, "log_b(xy)", "lnx/lnb+lny/lnb");
1368 |         expand(assert, "ln(xy/z)", "lnx+lny-lnz");
1369 | 
1370 |         expand(assert, "ln(x^y)", "ylnx");
1371 |         expand(assert, "log_b(x^y)", "ylnx/lnb");
1372 |         expand(assert, "ln(x^y^z)", "y^zlnx");
1373 | 
1374 |         expand(assert, "ln(x^y/z)", "ylnx-lnz");
1375 | 
1376 |         // ln((xy)^z) -> ln(x^z*y^z) -> z*ln(x)+z*ln(y)
1377 |         expand(assert, "ln((xy)^z)", "zlnx+zlny");
1378 | 
1379 |         expand(assert, "log_b(x)log_x(y)", "ln(x)/ln(b)*ln(y)/ln(x)");
1380 |         expand(assert, "log_b(x)log_x(y)log_y(z)", "ln(x)/ln(b)*ln(y)/ln(x)*ln(z)/ln(y)");
1381 |     });
1382 | 
1383 |     QUnit.test("expand trig functions", function(assert) {
1384 |         expand(assert, "sin(x)", "sin(x)");
1385 |         expand(assert, "cos(x)", "cos(x)");
1386 |         expand(assert, "tan(x)", "sin(x)/cos(x)");
1387 |         expand(assert, "csc(x)", "1/sin(x)");
1388 |         expand(assert, "sec(x)", "1/cos(x)");
1389 |         expand(assert, "cot(x)", "cos(x)/sin(x)");
1390 |     });
1391 | 
1392 |     QUnit.test("expand hyperbolic functions", function(assert) {
1393 |         expand(assert, "sinh(x)", "sinh(x)");
1394 |         expand(assert, "cosh(x)", "cosh(x)");
1395 |         expand(assert, "tanh(x)", "sinh(x)/cosh(x)");
1396 |         expand(assert, "csch(x)", "1/sinh(x)");
1397 |         expand(assert, "sech(x)", "1/cosh(x)");
1398 |         expand(assert, "coth(x)", "cosh(x)/sinh(x)");
1399 |     });
1400 | 
1401 |     var collect = function(assert, input, reference) {
1402 |         var actual = parse(input).collect().normalize().print();
1403 |         var expected = parse(reference).normalize().print();
1404 |         var message = input + " collects as " + reference;
1405 |         assert.strictEqual(actual, expected, message);
1406 |     };
1407 | 
1408 |     var collectrepr = function(assert, input, expected) {
1409 |         var actual = parse(input).collect().repr();
1410 |         var message = input + " collects as " + expected;
1411 |         assert.strictEqual(actual, expected, message);
1412 |     };
1413 | 
1414 |     var collecttex = function(assert, input, expected) {
1415 |         var actual = parse(input).collect().tex();
1416 |         var message = input + " collects and is rendered as " + expected;
1417 |         assert.strictEqual(actual, expected, message);
1418 |     };
1419 | 
1420 |     QUnit.test("collect over addition", function(assert) {
1421 |         collect(assert, "", "0");
1422 |         collect(assert, "0", "0");
1423 |         collect(assert, "1+3", "4");
1424 |         collect(assert, "x+3", "3+x");
1425 |         collect(assert, "x+3x", "4x");
1426 |         collectrepr(assert, "x+3x", "Mul(4,Var(x))");
1427 |         collect(assert, "a+a+a", "3a");
1428 |         collectrepr(assert, "a+a+a", "Mul(3,Var(a))");
1429 |         collect(assert, "a+b+b+c", "a+2b+c");
1430 |         collectrepr(assert, "a+b+b+c", "Add(Var(a),Mul(2,Var(b)),Var(c))");
1431 |         collect(assert, "4x^2-x^2+8x+7-5x-4", "3+3x+3x^2");
1432 |     });
1433 | 
1434 |     QUnit.test("collect over multiplication", function(assert) {
1435 |         collect(assert, "5*7", "35");
1436 |         collect(assert, "5*7x+20x", "55x");
1437 |         collect(assert, "3x*xy+2yx^2", "5x^2y");
1438 |         collect(assert, "4/6", "2/3");
1439 |         collect(assert, "1/1", "1");
1440 |         collect(assert, "1/2+1/3", "5/6");
1441 |         collect(assert, "1/2+1/3+1", "11/6");
1442 |         collect(assert, "1.2+1/2", "1.7");
1443 |         collect(assert, "1/2-1/2", "0");
1444 |         collect(assert, "1/2-.5", "0");
1445 |     });
1446 | 
1447 |     QUnit.test("collect over exponentiation", function(assert) {
1448 |         collect(assert, "x^0", "1");
1449 |         collect(assert, "x^1", "x");
1450 |         collect(assert, "x^(log_x y)", "y");
1451 |         collect(assert, "(x^y)^z", "x^(yz)");
1452 |         collect(assert, "0^0", "1");
1453 |         collect(assert, "4^1.5", "8");
1454 |         collect(assert, "(2/3)^2", "4/9");
1455 |         collect(assert, "(2/3)^-2", "9/4");
1456 |     });
1457 | 
1458 |     QUnit.test("collect over roots", function(assert) {
1459 |         collect(assert, "sqrt(2)^2", "2");
1460 |         collect(assert, "sqrt[3]{3}^3", "3");
1461 |         collect(assert, "(2^(1/3))^3", "2");
1462 |     });
1463 | 
1464 |     QUnit.test("collect over absolute value", function(assert) {
1465 |         collect(assert, "|x|", "|x|");
1466 |         collect(assert, "|2|", "2");
1467 |         collect(assert, "|0|", "0");
1468 |         collect(assert, "|-2|", "2");
1469 |         collect(assert, "|pi|", "pi");
1470 |         collect(assert, "|2^x|", "2^x");
1471 |         collect(assert, "|x^2|", "x^2");
1472 |         collect(assert, "|-2pix^2y^3|", "2pix^2*|y^3|");
1473 |     });
1474 | 
1475 |     QUnit.test("collect over logarithms", function(assert) {
1476 |         collect(assert, "log(1)", "0");
1477 |         collect(assert, "log_x(x)", "1");
1478 |         collect(assert, "log_b(b^x)", "x");
1479 | 
1480 |         collect(assert, "b^(2*y*log_b x)", "x^(2y)");
1481 |         collect(assert, "b^(log_b a) b^(-log_b c)", "a/c");
1482 | 
1483 |         collect(assert, "ln(x)/ln(b)", "log_b(x)");
1484 |         collect(assert, "ln(x)/ln(b)*ln(y)/ln(x)", "log_b(y)");
1485 |         collect(assert, "ln(x)/ln(b)*ln(y)/ln(x)*ln(z)/ln(y)", "log_b(z)");
1486 |     });
1487 | 
1488 |     QUnit.test("collect trig functions", function(assert) {
1489 |         collect(assert, "sin(x)cos(x)", "sin(x)cos(x)");
1490 |         collect(assert, "sin(x)/cos(x)", "tan(x)");
1491 | 
1492 |         collect(assert, "sin^2(x)/cos^2(x)", "tan^2(x)");
1493 |         collect(assert, "cos^2(x)/sin^2(x)", "cot^2(x)");
1494 | 
1495 |         collect(assert, "sin^-2(x)/cos^-2(x)", "cot^2(x)");
1496 |         collect(assert, "cos^-2(x)/sin^-2(x)", "tan^2(x)");
1497 | 
1498 |         collect(assert, "sin^--2(x)/cos^--2(x)", "tan^2(x)");
1499 |         collect(assert, "cos^--2(x)/sin^--2(x)", "cot^2(x)");
1500 | 
1501 |         collect(assert, "sin^2(x)/cos(x)", "sin^2(x)/cos(x)");
1502 |         collect(assert, "sin(x)/cos^2(x)", "sin(x)/cos^2(x)");
1503 | 
1504 |         collect(assert, "sin(-x)", "-sin(x)");
1505 |         collect(assert, "cos(-x)", "cos(x)");
1506 |         collect(assert, "tan(-x)", "-tan(x)");
1507 |         collect(assert, "csc(-x)", "-csc(x)");
1508 |         collect(assert, "sec(-x)", "sec(x)");
1509 |         collect(assert, "cot(-x)", "-cot(x)");
1510 | 
1511 |         collect(assert, "sin(--x)", "sin(x)");
1512 |         collect(assert, "arcsin(-x)", "arcsin(-x)");
1513 | 
1514 |         collect(assert, "sin(-x)cos(-x)", "-sin(x)cos(x)");
1515 |         collect(assert, "sin(-x)/cos(-x)", "-tan(x)");
1516 |     });
1517 | 
1518 |     QUnit.test("collect then output tex", function(assert) {
1519 |         // user-friendly tex representation is not guaranteed after collect(assert, )
1520 |         collect(assert, "-x", "-1x");
1521 |         collecttex(assert, "-x", "-1x");
1522 |         collect(assert, "a-b", "a+-1b");
1523 |         collecttex(assert, "a-b", "a+-1b");
1524 |         collect(assert, "a/b", "ab^-1");
1525 |         collecttex(assert, "a/b", "ab^{-1}");
1526 |     });
1527 | 
1528 |     QUnit.test("collect over an equation", function(assert) {
1529 |         // collect does not try to collect across both sides of an equation
1530 |         collect(assert, "y+1-1=x*x", "y=x^(2)");
1531 |         collect(assert, "1+y=1+x^2", "1+y=1+x^(2)");
1532 |     });
1533 | 
1534 |     var simplify = function(assert, input, reference) {
1535 |         var actual = parse(input).simplify().normalize().print();
1536 |         var expected = parse(reference).normalize().print();
1537 |         var message = input + " simplifies as " + reference;
1538 |         assert.strictEqual(actual, expected, message);
1539 |     };
1540 | 
1541 |     QUnit.test("simplify", function(assert) {
1542 |         simplify(assert, "(a+b)^2", "(a+b)^2");
1543 |         simplify(assert, "(a+b)(a+b)", "(a+b)^2");
1544 | 
1545 |         // (ab)^2 ->[factor]-> a^2 * b^2 ->[collect]-> a^2 * b^2
1546 |         // (no change during collect, therefore factoring is rolled back)
1547 |         simplify(assert, "(ab)^2", "(ab)^2");
1548 | 
1549 |         // (3x)^2 ->[factor]-> 3^2 * x^2 ->[collect]-> 9x^2
1550 |         // (changed during collect, therefore factoring persists)
1551 |         simplify(assert, "(3x)^2", "9x^2");
1552 | 
1553 |         simplify(assert, "(2sqrt(2))^4", "64");
1554 |         simplify(assert, "(3sqrt[3]{3})^9", "531441");
1555 | 
1556 |         // from "Simplifying expressions with exponents"
1557 |         simplify(assert, "((nx^5)^5)", "n^5 x^25");
1558 |         simplify(assert, "((nx^5)^5)/2", "1/2 n^5 x^25");
1559 |         simplify(assert, "((nx^5)^5)/(n^-2x^2)^-3", "n^-1 x^31");
1560 | 
1561 |         simplify(assert, "1/(xya)+1/(xyb)", "1/(xya)+1/(xyb)");
1562 | 
1563 |         // Simplify rationals correctly
1564 |         simplify(assert, "2*(x+1/3)", "2*x+2/3");
1565 |         simplify(assert, "-1*(1/3+x)", "-1*x+-1/3");
1566 |     });
1567 | 
1568 |     QUnit.module("units");
1569 | 
1570 |     var unitEq = function(assert, x, y, msg) {
1571 |         assert.ok(KAS.compare(x.simplify(), y.simplify()).equal, msg);
1572 |     };
1573 | 
1574 |     var unitNeq = function(assert, x, y, msg) {
1575 |         assert.ok(!KAS.compare(x.simplify(), y.simplify()).equal, msg);
1576 |     };
1577 | 
1578 |     var parseEq = function(assert, x, y, msg) {
1579 |         unitEq(assert, KAS.unitParse(x).expr, KAS.unitParse(y).expr, msg);
1580 |     };
1581 | 
1582 |     var parseNeq = function(assert, x, y, msg) {
1583 |         unitNeq(assert, KAS.unitParse(x).expr, KAS.unitParse(y).expr, msg);
1584 |     };
1585 | 
1586 |     var solveUnitVariable = function(assert, original, newUnit, expected) {
1587 |         var originalParsed = KAS.unitParse(original).expr;
1588 |         var newUnitParsed = KAS.unitParse(newUnit).unit;
1589 |         var x = new KAS.Var("x");
1590 |         var equality = new KAS.Eq(
1591 |             originalParsed,
1592 |             "=",
1593 |             new KAS.Mul(x, newUnitParsed)
1594 |         );
1595 |         var answer = equality.solveLinearEquationForVariable(x);
1596 | 
1597 |         var msg = original + " = [" + expected.print() + "] " + newUnit;
1598 |         assert.ok(Math.round(answer.eval()) == Math.round(expected.eval()), msg);
1599 |     };
1600 | 
1601 |     var formEq = function(x, y) {
1602 |         return KAS.compare(
1603 |             KAS.unitParse(x).unit,
1604 |             KAS.unitParse(y).unit
1605 |         ).equal;
1606 |     };
1607 | 
1608 |     var parseMagnitude = function(assert, str, expected) {
1609 |         var parsed = KAS.unitParse(str).coefficient;
1610 |         assert.ok(+parsed, expected);
1611 |     };
1612 | 
1613 |     QUnit.test("simplify expressions with units", function(assert) {
1614 |         unitEq(
1615 |             assert,
1616 |             new KAS.Mul(new KAS.Rational(1, 100), new KAS.Unit("cup")),
1617 |             new KAS.Mul(new KAS.Rational(1, 400), new KAS.Unit("qt")),
1618 |             "1/100 cup = 1 / 400 quart"
1619 |         );
1620 | 
1621 |         parseEq(assert, "10 g", "0.01 kg", "10 g = 1 / 100 kg");
1622 | 
1623 |         parseEq(assert, "9.8 kg m / s^2", "9.8 N", "9.8 kg m / s^2 = 9.8 N");
1624 | 
1625 |         parseEq(assert, "9.8 m / s^2", "9.8 N / kg", "9.8 m / s^2 = 9.8 N / kg");
1626 | 
1627 |         unitEq(
1628 |             assert,
1629 |             new KAS.Mul(new KAS.Float(9.8),
1630 |                         new KAS.Unit("m"),
1631 |                         new KAS.Pow(new KAS.Unit("s"), new KAS.Int(-2))),
1632 |             new KAS.Mul(new KAS.Float(9.8),
1633 |                         new KAS.Pow(new KAS.Unit("s"), new KAS.Int(-2)),
1634 |                         new KAS.Unit("m")),
1635 |             "9.8 m / s^2 = 9.8 s^-2 m"
1636 |         );
1637 | 
1638 |         unitEq(
1639 |             assert,
1640 |             new KAS.Mul(new KAS.Int(50),
1641 |                         new KAS.Unit("m"),
1642 |                         new KAS.Pow(new KAS.Unit("m"), new KAS.Int(-1))),
1643 |             new KAS.Int(50),
1644 |             "50 m / m = 50"
1645 |         );
1646 | 
1647 |         // There's a long chain of conversions before this is fully simplified.
1648 |         // tsp -> tbsp -> cup -> gal -> L -> m^3
1649 |         //
1650 |         //         1 tbsp    1 cup     1 gal   3.785 L
1651 |         // 1 tsp * ------ * ------- * ------ * -------
1652 |         //         3 tsp    16 tbsp   16 cup     gal
1653 |         unitEq(
1654 |             assert,
1655 |             new KAS.Unit("tsp"),
1656 |             new KAS.Mul(
1657 |                 new KAS.Rational(1, 3),
1658 |                 new KAS.Rational(1, 16),
1659 |                 new KAS.Rational(1, 16),
1660 |                 new KAS.Float(3.785),
1661 |                 new KAS.Unit("L")
1662 |             ),
1663 |             "tsp reduces"
1664 |         );
1665 | 
1666 |         assert.ok(
1667 |             !KAS.compare(
1668 |                 new KAS.Mul(new KAS.Int(50), new KAS.Unit("m")),
1669 |                 new KAS.Int(50)
1670 |             ).equal,
1671 |             "50 m != 50"
1672 |         );
1673 | 
1674 |         parseNeq(assert, "50 m", "50 A", "50 m != 50 A");
1675 |         parseEq(assert, "5000 mA", "5 A", "5000 mA = 5 A");
1676 |         parseNeq(assert, "5 mA", "5 A", "5 mA != 5 A");
1677 | 
1678 |         parseNeq(assert, "9.8 kg m / s^2", "9.8 J", "9.8 kg m / s^2 != 9.8 J");
1679 |         parseEq(assert, "9.8 kg m / s^2", "9.8 J/m", "9.8 kg m / s^2 = 9.8 J/m");
1680 | 
1681 |         assert.ok(!formEq("mA", "A"), "mA !== A")
1682 |         assert.ok(!formEq("g", "kg"), "g !== kg");
1683 |         assert.ok(!formEq("kg m / s^2", "N"), "kg m / s^2 !== N");
1684 |         assert.ok(!formEq("m / s^2", "N / kg"), "m / s^2 !== N / kg");
1685 | 
1686 |         assert.ok(formEq("A", "A"), "A === A");
1687 |         assert.ok(formEq("kg", "kg"), "kg = kg");
1688 |         assert.ok(formEq("kg m / s^2", "m kg / s^2"), "kg m / s^2 === m kg / s^2");
1689 |         assert.ok(formEq("m / s^2", "m / s^2"), "m / s^2 === m / s^2");
1690 | 
1691 |         // btu doesn't allow si prefixes
1692 |         assert.throws(new KAS.Unit("mBTU"), "mBTU throws");
1693 | 
1694 |         solveUnitVariable(
1695 |             assert,
1696 |             "2.5 gal", "cup", new KAS.Int(40)
1697 |         );
1698 | 
1699 |         //         1 tbsp    1 cup     1 gal    3785 L    1 m^3    ( 100 cm ) 3
1700 |         // 1 tsp * ------ * ------- * ------ * -------- * ------ * (--------)
1701 |         //         3 tsp    16 tbsp   16 cup   1000 gal   1000 L   (    m   )
1702 |         solveUnitVariable(
1703 |             assert,
1704 |             "1 tsp", "cm^3", new KAS.Rational(3785, 768)
1705 |         );
1706 | 
1707 |         solveUnitVariable(
1708 |             assert,
1709 |             "1 dozen qt", "gal", new KAS.Int(3)
1710 |         );
1711 | 
1712 |         solveUnitVariable(
1713 |             assert,
1714 |             "1 day", "sec", new KAS.Int(60*60*24)
1715 |         );
1716 | 
1717 |         solveUnitVariable(
1718 |             assert,
1719 |             "5 kg m / s^2", "N", new KAS.Int(5)
1720 |         );
1721 | 
1722 |         // This was originally broken due to a scientific notation parsing
1723 |         // problem. Leaving it around because it doesn't hurt anything.
1724 |         solveUnitVariable(
1725 |             assert,
1726 |             "5 x 10^5 N", "lb", new KAS.Int(112404)
1727 |         );
1728 | 
1729 |         parseMagnitude(assert, "5 x 10^5 N", 500000);
1730 |         parseMagnitude(assert, "1.23456 x 10^5 N", 123456);
1731 |         parseMagnitude(assert, "3.14 x 10^-2 N", 0.0314);
1732 |     });
1733 | 
1734 |     QUnit.module("isSimplified");
1735 | 
1736 |     var isSimplified = function(assert, input, expectedResult, options) {
1737 |         if (expectedResult === undefined) expectedResult = true;
1738 |         var message = input + (expectedResult ? " is " : " is NOT ") + "simplified";
1739 |         assert.ok(parse(input, options).isSimplified() === expectedResult, message);
1740 |     };
1741 | 
1742 |     QUnit.test("isSimplified (addition/subtraction)", function(assert) {
1743 |         isSimplified(assert, "a+b+c");
1744 |         isSimplified(assert, "a-b-c");
1745 |         isSimplified(assert, "a+b+c+c", false);
1746 |         isSimplified(assert, "a-b-c-d-d+d", false);
1747 |         isSimplified(assert, "x");
1748 |         isSimplified(assert, "x+0", false);
1749 |     });
1750 | 
1751 |     QUnit.test("isSimplified (multiplication/division/negation)", function(assert) {
1752 |         isSimplified(assert, "1/2");
1753 |         isSimplified(assert, "2/1", false);
1754 |         isSimplified(assert, "(2x)/(5x)", false);
1755 |         isSimplified(assert, "-x");
1756 |         isSimplified(assert, "-1*x");
1757 |         isSimplified(assert, "--x", false);
1758 |         isSimplified(assert, "x/1", false);
1759 |         isSimplified(assert, "x/y");
1760 |         isSimplified(assert, "xy/z");
1761 |         isSimplified(assert, "-3x");
1762 |         isSimplified(assert, "-x*3");
1763 |         isSimplified(assert, "-x*3*y");
1764 |         isSimplified(assert, "(x+1)/(2(x+1))", false);
1765 |     });
1766 | 
1767 |     QUnit.test("isSimplified (exponentiation)", function(assert) {
1768 |         isSimplified(assert, "x^-1");
1769 |         isSimplified(assert, "1/x");
1770 |         isSimplified(assert, "1/x^-1", false);
1771 |     });
1772 | 
1773 |     QUnit.test("isSimplified (logarithms)", function(assert) {
1774 |         isSimplified(assert, "ln(x)");
1775 |         isSimplified(assert, "ln(x+y)");
1776 | 
1777 |         // Will only expand logarithms if leads to a simpler expression
1778 |         // TODO(alex): Combine all simplify(assert, ) and isSimplified(assert, ) tests!
1779 |         isSimplified(assert, "ln(x/y)");
1780 |         isSimplified(assert, "ln(x/y)+ln(y)", false);
1781 |     });
1782 | 
1783 |     QUnit.test("isSimplified (equations)", function(assert) {
1784 |         isSimplified(assert, "x=10");
1785 |         isSimplified(assert, "x=-10");
1786 |         isSimplified(assert, "x=10y");
1787 |         isSimplified(assert, "x=-10y");
1788 |         isSimplified(assert, "x=10+y");
1789 |         isSimplified(assert, "x=-10+y");
1790 | 
1791 |         isSimplified(assert, "f(2x) = 10", true, {functions: ["f"]});
1792 |         isSimplified(assert, "f(x+x) = 10", false, {functions: ["f"]});
1793 |     });
1794 | 
1795 |     QUnit.test("isSimplified (equalities)", function(assert) {
1796 |         isSimplified(assert, "y=x");
1797 |         isSimplified(assert, "y=x^2");
1798 |         isSimplified(assert, "y=x*x", false);
1799 | 
1800 |         isSimplified(assert, "y=x^2+1");
1801 |         isSimplified(assert, "xy=x^2+1");
1802 |         isSimplified(assert, "y+1=x^2+1", false);
1803 | 
1804 |         isSimplified(assert, "xy=x^2", false);
1805 |         isSimplified(assert, "x^2y=x^3", false);
1806 |         isSimplified(assert, "alnx=blnx+clnx", false)
1807 | 
1808 |         isSimplified(assert, "xy=0");
1809 |         isSimplified(assert, "2xy=0", false);
1810 |         isSimplified(assert, "xy/z=0");
1811 |     });
1812 | 
1813 |     QUnit.test("isSimplified (inequalities)", function(assert) {
1814 |         isSimplified(assert, "y<x");
1815 |         isSimplified(assert, "y<x^2");
1816 |         isSimplified(assert, "y<x*x", false);
1817 | 
1818 |         isSimplified(assert, "y<x^2+1");
1819 |         isSimplified(assert, "xy<x^2+1");
1820 |         isSimplified(assert, "y+1<x^2+1", false);
1821 | 
1822 |         isSimplified(assert, "xy<x^2"); // x might be negative
1823 |         isSimplified(assert, "x^2y<x^3", false);
1824 |         isSimplified(assert, "alnx<blnx+clnx"); // lnx might be negative
1825 | 
1826 |         isSimplified(assert, "xy<0");
1827 |         isSimplified(assert, "2xy<0", false);
1828 |         isSimplified(assert, "xy/z<0");
1829 |     });
1830 | 
1831 |     QUnit.test("isSimplified (rational expressions)", function(assert) {
1832 |         isSimplified(assert, "3/4 x");
1833 |         isSimplified(assert, "3/(4x)");
1834 |         isSimplified(assert, "3/4 1/x");
1835 | 
1836 |         isSimplified(assert, "(x+1)/(x+2)");
1837 |         isSimplified(assert, "(x+1)/(2x+2)", false);
1838 |         isSimplified(assert, "(2x+2)/(x+1)", false);
1839 | 
1840 |         isSimplified(assert, "xy+2y=x+1");
1841 |         isSimplified(assert, "y=(x+1)/(x+2)");
1842 |         isSimplified(assert, "y/(x+1)=1/(x+2)");
1843 | 
1844 |         // TODO(alex): Combine all isSimplified(assert, ) and simplify(assert, ) tests!
1845 |         isSimplified(assert, "y=(x+1)/(2x+2)", false);
1846 |         isSimplified(assert, "y=1/2");
1847 | 
1848 |         isSimplified(assert, "y=(2x+2)/(x+1)", false);
1849 |         isSimplified(assert, "y=2");
1850 | 
1851 |         // same denominators (adding_and_subtracting_rational_expressions_1.5)
1852 |         isSimplified(assert, "(15np-25mp)/(15p^2-5p)+(20mp+10p^2)/(15p^2-5p)", false);
1853 |         isSimplified(assert, "(3n-m+2p)/(3p-1)");
1854 | 
1855 |         isSimplified(assert, "5yx/(2x^2+4yx)-(2x^2-6yx)/(2x^2+4yx)", false);
1856 |         isSimplified(assert, "(11y-2x)/(2x+4y)");
1857 | 
1858 |         isSimplified(assert, "(25m^2-20pm)/(5pm+5m)-20m^2/(5pm+5m)", false);
1859 |         isSimplified(assert, "(m-4p)/(p+1)");
1860 | 
1861 |         // pathological examples
1862 |         isSimplified(assert, "  (a + b)/(2c+2d)");
1863 |         isSimplified(assert, "  (3a+3b)/(2c+2d)");
1864 |         isSimplified(assert, "  (2a+2b)/( c+ d)");
1865 |         isSimplified(assert, "  (2a+2b)/(3c+3d)");
1866 |         isSimplified(assert, "  (2a+2b)/(4c+4d)", false);
1867 |         isSimplified(assert, "  (4a+4b)/(2c+2d)", false);
1868 |         isSimplified(assert, "y=(a + b)/(2c+2d)");
1869 |         isSimplified(assert, "y=(3a+3b)/(2c+2d)");
1870 |         isSimplified(assert, "y=(2a+2b)/( c+ d)");
1871 |         isSimplified(assert, "y=(2a+2b)/(3c+3d)");
1872 |         isSimplified(assert, "y=(2a+2b)/(4c+4d)", false);
1873 |         isSimplified(assert, "y=(4a+4b)/(2c+2d)", false);
1874 |     });
1875 | 
1876 |     var hasConsts = function(assert, input, expectedConsts, options) {
1877 |         assert.deepEqual(parse(input, options).getConsts(), expectedConsts);
1878 |     };
1879 | 
1880 |     QUnit.test("getConsts", function(assert) {
1881 |         hasConsts(assert, "4", []);
1882 |         hasConsts(assert, "4x", []);
1883 |         hasConsts(assert, "4pi", ["pi"]);
1884 |         hasConsts(assert, "4e", ["e"]);
1885 |         hasConsts(assert, "4pi+e", ["e", "pi"]);
1886 |         hasConsts(assert, "4pi+pi", ["pi"]);
1887 |         hasConsts(assert, "4cos(pi)", ["pi"]);
1888 |         hasConsts(assert, "4cos(xpi)", ["pi"]);
1889 |         hasConsts(assert, "(4x)/(2pi)", ["pi"]);
1890 |         hasConsts(assert, "4sec(x)", []);
1891 |     });
1892 | })(KAS);
1893 | </script>
1894 | 
1895 | </body>
1896 | </html>
1897 | 


--------------------------------------------------------------------------------
/yarn.lock:
--------------------------------------------------------------------------------
   1 | # THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
   2 | # yarn lockfile v1
   3 | 
   4 | 
   5 | JSONSelect@0.4.0:
   6 |   version "0.4.0"
   7 |   resolved "https://registry.yarnpkg.com/JSONSelect/-/JSONSelect-0.4.0.tgz#a08edcc67eb3fcbe99ed630855344a0cf282bb8d"
   8 |   integrity sha1-oI7cxn6z/L6Z7WMIVTRKDPKCu40=
   9 | 
  10 | "JSV@>= 4.0.x":
  11 |   version "4.0.2"
  12 |   resolved "https://registry.yarnpkg.com/JSV/-/JSV-4.0.2.tgz#d077f6825571f82132f9dffaed587b4029feff57"
  13 |   integrity sha1-0Hf2glVx+CEy+d/67Vh7QCn+/1c=
  14 | 
  15 | abbrev@1:
  16 |   version "1.1.1"
  17 |   resolved "https://registry.yarnpkg.com/abbrev/-/abbrev-1.1.1.tgz#f8f2c887ad10bf67f634f005b6987fed3179aac8"
  18 |   integrity sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==
  19 | 
  20 | amdefine@>=0.0.4:
  21 |   version "1.0.1"
  22 |   resolved "https://registry.yarnpkg.com/amdefine/-/amdefine-1.0.1.tgz#4a5282ac164729e93619bcfd3ad151f817ce91f5"
  23 |   integrity sha1-SlKCrBZHKek2Gbz9OtFR+BfOkfU=
  24 | 
  25 | ansi-styles@^4.1.0:
  26 |   version "4.3.0"
  27 |   resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-4.3.0.tgz#edd803628ae71c04c85ae7a0906edad34b648937"
  28 |   integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==
  29 |   dependencies:
  30 |     color-convert "^2.0.1"
  31 | 
  32 | ansi-styles@~1.0.0:
  33 |   version "1.0.0"
  34 |   resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-1.0.0.tgz#cb102df1c56f5123eab8b67cd7b98027a0279178"
  35 |   integrity sha1-yxAt8cVvUSPquLZ817mAJ6AnkXg=
  36 | 
  37 | argparse@^1.0.7:
  38 |   version "1.0.10"
  39 |   resolved "https://registry.yarnpkg.com/argparse/-/argparse-1.0.10.tgz#bcd6791ea5ae09725e17e5ad988134cd40b3d911"
  40 |   integrity sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==
  41 |   dependencies:
  42 |     sprintf-js "~1.0.2"
  43 | 
  44 | arr-diff@^4.0.0:
  45 |   version "4.0.0"
  46 |   resolved "https://registry.yarnpkg.com/arr-diff/-/arr-diff-4.0.0.tgz#d6461074febfec71e7e15235761a329a5dc7c520"
  47 |   integrity sha1-1kYQdP6/7HHn4VI1dhoyml3HxSA=
  48 | 
  49 | arr-flatten@^1.1.0:
  50 |   version "1.1.0"
  51 |   resolved "https://registry.yarnpkg.com/arr-flatten/-/arr-flatten-1.1.0.tgz#36048bbff4e7b47e136644316c99669ea5ae91f1"
  52 |   integrity sha512-L3hKV5R/p5o81R7O02IGnwpDmkp6E982XhtbuwSe3O4qOtMMMtodicASA1Cny2U+aCXcNpml+m4dPsvsJ3jatg==
  53 | 
  54 | arr-union@^3.1.0:
  55 |   version "3.1.0"
  56 |   resolved "https://registry.yarnpkg.com/arr-union/-/arr-union-3.1.0.tgz#e39b09aea9def866a8f206e288af63919bae39c4"
  57 |   integrity sha1-45sJrqne+Gao8gbiiK9jkZuuOcQ=
  58 | 
  59 | array-each@^1.0.1:
  60 |   version "1.0.1"
  61 |   resolved "https://registry.yarnpkg.com/array-each/-/array-each-1.0.1.tgz#a794af0c05ab1752846ee753a1f211a05ba0c44f"
  62 |   integrity sha1-p5SvDAWrF1KEbudTofIRoFugxE8=
  63 | 
  64 | array-slice@^1.0.0:
  65 |   version "1.1.0"
  66 |   resolved "https://registry.yarnpkg.com/array-slice/-/array-slice-1.1.0.tgz#e368ea15f89bc7069f7ffb89aec3a6c7d4ac22d4"
  67 |   integrity sha512-B1qMD3RBP7O8o0H2KbrXDyB0IccejMF15+87Lvlor12ONPRHP6gTjXMNkt/d3ZuOGbAe66hFmaCfECI24Ufp6w==
  68 | 
  69 | array-unique@^0.3.2:
  70 |   version "0.3.2"
  71 |   resolved "https://registry.yarnpkg.com/array-unique/-/array-unique-0.3.2.tgz#a894b75d4bc4f6cd679ef3244a9fd8f46ae2d428"
  72 |   integrity sha1-qJS3XUvE9s1nnvMkSp/Y9Gri1Cg=
  73 | 
  74 | assign-symbols@^1.0.0:
  75 |   version "1.0.0"
  76 |   resolved "https://registry.yarnpkg.com/assign-symbols/-/assign-symbols-1.0.0.tgz#59667f41fadd4f20ccbc2bb96b8d4f7f78ec0367"
  77 |   integrity sha1-WWZ/QfrdTyDMvCu5a41Pf3jsA2c=
  78 | 
  79 | async@~1.5.2:
  80 |   version "1.5.2"
  81 |   resolved "https://registry.yarnpkg.com/async/-/async-1.5.2.tgz#ec6a61ae56480c0c3cb241c95618e20892f9672a"
  82 |   integrity sha1-7GphrlZIDAw8skHJVhjiCJL5Zyo=
  83 | 
  84 | atob@^2.1.2:
  85 |   version "2.1.2"
  86 |   resolved "https://registry.yarnpkg.com/atob/-/atob-2.1.2.tgz#6d9517eb9e030d2436666651e86bd9f6f13533c9"
  87 |   integrity sha512-Wm6ukoaOGJi/73p/cl2GvLjTI5JM1k/O14isD73YML8StrH/7/lRFgmg8nICZgD3bZZvjwCGxtMOD3wWNAu8cg==
  88 | 
  89 | balanced-match@^1.0.0:
  90 |   version "1.0.2"
  91 |   resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.2.tgz#e83e3a7e3f300b34cb9d87f615fa0cbf357690ee"
  92 |   integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==
  93 | 
  94 | base@^0.11.1:
  95 |   version "0.11.2"
  96 |   resolved "https://registry.yarnpkg.com/base/-/base-0.11.2.tgz#7bde5ced145b6d551a90db87f83c558b4eb48a8f"
  97 |   integrity sha512-5T6P4xPgpp0YDFvSWwEZ4NoE3aM4QBQXDzmVbraCkFj8zHM+mba8SyqB5DbZWyR7mYHo6Y7BdQo3MoA4m0TeQg==
  98 |   dependencies:
  99 |     cache-base "^1.0.1"
 100 |     class-utils "^0.3.5"
 101 |     component-emitter "^1.2.1"
 102 |     define-property "^1.0.0"
 103 |     isobject "^3.0.1"
 104 |     mixin-deep "^1.2.0"
 105 |     pascalcase "^0.1.1"
 106 | 
 107 | brace-expansion@^1.1.7:
 108 |   version "1.1.11"
 109 |   resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.11.tgz#3c7fcbf529d87226f3d2f52b966ff5271eb441dd"
 110 |   integrity sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==
 111 |   dependencies:
 112 |     balanced-match "^1.0.0"
 113 |     concat-map "0.0.1"
 114 | 
 115 | braces@^2.3.1:
 116 |   version "2.3.2"
 117 |   resolved "https://registry.yarnpkg.com/braces/-/braces-2.3.2.tgz#5979fd3f14cd531565e5fa2df1abfff1dfaee729"
 118 |   integrity sha512-aNdbnj9P8PjdXU4ybaWLK2IF3jc/EoDYbC7AazW6to3TRsfXxscC9UXOB5iDiEQrkyIbWp2SLQda4+QAa7nc3w==
 119 |   dependencies:
 120 |     arr-flatten "^1.1.0"
 121 |     array-unique "^0.3.2"
 122 |     extend-shallow "^2.0.1"
 123 |     fill-range "^4.0.0"
 124 |     isobject "^3.0.1"
 125 |     repeat-element "^1.1.2"
 126 |     snapdragon "^0.8.1"
 127 |     snapdragon-node "^2.0.1"
 128 |     split-string "^3.0.2"
 129 |     to-regex "^3.0.1"
 130 | 
 131 | cache-base@^1.0.1:
 132 |   version "1.0.1"
 133 |   resolved "https://registry.yarnpkg.com/cache-base/-/cache-base-1.0.1.tgz#0a7f46416831c8b662ee36fe4e7c59d76f666ab2"
 134 |   integrity sha512-AKcdTnFSWATd5/GCPRxr2ChwIJ85CeyrEyjRHlKxQ56d4XJMGym0uAiKn0xbLOGOl3+yRpOTi484dVCEc5AUzQ==
 135 |   dependencies:
 136 |     collection-visit "^1.0.0"
 137 |     component-emitter "^1.2.1"
 138 |     get-value "^2.0.6"
 139 |     has-value "^1.0.0"
 140 |     isobject "^3.0.1"
 141 |     set-value "^2.0.0"
 142 |     to-object-path "^0.3.0"
 143 |     union-value "^1.0.0"
 144 |     unset-value "^1.0.0"
 145 | 
 146 | chalk@~0.4.0:
 147 |   version "0.4.0"
 148 |   resolved "https://registry.yarnpkg.com/chalk/-/chalk-0.4.0.tgz#5199a3ddcd0c1efe23bc08c1b027b06176e0c64f"
 149 |   integrity sha1-UZmj3c0MHv4jvAjBsCewYXbgxk8=
 150 |   dependencies:
 151 |     ansi-styles "~1.0.0"
 152 |     has-color "~0.1.0"
 153 |     strip-ansi "~0.1.0"
 154 | 
 155 | chalk@~4.1.0:
 156 |   version "4.1.0"
 157 |   resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.0.tgz#4e14870a618d9e2edd97dd8345fd9d9dc315646a"
 158 |   integrity sha512-qwx12AxXe2Q5xQ43Ac//I6v5aXTipYrSESdOgzrN+9XjgEpyjpKuvSGaN4qE93f7TQTlerQQ8S+EQ0EyDoVL1A==
 159 |   dependencies:
 160 |     ansi-styles "^4.1.0"
 161 |     supports-color "^7.1.0"
 162 | 
 163 | cjson@0.3.0:
 164 |   version "0.3.0"
 165 |   resolved "https://registry.yarnpkg.com/cjson/-/cjson-0.3.0.tgz#e6439b90703d312ff6e2224097bea92ce3d02a14"
 166 |   integrity sha1-5kObkHA9MS/24iJAl76pLOPQKhQ=
 167 |   dependencies:
 168 |     jsonlint "1.6.0"
 169 | 
 170 | class-utils@^0.3.5:
 171 |   version "0.3.6"
 172 |   resolved "https://registry.yarnpkg.com/class-utils/-/class-utils-0.3.6.tgz#f93369ae8b9a7ce02fd41faad0ca83033190c463"
 173 |   integrity sha512-qOhPa/Fj7s6TY8H8esGu5QNpMMQxz79h+urzrNYN6mn+9BnxlDGf5QZ+XeCDsxSjPqsSR56XOZOJmpeurnLMeg==
 174 |   dependencies:
 175 |     arr-union "^3.1.0"
 176 |     define-property "^0.2.5"
 177 |     isobject "^3.0.0"
 178 |     static-extend "^0.1.1"
 179 | 
 180 | collection-visit@^1.0.0:
 181 |   version "1.0.0"
 182 |   resolved "https://registry.yarnpkg.com/collection-visit/-/collection-visit-1.0.0.tgz#4bc0373c164bc3291b4d368c829cf1a80a59dca0"
 183 |   integrity sha1-S8A3PBZLwykbTTaMgpzxqApZ3KA=
 184 |   dependencies:
 185 |     map-visit "^1.0.0"
 186 |     object-visit "^1.0.0"
 187 | 
 188 | color-convert@^2.0.1:
 189 |   version "2.0.1"
 190 |   resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-2.0.1.tgz#72d3a68d598c9bdb3af2ad1e84f21d896abd4de3"
 191 |   integrity sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==
 192 |   dependencies:
 193 |     color-name "~1.1.4"
 194 | 
 195 | color-name@~1.1.4:
 196 |   version "1.1.4"
 197 |   resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.4.tgz#c2a09a87acbde69543de6f63fa3995c826c536a2"
 198 |   integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==
 199 | 
 200 | colors@0.5.x:
 201 |   version "0.5.1"
 202 |   resolved "https://registry.yarnpkg.com/colors/-/colors-0.5.1.tgz#7d0023eaeb154e8ee9fce75dcb923d0ed1667774"
 203 |   integrity sha1-fQAj6usVTo7p/Oddy5I9DtFmd3Q=
 204 | 
 205 | colors@~1.1.2:
 206 |   version "1.1.2"
 207 |   resolved "https://registry.yarnpkg.com/colors/-/colors-1.1.2.tgz#168a4701756b6a7f51a12ce0c97bfa28c084ed63"
 208 |   integrity sha1-FopHAXVran9RoSzgyXv6KMCE7WM=
 209 | 
 210 | commander@7.1.0:
 211 |   version "7.1.0"
 212 |   resolved "https://registry.yarnpkg.com/commander/-/commander-7.1.0.tgz#f2eaecf131f10e36e07d894698226e36ae0eb5ff"
 213 |   integrity sha512-pRxBna3MJe6HKnBGsDyMv8ETbptw3axEdYHoqNh7gu5oDcew8fs0xnivZGm06Ogk8zGAJ9VX+OPEr2GXEQK4dg==
 214 | 
 215 | component-emitter@^1.2.1:
 216 |   version "1.3.0"
 217 |   resolved "https://registry.yarnpkg.com/component-emitter/-/component-emitter-1.3.0.tgz#16e4070fba8ae29b679f2215853ee181ab2eabc0"
 218 |   integrity sha512-Rd3se6QB+sO1TwqZjscQrurpEPIfO0/yYnSin6Q/rD3mOutHvUrCAhJub3r90uNb+SESBuE0QYoB90YdfatsRg==
 219 | 
 220 | concat-map@0.0.1:
 221 |   version "0.0.1"
 222 |   resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b"
 223 |   integrity sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=
 224 | 
 225 | copy-descriptor@^0.1.0:
 226 |   version "0.1.1"
 227 |   resolved "https://registry.yarnpkg.com/copy-descriptor/-/copy-descriptor-0.1.1.tgz#676f6eb3c39997c2ee1ac3a924fd6124748f578d"
 228 |   integrity sha1-Z29us8OZl8LuGsOpJP1hJHSPV40=
 229 | 
 230 | dateformat@~3.0.3:
 231 |   version "3.0.3"
 232 |   resolved "https://registry.yarnpkg.com/dateformat/-/dateformat-3.0.3.tgz#a6e37499a4d9a9cf85ef5872044d62901c9889ae"
 233 |   integrity sha512-jyCETtSl3VMZMWeRo7iY1FL19ges1t55hMo5yaam4Jrsm5EPL89UQkoQRyiI+Yf4k8r2ZpdngkV8hr1lIdjb3Q==
 234 | 
 235 | debug@^2.2.0, debug@^2.3.3:
 236 |   version "2.6.9"
 237 |   resolved "https://registry.yarnpkg.com/debug/-/debug-2.6.9.tgz#5d128515df134ff327e90a4c93f4e077a536341f"
 238 |   integrity sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==
 239 |   dependencies:
 240 |     ms "2.0.0"
 241 | 
 242 | decode-uri-component@^0.2.0:
 243 |   version "0.2.0"
 244 |   resolved "https://registry.yarnpkg.com/decode-uri-component/-/decode-uri-component-0.2.0.tgz#eb3913333458775cb84cd1a1fae062106bb87545"
 245 |   integrity sha1-6zkTMzRYd1y4TNGh+uBiEGu4dUU=
 246 | 
 247 | define-property@^0.2.5:
 248 |   version "0.2.5"
 249 |   resolved "https://registry.yarnpkg.com/define-property/-/define-property-0.2.5.tgz#c35b1ef918ec3c990f9a5bc57be04aacec5c8116"
 250 |   integrity sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=
 251 |   dependencies:
 252 |     is-descriptor "^0.1.0"
 253 | 
 254 | define-property@^1.0.0:
 255 |   version "1.0.0"
 256 |   resolved "https://registry.yarnpkg.com/define-property/-/define-property-1.0.0.tgz#769ebaaf3f4a63aad3af9e8d304c9bbe79bfb0e6"
 257 |   integrity sha1-dp66rz9KY6rTr56NMEybvnm/sOY=
 258 |   dependencies:
 259 |     is-descriptor "^1.0.0"
 260 | 
 261 | define-property@^2.0.2:
 262 |   version "2.0.2"
 263 |   resolved "https://registry.yarnpkg.com/define-property/-/define-property-2.0.2.tgz#d459689e8d654ba77e02a817f8710d702cb16e9d"
 264 |   integrity sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ==
 265 |   dependencies:
 266 |     is-descriptor "^1.0.2"
 267 |     isobject "^3.0.1"
 268 | 
 269 | detect-file@^1.0.0:
 270 |   version "1.0.0"
 271 |   resolved "https://registry.yarnpkg.com/detect-file/-/detect-file-1.0.0.tgz#f0d66d03672a825cb1b73bdb3fe62310c8e552b7"
 272 |   integrity sha1-8NZtA2cqglyxtzvbP+YjEMjlUrc=
 273 | 
 274 | ebnf-parser@0.1.10:
 275 |   version "0.1.10"
 276 |   resolved "https://registry.yarnpkg.com/ebnf-parser/-/ebnf-parser-0.1.10.tgz#cd1f6ba477c5638c40c97ed9b572db5bab5d8331"
 277 |   integrity sha1-zR9rpHfFY4xAyX7ZtXLbW6tdgzE=
 278 | 
 279 | escodegen@1.3.x:
 280 |   version "1.3.3"
 281 |   resolved "https://registry.yarnpkg.com/escodegen/-/escodegen-1.3.3.tgz#f024016f5a88e046fd12005055e939802e6c5f23"
 282 |   integrity sha1-8CQBb1qI4Eb9EgBQVek5gC5sXyM=
 283 |   dependencies:
 284 |     esprima "~1.1.1"
 285 |     estraverse "~1.5.0"
 286 |     esutils "~1.0.0"
 287 |   optionalDependencies:
 288 |     source-map "~0.1.33"
 289 | 
 290 | esprima@1.1.x, esprima@~1.1.1:
 291 |   version "1.1.1"
 292 |   resolved "https://registry.yarnpkg.com/esprima/-/esprima-1.1.1.tgz#5b6f1547f4d102e670e140c509be6771d6aeb549"
 293 |   integrity sha1-W28VR/TRAuZw4UDFCb5ncdautUk=
 294 | 
 295 | esprima@^4.0.0:
 296 |   version "4.0.1"
 297 |   resolved "https://registry.yarnpkg.com/esprima/-/esprima-4.0.1.tgz#13b04cdb3e6c5d19df91ab6987a8695619b0aa71"
 298 |   integrity sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==
 299 | 
 300 | estraverse@~1.5.0:
 301 |   version "1.5.1"
 302 |   resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-1.5.1.tgz#867a3e8e58a9f84618afb6c2ddbcd916b7cbaf71"
 303 |   integrity sha1-hno+jlip+EYYr7bC3bzZFrfLr3E=
 304 | 
 305 | esutils@~1.0.0:
 306 |   version "1.0.0"
 307 |   resolved "https://registry.yarnpkg.com/esutils/-/esutils-1.0.0.tgz#8151d358e20c8acc7fb745e7472c0025fe496570"
 308 |   integrity sha1-gVHTWOIMisx/t0XnRywAJf5JZXA=
 309 | 
 310 | eventemitter2@~0.4.13:
 311 |   version "0.4.14"
 312 |   resolved "https://registry.yarnpkg.com/eventemitter2/-/eventemitter2-0.4.14.tgz#8f61b75cde012b2e9eb284d4545583b5643b61ab"
 313 |   integrity sha1-j2G3XN4BKy6esoTUVFWDtWQ7Yas=
 314 | 
 315 | exit@~0.1.1, exit@~0.1.2:
 316 |   version "0.1.2"
 317 |   resolved "https://registry.yarnpkg.com/exit/-/exit-0.1.2.tgz#0632638f8d877cc82107d30a0fff1a17cba1cd0c"
 318 |   integrity sha1-BjJjj42HfMghB9MKD/8aF8uhzQw=
 319 | 
 320 | expand-brackets@^2.1.4:
 321 |   version "2.1.4"
 322 |   resolved "https://registry.yarnpkg.com/expand-brackets/-/expand-brackets-2.1.4.tgz#b77735e315ce30f6b6eff0f83b04151a22449622"
 323 |   integrity sha1-t3c14xXOMPa27/D4OwQVGiJEliI=
 324 |   dependencies:
 325 |     debug "^2.3.3"
 326 |     define-property "^0.2.5"
 327 |     extend-shallow "^2.0.1"
 328 |     posix-character-classes "^0.1.0"
 329 |     regex-not "^1.0.0"
 330 |     snapdragon "^0.8.1"
 331 |     to-regex "^3.0.1"
 332 | 
 333 | expand-tilde@^2.0.0, expand-tilde@^2.0.2:
 334 |   version "2.0.2"
 335 |   resolved "https://registry.yarnpkg.com/expand-tilde/-/expand-tilde-2.0.2.tgz#97e801aa052df02454de46b02bf621642cdc8502"
 336 |   integrity sha1-l+gBqgUt8CRU3kawK/YhZCzchQI=
 337 |   dependencies:
 338 |     homedir-polyfill "^1.0.1"
 339 | 
 340 | extend-shallow@^2.0.1:
 341 |   version "2.0.1"
 342 |   resolved "https://registry.yarnpkg.com/extend-shallow/-/extend-shallow-2.0.1.tgz#51af7d614ad9a9f610ea1bafbb989d6b1c56890f"
 343 |   integrity sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=
 344 |   dependencies:
 345 |     is-extendable "^0.1.0"
 346 | 
 347 | extend-shallow@^3.0.0, extend-shallow@^3.0.2:
 348 |   version "3.0.2"
 349 |   resolved "https://registry.yarnpkg.com/extend-shallow/-/extend-shallow-3.0.2.tgz#26a71aaf073b39fb2127172746131c2704028db8"
 350 |   integrity sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=
 351 |   dependencies:
 352 |     assign-symbols "^1.0.0"
 353 |     is-extendable "^1.0.1"
 354 | 
 355 | extend@^3.0.0:
 356 |   version "3.0.2"
 357 |   resolved "https://registry.yarnpkg.com/extend/-/extend-3.0.2.tgz#f8b1136b4071fbd8eb140aff858b1019ec2915fa"
 358 |   integrity sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==
 359 | 
 360 | extglob@^2.0.4:
 361 |   version "2.0.4"
 362 |   resolved "https://registry.yarnpkg.com/extglob/-/extglob-2.0.4.tgz#ad00fe4dc612a9232e8718711dc5cb5ab0285543"
 363 |   integrity sha512-Nmb6QXkELsuBr24CJSkilo6UHHgbekK5UiZgfE6UHD3Eb27YC6oD+bhcT+tJ6cl8dmsgdQxnWlcry8ksBIBLpw==
 364 |   dependencies:
 365 |     array-unique "^0.3.2"
 366 |     define-property "^1.0.0"
 367 |     expand-brackets "^2.1.4"
 368 |     extend-shallow "^2.0.1"
 369 |     fragment-cache "^0.2.1"
 370 |     regex-not "^1.0.0"
 371 |     snapdragon "^0.8.1"
 372 |     to-regex "^3.0.1"
 373 | 
 374 | fill-range@^4.0.0:
 375 |   version "4.0.0"
 376 |   resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-4.0.0.tgz#d544811d428f98eb06a63dc402d2403c328c38f7"
 377 |   integrity sha1-1USBHUKPmOsGpj3EAtJAPDKMOPc=
 378 |   dependencies:
 379 |     extend-shallow "^2.0.1"
 380 |     is-number "^3.0.0"
 381 |     repeat-string "^1.6.1"
 382 |     to-regex-range "^2.1.0"
 383 | 
 384 | findup-sync@^2.0.0:
 385 |   version "2.0.0"
 386 |   resolved "https://registry.yarnpkg.com/findup-sync/-/findup-sync-2.0.0.tgz#9326b1488c22d1a6088650a86901b2d9a90a2cbc"
 387 |   integrity sha1-kyaxSIwi0aYIhlCoaQGy2akKLLw=
 388 |   dependencies:
 389 |     detect-file "^1.0.0"
 390 |     is-glob "^3.1.0"
 391 |     micromatch "^3.0.4"
 392 |     resolve-dir "^1.0.1"
 393 | 
 394 | findup-sync@~0.3.0:
 395 |   version "0.3.0"
 396 |   resolved "https://registry.yarnpkg.com/findup-sync/-/findup-sync-0.3.0.tgz#37930aa5d816b777c03445e1966cc6790a4c0b16"
 397 |   integrity sha1-N5MKpdgWt3fANEXhlmzGeQpMCxY=
 398 |   dependencies:
 399 |     glob "~5.0.0"
 400 | 
 401 | fined@^1.0.1:
 402 |   version "1.2.0"
 403 |   resolved "https://registry.yarnpkg.com/fined/-/fined-1.2.0.tgz#d00beccf1aa2b475d16d423b0238b713a2c4a37b"
 404 |   integrity sha512-ZYDqPLGxDkDhDZBjZBb+oD1+j0rA4E0pXY50eplAAOPg2N/gUBSSk5IM1/QhPfyVo19lJ+CvXpqfvk+b2p/8Ng==
 405 |   dependencies:
 406 |     expand-tilde "^2.0.2"
 407 |     is-plain-object "^2.0.3"
 408 |     object.defaults "^1.1.0"
 409 |     object.pick "^1.2.0"
 410 |     parse-filepath "^1.0.1"
 411 | 
 412 | flagged-respawn@^1.0.0:
 413 |   version "1.0.1"
 414 |   resolved "https://registry.yarnpkg.com/flagged-respawn/-/flagged-respawn-1.0.1.tgz#e7de6f1279ddd9ca9aac8a5971d618606b3aab41"
 415 |   integrity sha512-lNaHNVymajmk0OJMBn8fVUAU1BtDeKIqKoVhk4xAALB57aALg6b4W0MfJ/cUE0g9YBXy5XhSlPIpYIJ7HaY/3Q==
 416 | 
 417 | for-in@^1.0.1, for-in@^1.0.2:
 418 |   version "1.0.2"
 419 |   resolved "https://registry.yarnpkg.com/for-in/-/for-in-1.0.2.tgz#81068d295a8142ec0ac726c6e2200c30fb6d5e80"
 420 |   integrity sha1-gQaNKVqBQuwKxybG4iAMMPttXoA=
 421 | 
 422 | for-own@^1.0.0:
 423 |   version "1.0.0"
 424 |   resolved "https://registry.yarnpkg.com/for-own/-/for-own-1.0.0.tgz#c63332f415cedc4b04dbfe70cf836494c53cb44b"
 425 |   integrity sha1-xjMy9BXO3EsE2/5wz4NklMU8tEs=
 426 |   dependencies:
 427 |     for-in "^1.0.1"
 428 | 
 429 | fragment-cache@^0.2.1:
 430 |   version "0.2.1"
 431 |   resolved "https://registry.yarnpkg.com/fragment-cache/-/fragment-cache-0.2.1.tgz#4290fad27f13e89be7f33799c6bc5a0abfff0d19"
 432 |   integrity sha1-QpD60n8T6Jvn8zeZxrxaCr//DRk=
 433 |   dependencies:
 434 |     map-cache "^0.2.2"
 435 | 
 436 | fs.realpath@^1.0.0:
 437 |   version "1.0.0"
 438 |   resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f"
 439 |   integrity sha1-FQStJSMVjKpA20onh8sBQRmU6k8=
 440 | 
 441 | function-bind@^1.1.1:
 442 |   version "1.1.1"
 443 |   resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.1.tgz#a56899d3ea3c9bab874bb9773b7c5ede92f4895d"
 444 |   integrity sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==
 445 | 
 446 | get-value@^2.0.3, get-value@^2.0.6:
 447 |   version "2.0.6"
 448 |   resolved "https://registry.yarnpkg.com/get-value/-/get-value-2.0.6.tgz#dc15ca1c672387ca76bd37ac0a395ba2042a2c28"
 449 |   integrity sha1-3BXKHGcjh8p2vTesCjlbogQqLCg=
 450 | 
 451 | getobject@~0.1.0:
 452 |   version "0.1.0"
 453 |   resolved "https://registry.yarnpkg.com/getobject/-/getobject-0.1.0.tgz#047a449789fa160d018f5486ed91320b6ec7885c"
 454 |   integrity sha1-BHpEl4n6Fg0Bj1SG7ZEyC27HiFw=
 455 | 
 456 | glob@^7.1.3, glob@~7.1.6:
 457 |   version "7.1.6"
 458 |   resolved "https://registry.yarnpkg.com/glob/-/glob-7.1.6.tgz#141f33b81a7c2492e125594307480c46679278a6"
 459 |   integrity sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==
 460 |   dependencies:
 461 |     fs.realpath "^1.0.0"
 462 |     inflight "^1.0.4"
 463 |     inherits "2"
 464 |     minimatch "^3.0.4"
 465 |     once "^1.3.0"
 466 |     path-is-absolute "^1.0.0"
 467 | 
 468 | glob@~5.0.0:
 469 |   version "5.0.15"
 470 |   resolved "https://registry.yarnpkg.com/glob/-/glob-5.0.15.tgz#1bc936b9e02f4a603fcc222ecf7633d30b8b93b1"
 471 |   integrity sha1-G8k2ueAvSmA/zCIuz3Yz0wuLk7E=
 472 |   dependencies:
 473 |     inflight "^1.0.4"
 474 |     inherits "2"
 475 |     minimatch "2 || 3"
 476 |     once "^1.3.0"
 477 |     path-is-absolute "^1.0.0"
 478 | 
 479 | global-modules@^1.0.0:
 480 |   version "1.0.0"
 481 |   resolved "https://registry.yarnpkg.com/global-modules/-/global-modules-1.0.0.tgz#6d770f0eb523ac78164d72b5e71a8877265cc3ea"
 482 |   integrity sha512-sKzpEkf11GpOFuw0Zzjzmt4B4UZwjOcG757PPvrfhxcLFbq0wpsgpOqxpxtxFiCG4DtG93M6XRVbF2oGdev7bg==
 483 |   dependencies:
 484 |     global-prefix "^1.0.1"
 485 |     is-windows "^1.0.1"
 486 |     resolve-dir "^1.0.0"
 487 | 
 488 | global-prefix@^1.0.1:
 489 |   version "1.0.2"
 490 |   resolved "https://registry.yarnpkg.com/global-prefix/-/global-prefix-1.0.2.tgz#dbf743c6c14992593c655568cb66ed32c0122ebe"
 491 |   integrity sha1-2/dDxsFJklk8ZVVoy2btMsASLr4=
 492 |   dependencies:
 493 |     expand-tilde "^2.0.2"
 494 |     homedir-polyfill "^1.0.1"
 495 |     ini "^1.3.4"
 496 |     is-windows "^1.0.1"
 497 |     which "^1.2.14"
 498 | 
 499 | globalyzer@0.1.0:
 500 |   version "0.1.0"
 501 |   resolved "https://registry.yarnpkg.com/globalyzer/-/globalyzer-0.1.0.tgz#cb76da79555669a1519d5a8edf093afaa0bf1465"
 502 |   integrity sha512-40oNTM9UfG6aBmuKxk/giHn5nQ8RVz/SS4Ir6zgzOv9/qC3kKZ9v4etGTcJbEl/NyVQH7FGU7d+X1egr57Md2Q==
 503 | 
 504 | globrex@^0.1.2:
 505 |   version "0.1.2"
 506 |   resolved "https://registry.yarnpkg.com/globrex/-/globrex-0.1.2.tgz#dd5d9ec826232730cd6793a5e33a9302985e6098"
 507 |   integrity sha512-uHJgbwAMwNFf5mLst7IWLNg14x1CkeqglJb/K3doi4dw6q2IvAAmM/Y81kevy83wP+Sst+nutFTYOGg3d1lsxg==
 508 | 
 509 | grunt-cli@~1.3.2:
 510 |   version "1.3.2"
 511 |   resolved "https://registry.yarnpkg.com/grunt-cli/-/grunt-cli-1.3.2.tgz#60f12d12c1b5aae94ae3469c6b5fe24e960014e8"
 512 |   integrity sha512-8OHDiZZkcptxVXtMfDxJvmN7MVJNE8L/yIcPb4HB7TlyFD1kDvjHrb62uhySsU14wJx9ORMnTuhRMQ40lH/orQ==
 513 |   dependencies:
 514 |     grunt-known-options "~1.1.0"
 515 |     interpret "~1.1.0"
 516 |     liftoff "~2.5.0"
 517 |     nopt "~4.0.1"
 518 |     v8flags "~3.1.1"
 519 | 
 520 | grunt-contrib-concat@~0.1.3:
 521 |   version "0.1.3"
 522 |   resolved "https://registry.yarnpkg.com/grunt-contrib-concat/-/grunt-contrib-concat-0.1.3.tgz#df9a1a9bc8d75fcd00794b3d0f6d8ae8278523ac"
 523 |   integrity sha1-35oam8jXX80AeUs9D22K6CeFI6w=
 524 | 
 525 | grunt-execute@~0.1.5:
 526 |   version "0.1.5"
 527 |   resolved "https://registry.yarnpkg.com/grunt-execute/-/grunt-execute-0.1.5.tgz#c97eb8943612fefbb72fbe3d32ef95233c5fa2e9"
 528 |   integrity sha1-yX64lDYS/vu3L749Mu+VIzxfouk=
 529 | 
 530 | grunt-known-options@~1.1.0:
 531 |   version "1.1.1"
 532 |   resolved "https://registry.yarnpkg.com/grunt-known-options/-/grunt-known-options-1.1.1.tgz#6cc088107bd0219dc5d3e57d91923f469059804d"
 533 |   integrity sha512-cHwsLqoighpu7TuYj5RonnEuxGVFnztcUqTqp5rXFGYL4OuPFofwC4Ycg7n9fYwvK6F5WbYgeVOwph9Crs2fsQ==
 534 | 
 535 | grunt-legacy-log-utils@~2.1.0:
 536 |   version "2.1.0"
 537 |   resolved "https://registry.yarnpkg.com/grunt-legacy-log-utils/-/grunt-legacy-log-utils-2.1.0.tgz#49a8c7dc74051476dcc116c32faf9db8646856ef"
 538 |   integrity sha512-lwquaPXJtKQk0rUM1IQAop5noEpwFqOXasVoedLeNzaibf/OPWjKYvvdqnEHNmU+0T0CaReAXIbGo747ZD+Aaw==
 539 |   dependencies:
 540 |     chalk "~4.1.0"
 541 |     lodash "~4.17.19"
 542 | 
 543 | grunt-legacy-log@~3.0.0:
 544 |   version "3.0.0"
 545 |   resolved "https://registry.yarnpkg.com/grunt-legacy-log/-/grunt-legacy-log-3.0.0.tgz#1c6eaf92371ea415af31ea84ce50d434ef6d39c4"
 546 |   integrity sha512-GHZQzZmhyq0u3hr7aHW4qUH0xDzwp2YXldLPZTCjlOeGscAOWWPftZG3XioW8MasGp+OBRIu39LFx14SLjXRcA==
 547 |   dependencies:
 548 |     colors "~1.1.2"
 549 |     grunt-legacy-log-utils "~2.1.0"
 550 |     hooker "~0.2.3"
 551 |     lodash "~4.17.19"
 552 | 
 553 | grunt-legacy-util@~2.0.0:
 554 |   version "2.0.0"
 555 |   resolved "https://registry.yarnpkg.com/grunt-legacy-util/-/grunt-legacy-util-2.0.0.tgz#34d20f2a26c6adebfe9a9bdc8823f7016b0369c3"
 556 |   integrity sha512-ZEmYFB44bblwPE2oz3q3ygfF6hseQja9tx8I3UZIwbUik32FMWewA+d1qSFicMFB+8dNXDkh35HcDCWlpRsGlA==
 557 |   dependencies:
 558 |     async "~1.5.2"
 559 |     exit "~0.1.1"
 560 |     getobject "~0.1.0"
 561 |     hooker "~0.2.3"
 562 |     lodash "~4.17.20"
 563 |     underscore.string "~3.3.5"
 564 |     which "~1.3.0"
 565 | 
 566 | grunt@^1.0.3:
 567 |   version "1.3.0"
 568 |   resolved "https://registry.yarnpkg.com/grunt/-/grunt-1.3.0.tgz#55db6ccd80c6fb53722e496f680620a2e681f809"
 569 |   integrity sha512-6ILlMXv11/4cxuhSMfSU+SfvbxrPuqZrAtLN64+tZpQ3DAKfSQPQHRbTjSbdtxfyQhGZPtN0bDZJ/LdCM5WXXA==
 570 |   dependencies:
 571 |     dateformat "~3.0.3"
 572 |     eventemitter2 "~0.4.13"
 573 |     exit "~0.1.2"
 574 |     findup-sync "~0.3.0"
 575 |     glob "~7.1.6"
 576 |     grunt-cli "~1.3.2"
 577 |     grunt-known-options "~1.1.0"
 578 |     grunt-legacy-log "~3.0.0"
 579 |     grunt-legacy-util "~2.0.0"
 580 |     iconv-lite "~0.4.13"
 581 |     js-yaml "~3.14.0"
 582 |     minimatch "~3.0.4"
 583 |     mkdirp "~1.0.4"
 584 |     nopt "~3.0.6"
 585 |     rimraf "~3.0.2"
 586 | 
 587 | has-color@~0.1.0:
 588 |   version "0.1.7"
 589 |   resolved "https://registry.yarnpkg.com/has-color/-/has-color-0.1.7.tgz#67144a5260c34fc3cca677d041daf52fe7b78b2f"
 590 |   integrity sha1-ZxRKUmDDT8PMpnfQQdr1L+e3iy8=
 591 | 
 592 | has-flag@^4.0.0:
 593 |   version "4.0.0"
 594 |   resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-4.0.0.tgz#944771fd9c81c81265c4d6941860da06bb59479b"
 595 |   integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==
 596 | 
 597 | has-value@^0.3.1:
 598 |   version "0.3.1"
 599 |   resolved "https://registry.yarnpkg.com/has-value/-/has-value-0.3.1.tgz#7b1f58bada62ca827ec0a2078025654845995e1f"
 600 |   integrity sha1-ex9YutpiyoJ+wKIHgCVlSEWZXh8=
 601 |   dependencies:
 602 |     get-value "^2.0.3"
 603 |     has-values "^0.1.4"
 604 |     isobject "^2.0.0"
 605 | 
 606 | has-value@^1.0.0:
 607 |   version "1.0.0"
 608 |   resolved "https://registry.yarnpkg.com/has-value/-/has-value-1.0.0.tgz#18b281da585b1c5c51def24c930ed29a0be6b177"
 609 |   integrity sha1-GLKB2lhbHFxR3vJMkw7SmgvmsXc=
 610 |   dependencies:
 611 |     get-value "^2.0.6"
 612 |     has-values "^1.0.0"
 613 |     isobject "^3.0.0"
 614 | 
 615 | has-values@^0.1.4:
 616 |   version "0.1.4"
 617 |   resolved "https://registry.yarnpkg.com/has-values/-/has-values-0.1.4.tgz#6d61de95d91dfca9b9a02089ad384bff8f62b771"
 618 |   integrity sha1-bWHeldkd/Km5oCCJrThL/49it3E=
 619 | 
 620 | has-values@^1.0.0:
 621 |   version "1.0.0"
 622 |   resolved "https://registry.yarnpkg.com/has-values/-/has-values-1.0.0.tgz#95b0b63fec2146619a6fe57fe75628d5a39efe4f"
 623 |   integrity sha1-lbC2P+whRmGab+V/51Yo1aOe/k8=
 624 |   dependencies:
 625 |     is-number "^3.0.0"
 626 |     kind-of "^4.0.0"
 627 | 
 628 | has@^1.0.3:
 629 |   version "1.0.3"
 630 |   resolved "https://registry.yarnpkg.com/has/-/has-1.0.3.tgz#722d7cbfc1f6aa8241f16dd814e011e1f41e8796"
 631 |   integrity sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==
 632 |   dependencies:
 633 |     function-bind "^1.1.1"
 634 | 
 635 | homedir-polyfill@^1.0.1:
 636 |   version "1.0.3"
 637 |   resolved "https://registry.yarnpkg.com/homedir-polyfill/-/homedir-polyfill-1.0.3.tgz#743298cef4e5af3e194161fbadcc2151d3a058e8"
 638 |   integrity sha512-eSmmWE5bZTK2Nou4g0AI3zZ9rswp7GRKoKXS1BLUkvPviOqs4YTN1djQIqrXy9k5gEtdLPy86JjRwsNM9tnDcA==
 639 |   dependencies:
 640 |     parse-passwd "^1.0.0"
 641 | 
 642 | hooker@~0.2.3:
 643 |   version "0.2.3"
 644 |   resolved "https://registry.yarnpkg.com/hooker/-/hooker-0.2.3.tgz#b834f723cc4a242aa65963459df6d984c5d3d959"
 645 |   integrity sha1-uDT3I8xKJCqmWWNFnfbZhMXT2Vk=
 646 | 
 647 | iconv-lite@~0.4.13:
 648 |   version "0.4.24"
 649 |   resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.4.24.tgz#2022b4b25fbddc21d2f524974a474aafe733908b"
 650 |   integrity sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==
 651 |   dependencies:
 652 |     safer-buffer ">= 2.1.2 < 3"
 653 | 
 654 | inflight@^1.0.4:
 655 |   version "1.0.6"
 656 |   resolved "https://registry.yarnpkg.com/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9"
 657 |   integrity sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=
 658 |   dependencies:
 659 |     once "^1.3.0"
 660 |     wrappy "1"
 661 | 
 662 | inherits@2:
 663 |   version "2.0.4"
 664 |   resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c"
 665 |   integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
 666 | 
 667 | ini@^1.3.4:
 668 |   version "1.3.8"
 669 |   resolved "https://registry.yarnpkg.com/ini/-/ini-1.3.8.tgz#a29da425b48806f34767a4efce397269af28432c"
 670 |   integrity sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==
 671 | 
 672 | interpret@~1.1.0:
 673 |   version "1.1.0"
 674 |   resolved "https://registry.yarnpkg.com/interpret/-/interpret-1.1.0.tgz#7ed1b1410c6a0e0f78cf95d3b8440c63f78b8614"
 675 |   integrity sha1-ftGxQQxqDg94z5XTuEQMY/eLhhQ=
 676 | 
 677 | is-absolute@^1.0.0:
 678 |   version "1.0.0"
 679 |   resolved "https://registry.yarnpkg.com/is-absolute/-/is-absolute-1.0.0.tgz#395e1ae84b11f26ad1795e73c17378e48a301576"
 680 |   integrity sha512-dOWoqflvcydARa360Gvv18DZ/gRuHKi2NU/wU5X1ZFzdYfH29nkiNZsF3mp4OJ3H4yo9Mx8A/uAGNzpzPN3yBA==
 681 |   dependencies:
 682 |     is-relative "^1.0.0"
 683 |     is-windows "^1.0.1"
 684 | 
 685 | is-accessor-descriptor@^0.1.6:
 686 |   version "0.1.6"
 687 |   resolved "https://registry.yarnpkg.com/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz#a9e12cb3ae8d876727eeef3843f8a0897b5c98d6"
 688 |   integrity sha1-qeEss66Nh2cn7u84Q/igiXtcmNY=
 689 |   dependencies:
 690 |     kind-of "^3.0.2"
 691 | 
 692 | is-accessor-descriptor@^1.0.0:
 693 |   version "1.0.0"
 694 |   resolved "https://registry.yarnpkg.com/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz#169c2f6d3df1f992618072365c9b0ea1f6878656"
 695 |   integrity sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==
 696 |   dependencies:
 697 |     kind-of "^6.0.0"
 698 | 
 699 | is-buffer@^1.1.5:
 700 |   version "1.1.6"
 701 |   resolved "https://registry.yarnpkg.com/is-buffer/-/is-buffer-1.1.6.tgz#efaa2ea9daa0d7ab2ea13a97b2b8ad51fefbe8be"
 702 |   integrity sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==
 703 | 
 704 | is-core-module@^2.2.0:
 705 |   version "2.2.0"
 706 |   resolved "https://registry.yarnpkg.com/is-core-module/-/is-core-module-2.2.0.tgz#97037ef3d52224d85163f5597b2b63d9afed981a"
 707 |   integrity sha512-XRAfAdyyY5F5cOXn7hYQDqh2Xmii+DEfIcQGxK/uNwMHhIkPWO0g8msXcbzLe+MpGoR951MlqM/2iIlU4vKDdQ==
 708 |   dependencies:
 709 |     has "^1.0.3"
 710 | 
 711 | is-data-descriptor@^0.1.4:
 712 |   version "0.1.4"
 713 |   resolved "https://registry.yarnpkg.com/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz#0b5ee648388e2c860282e793f1856fec3f301b56"
 714 |   integrity sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y=
 715 |   dependencies:
 716 |     kind-of "^3.0.2"
 717 | 
 718 | is-data-descriptor@^1.0.0:
 719 |   version "1.0.0"
 720 |   resolved "https://registry.yarnpkg.com/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz#d84876321d0e7add03990406abbbbd36ba9268c7"
 721 |   integrity sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==
 722 |   dependencies:
 723 |     kind-of "^6.0.0"
 724 | 
 725 | is-descriptor@^0.1.0:
 726 |   version "0.1.6"
 727 |   resolved "https://registry.yarnpkg.com/is-descriptor/-/is-descriptor-0.1.6.tgz#366d8240dde487ca51823b1ab9f07a10a78251ca"
 728 |   integrity sha512-avDYr0SB3DwO9zsMov0gKCESFYqCnE4hq/4z3TdUlukEy5t9C0YRq7HLrsN52NAcqXKaepeCD0n+B0arnVG3Hg==
 729 |   dependencies:
 730 |     is-accessor-descriptor "^0.1.6"
 731 |     is-data-descriptor "^0.1.4"
 732 |     kind-of "^5.0.0"
 733 | 
 734 | is-descriptor@^1.0.0, is-descriptor@^1.0.2:
 735 |   version "1.0.2"
 736 |   resolved "https://registry.yarnpkg.com/is-descriptor/-/is-descriptor-1.0.2.tgz#3b159746a66604b04f8c81524ba365c5f14d86ec"
 737 |   integrity sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==
 738 |   dependencies:
 739 |     is-accessor-descriptor "^1.0.0"
 740 |     is-data-descriptor "^1.0.0"
 741 |     kind-of "^6.0.2"
 742 | 
 743 | is-extendable@^0.1.0, is-extendable@^0.1.1:
 744 |   version "0.1.1"
 745 |   resolved "https://registry.yarnpkg.com/is-extendable/-/is-extendable-0.1.1.tgz#62b110e289a471418e3ec36a617d472e301dfc89"
 746 |   integrity sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik=
 747 | 
 748 | is-extendable@^1.0.1:
 749 |   version "1.0.1"
 750 |   resolved "https://registry.yarnpkg.com/is-extendable/-/is-extendable-1.0.1.tgz#a7470f9e426733d81bd81e1155264e3a3507cab4"
 751 |   integrity sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==
 752 |   dependencies:
 753 |     is-plain-object "^2.0.4"
 754 | 
 755 | is-extglob@^2.1.0:
 756 |   version "2.1.1"
 757 |   resolved "https://registry.yarnpkg.com/is-extglob/-/is-extglob-2.1.1.tgz#a88c02535791f02ed37c76a1b9ea9773c833f8c2"
 758 |   integrity sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=
 759 | 
 760 | is-glob@^3.1.0:
 761 |   version "3.1.0"
 762 |   resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-3.1.0.tgz#7ba5ae24217804ac70707b96922567486cc3e84a"
 763 |   integrity sha1-e6WuJCF4BKxwcHuWkiVnSGzD6Eo=
 764 |   dependencies:
 765 |     is-extglob "^2.1.0"
 766 | 
 767 | is-number@^3.0.0:
 768 |   version "3.0.0"
 769 |   resolved "https://registry.yarnpkg.com/is-number/-/is-number-3.0.0.tgz#24fd6201a4782cf50561c810276afc7d12d71195"
 770 |   integrity sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=
 771 |   dependencies:
 772 |     kind-of "^3.0.2"
 773 | 
 774 | is-plain-object@^2.0.3, is-plain-object@^2.0.4:
 775 |   version "2.0.4"
 776 |   resolved "https://registry.yarnpkg.com/is-plain-object/-/is-plain-object-2.0.4.tgz#2c163b3fafb1b606d9d17928f05c2a1c38e07677"
 777 |   integrity sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==
 778 |   dependencies:
 779 |     isobject "^3.0.1"
 780 | 
 781 | is-relative@^1.0.0:
 782 |   version "1.0.0"
 783 |   resolved "https://registry.yarnpkg.com/is-relative/-/is-relative-1.0.0.tgz#a1bb6935ce8c5dba1e8b9754b9b2dcc020e2260d"
 784 |   integrity sha512-Kw/ReK0iqwKeu0MITLFuj0jbPAmEiOsIwyIXvvbfa6QfmN9pkD1M+8pdk7Rl/dTKbH34/XBFMbgD4iMJhLQbGA==
 785 |   dependencies:
 786 |     is-unc-path "^1.0.0"
 787 | 
 788 | is-unc-path@^1.0.0:
 789 |   version "1.0.0"
 790 |   resolved "https://registry.yarnpkg.com/is-unc-path/-/is-unc-path-1.0.0.tgz#d731e8898ed090a12c352ad2eaed5095ad322c9d"
 791 |   integrity sha512-mrGpVd0fs7WWLfVsStvgF6iEJnbjDFZh9/emhRDcGWTduTfNHd9CHeUwH3gYIjdbwo4On6hunkztwOaAw0yllQ==
 792 |   dependencies:
 793 |     unc-path-regex "^0.1.2"
 794 | 
 795 | is-windows@^1.0.1, is-windows@^1.0.2:
 796 |   version "1.0.2"
 797 |   resolved "https://registry.yarnpkg.com/is-windows/-/is-windows-1.0.2.tgz#d1850eb9791ecd18e6182ce12a30f396634bb19d"
 798 |   integrity sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==
 799 | 
 800 | isarray@1.0.0:
 801 |   version "1.0.0"
 802 |   resolved "https://registry.yarnpkg.com/isarray/-/isarray-1.0.0.tgz#bb935d48582cba168c06834957a54a3e07124f11"
 803 |   integrity sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=
 804 | 
 805 | isexe@^2.0.0:
 806 |   version "2.0.0"
 807 |   resolved "https://registry.yarnpkg.com/isexe/-/isexe-2.0.0.tgz#e8fbf374dc556ff8947a10dcb0572d633f2cfa10"
 808 |   integrity sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=
 809 | 
 810 | isobject@^2.0.0:
 811 |   version "2.1.0"
 812 |   resolved "https://registry.yarnpkg.com/isobject/-/isobject-2.1.0.tgz#f065561096a3f1da2ef46272f815c840d87e0c89"
 813 |   integrity sha1-8GVWEJaj8dou9GJy+BXIQNh+DIk=
 814 |   dependencies:
 815 |     isarray "1.0.0"
 816 | 
 817 | isobject@^3.0.0, isobject@^3.0.1:
 818 |   version "3.0.1"
 819 |   resolved "https://registry.yarnpkg.com/isobject/-/isobject-3.0.1.tgz#4e431e92b11a9731636aa1f9c8d1ccbcfdab78df"
 820 |   integrity sha1-TkMekrEalzFjaqH5yNHMvP2reN8=
 821 | 
 822 | jison-lex@0.3.x:
 823 |   version "0.3.4"
 824 |   resolved "https://registry.yarnpkg.com/jison-lex/-/jison-lex-0.3.4.tgz#81ca28d84f84499dfa8c594dcde3d8a3f26ec7a5"
 825 |   integrity sha1-gcoo2E+ESZ36jFlNzePYo/Jux6U=
 826 |   dependencies:
 827 |     lex-parser "0.1.x"
 828 |     nomnom "1.5.2"
 829 | 
 830 | jison@0.4.15:
 831 |   version "0.4.15"
 832 |   resolved "https://registry.yarnpkg.com/jison/-/jison-0.4.15.tgz#6c6336c43e76b13c7ce29f96898c8bdf4e1e38fa"
 833 |   integrity sha1-bGM2xD52sTx84p+WiYyL304eOPo=
 834 |   dependencies:
 835 |     JSONSelect "0.4.0"
 836 |     cjson "0.3.0"
 837 |     ebnf-parser "0.1.10"
 838 |     escodegen "1.3.x"
 839 |     esprima "1.1.x"
 840 |     jison-lex "0.3.x"
 841 |     lex-parser "~0.1.3"
 842 |     nomnom "1.5.2"
 843 | 
 844 | js-reporters@2.0.0:
 845 |   version "2.0.0"
 846 |   resolved "https://registry.yarnpkg.com/js-reporters/-/js-reporters-2.0.0.tgz#62ad6a512f1740d3ab4686b0059dd9f57cc0708b"
 847 |   integrity sha512-VJd/86niT7GzsaVc+Yxrs8QPrYl1orzv8bYZPuSOtxU6rk/pv8aOXTcIa7HaANvtvdLMTsZspAiucNQ6T2QFHw==
 848 | 
 849 | js-yaml@~3.14.0:
 850 |   version "3.14.1"
 851 |   resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.14.1.tgz#dae812fdb3825fa306609a8717383c50c36a0537"
 852 |   integrity sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==
 853 |   dependencies:
 854 |     argparse "^1.0.7"
 855 |     esprima "^4.0.0"
 856 | 
 857 | jsonlint@1.6.0:
 858 |   version "1.6.0"
 859 |   resolved "https://registry.yarnpkg.com/jsonlint/-/jsonlint-1.6.0.tgz#88aa46bc289a7ac93bb46cae2d58a187a9bb494a"
 860 |   integrity sha1-iKpGvCiaesk7tGyuLVihh6m7SUo=
 861 |   dependencies:
 862 |     JSV ">= 4.0.x"
 863 |     nomnom ">= 1.5.x"
 864 | 
 865 | kind-of@^3.0.2, kind-of@^3.0.3, kind-of@^3.2.0:
 866 |   version "3.2.2"
 867 |   resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-3.2.2.tgz#31ea21a734bab9bbb0f32466d893aea51e4a3c64"
 868 |   integrity sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=
 869 |   dependencies:
 870 |     is-buffer "^1.1.5"
 871 | 
 872 | kind-of@^4.0.0:
 873 |   version "4.0.0"
 874 |   resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-4.0.0.tgz#20813df3d712928b207378691a45066fae72dd57"
 875 |   integrity sha1-IIE989cSkosgc3hpGkUGb65y3Vc=
 876 |   dependencies:
 877 |     is-buffer "^1.1.5"
 878 | 
 879 | kind-of@^5.0.0:
 880 |   version "5.1.0"
 881 |   resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-5.1.0.tgz#729c91e2d857b7a419a1f9aa65685c4c33f5845d"
 882 |   integrity sha512-NGEErnH6F2vUuXDh+OlbcKW7/wOcfdRHaZ7VWtqCztfHri/++YKmP51OdWeGPuqCOba6kk2OTe5d02VmTB80Pw==
 883 | 
 884 | kind-of@^6.0.0, kind-of@^6.0.2:
 885 |   version "6.0.3"
 886 |   resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-6.0.3.tgz#07c05034a6c349fa06e24fa35aa76db4580ce4dd"
 887 |   integrity sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==
 888 | 
 889 | lex-parser@0.1.x, lex-parser@~0.1.3:
 890 |   version "0.1.4"
 891 |   resolved "https://registry.yarnpkg.com/lex-parser/-/lex-parser-0.1.4.tgz#64c4f025f17fd53bfb45763faeb16f015a747550"
 892 |   integrity sha1-ZMTwJfF/1Tv7RXY/rrFvAVp0dVA=
 893 | 
 894 | liftoff@~2.5.0:
 895 |   version "2.5.0"
 896 |   resolved "https://registry.yarnpkg.com/liftoff/-/liftoff-2.5.0.tgz#2009291bb31cea861bbf10a7c15a28caf75c31ec"
 897 |   integrity sha1-IAkpG7Mc6oYbvxCnwVooyvdcMew=
 898 |   dependencies:
 899 |     extend "^3.0.0"
 900 |     findup-sync "^2.0.0"
 901 |     fined "^1.0.1"
 902 |     flagged-respawn "^1.0.0"
 903 |     is-plain-object "^2.0.4"
 904 |     object.map "^1.0.0"
 905 |     rechoir "^0.6.2"
 906 |     resolve "^1.1.7"
 907 | 
 908 | lodash@~4.17.19, lodash@~4.17.20:
 909 |   version "4.17.21"
 910 |   resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c"
 911 |   integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==
 912 | 
 913 | make-iterator@^1.0.0:
 914 |   version "1.0.1"
 915 |   resolved "https://registry.yarnpkg.com/make-iterator/-/make-iterator-1.0.1.tgz#29b33f312aa8f547c4a5e490f56afcec99133ad6"
 916 |   integrity sha512-pxiuXh0iVEq7VM7KMIhs5gxsfxCux2URptUQaXo4iZZJxBAzTPOLE2BumO5dbfVYq/hBJFBR/a1mFDmOx5AGmw==
 917 |   dependencies:
 918 |     kind-of "^6.0.2"
 919 | 
 920 | map-cache@^0.2.0, map-cache@^0.2.2:
 921 |   version "0.2.2"
 922 |   resolved "https://registry.yarnpkg.com/map-cache/-/map-cache-0.2.2.tgz#c32abd0bd6525d9b051645bb4f26ac5dc98a0dbf"
 923 |   integrity sha1-wyq9C9ZSXZsFFkW7TyasXcmKDb8=
 924 | 
 925 | map-visit@^1.0.0:
 926 |   version "1.0.0"
 927 |   resolved "https://registry.yarnpkg.com/map-visit/-/map-visit-1.0.0.tgz#ecdca8f13144e660f1b5bd41f12f3479d98dfb8f"
 928 |   integrity sha1-7Nyo8TFE5mDxtb1B8S80edmN+48=
 929 |   dependencies:
 930 |     object-visit "^1.0.0"
 931 | 
 932 | micromatch@^3.0.4:
 933 |   version "3.1.10"
 934 |   resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-3.1.10.tgz#70859bc95c9840952f359a068a3fc49f9ecfac23"
 935 |   integrity sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==
 936 |   dependencies:
 937 |     arr-diff "^4.0.0"
 938 |     array-unique "^0.3.2"
 939 |     braces "^2.3.1"
 940 |     define-property "^2.0.2"
 941 |     extend-shallow "^3.0.2"
 942 |     extglob "^2.0.4"
 943 |     fragment-cache "^0.2.1"
 944 |     kind-of "^6.0.2"
 945 |     nanomatch "^1.2.9"
 946 |     object.pick "^1.3.0"
 947 |     regex-not "^1.0.0"
 948 |     snapdragon "^0.8.1"
 949 |     to-regex "^3.0.2"
 950 | 
 951 | "minimatch@2 || 3", minimatch@^3.0.4, minimatch@~3.0.4:
 952 |   version "3.0.4"
 953 |   resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.0.4.tgz#5166e286457f03306064be5497e8dbb0c3d32083"
 954 |   integrity sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==
 955 |   dependencies:
 956 |     brace-expansion "^1.1.7"
 957 | 
 958 | mixin-deep@^1.2.0:
 959 |   version "1.3.2"
 960 |   resolved "https://registry.yarnpkg.com/mixin-deep/-/mixin-deep-1.3.2.tgz#1120b43dc359a785dce65b55b82e257ccf479566"
 961 |   integrity sha512-WRoDn//mXBiJ1H40rqa3vH0toePwSsGb45iInWlTySa+Uu4k3tYUSxa2v1KqAiLtvlrSzaExqS1gtk96A9zvEA==
 962 |   dependencies:
 963 |     for-in "^1.0.2"
 964 |     is-extendable "^1.0.1"
 965 | 
 966 | mkdirp@~1.0.4:
 967 |   version "1.0.4"
 968 |   resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-1.0.4.tgz#3eb5ed62622756d79a5f0e2a221dfebad75c2f7e"
 969 |   integrity sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==
 970 | 
 971 | ms@2.0.0:
 972 |   version "2.0.0"
 973 |   resolved "https://registry.yarnpkg.com/ms/-/ms-2.0.0.tgz#5608aeadfc00be6c2901df5f9861788de0d597c8"
 974 |   integrity sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=
 975 | 
 976 | nanomatch@^1.2.9:
 977 |   version "1.2.13"
 978 |   resolved "https://registry.yarnpkg.com/nanomatch/-/nanomatch-1.2.13.tgz#b87a8aa4fc0de8fe6be88895b38983ff265bd119"
 979 |   integrity sha512-fpoe2T0RbHwBTBUOftAfBPaDEi06ufaUai0mE6Yn1kacc3SnTErfb/h+X94VXzI64rKFHYImXSvdwGGCmwOqCA==
 980 |   dependencies:
 981 |     arr-diff "^4.0.0"
 982 |     array-unique "^0.3.2"
 983 |     define-property "^2.0.2"
 984 |     extend-shallow "^3.0.2"
 985 |     fragment-cache "^0.2.1"
 986 |     is-windows "^1.0.2"
 987 |     kind-of "^6.0.2"
 988 |     object.pick "^1.3.0"
 989 |     regex-not "^1.0.0"
 990 |     snapdragon "^0.8.1"
 991 |     to-regex "^3.0.1"
 992 | 
 993 | node-watch@0.7.1:
 994 |   version "0.7.1"
 995 |   resolved "https://registry.yarnpkg.com/node-watch/-/node-watch-0.7.1.tgz#0caaa6a6833b0d533487f953c52a6c787769ba7c"
 996 |   integrity sha512-UWblPYuZYrkCQCW5PxAwYSxaELNBLUckrTBBk8xr1/bUgyOkYYTsUcV4e3ytcazFEOyiRyiUrsG37pu6I0I05g==
 997 | 
 998 | nomnom@1.5.2:
 999 |   version "1.5.2"
1000 |   resolved "https://registry.yarnpkg.com/nomnom/-/nomnom-1.5.2.tgz#f4345448a853cfbd5c0d26320f2477ab0526fe2f"
1001 |   integrity sha1-9DRUSKhTz71cDSYyDyR3qwUm/i8=
1002 |   dependencies:
1003 |     colors "0.5.x"
1004 |     underscore "1.1.x"
1005 | 
1006 | "nomnom@>= 1.5.x":
1007 |   version "1.8.1"
1008 |   resolved "https://registry.yarnpkg.com/nomnom/-/nomnom-1.8.1.tgz#2151f722472ba79e50a76fc125bb8c8f2e4dc2a7"
1009 |   integrity sha1-IVH3Ikcrp55Qp2/BJbuMjy5Nwqc=
1010 |   dependencies:
1011 |     chalk "~0.4.0"
1012 |     underscore "~1.6.0"
1013 | 
1014 | nopt@~3.0.6:
1015 |   version "3.0.6"
1016 |   resolved "https://registry.yarnpkg.com/nopt/-/nopt-3.0.6.tgz#c6465dbf08abcd4db359317f79ac68a646b28ff9"
1017 |   integrity sha1-xkZdvwirzU2zWTF/eaxopkayj/k=
1018 |   dependencies:
1019 |     abbrev "1"
1020 | 
1021 | nopt@~4.0.1:
1022 |   version "4.0.3"
1023 |   resolved "https://registry.yarnpkg.com/nopt/-/nopt-4.0.3.tgz#a375cad9d02fd921278d954c2254d5aa57e15e48"
1024 |   integrity sha512-CvaGwVMztSMJLOeXPrez7fyfObdZqNUK1cPAEzLHrTybIua9pMdmmPR5YwtfNftIOMv3DPUhFaxsZMNTQO20Kg==
1025 |   dependencies:
1026 |     abbrev "1"
1027 |     osenv "^0.1.4"
1028 | 
1029 | object-copy@^0.1.0:
1030 |   version "0.1.0"
1031 |   resolved "https://registry.yarnpkg.com/object-copy/-/object-copy-0.1.0.tgz#7e7d858b781bd7c991a41ba975ed3812754e998c"
1032 |   integrity sha1-fn2Fi3gb18mRpBupde04EnVOmYw=
1033 |   dependencies:
1034 |     copy-descriptor "^0.1.0"
1035 |     define-property "^0.2.5"
1036 |     kind-of "^3.0.3"
1037 | 
1038 | object-visit@^1.0.0:
1039 |   version "1.0.1"
1040 |   resolved "https://registry.yarnpkg.com/object-visit/-/object-visit-1.0.1.tgz#f79c4493af0c5377b59fe39d395e41042dd045bb"
1041 |   integrity sha1-95xEk68MU3e1n+OdOV5BBC3QRbs=
1042 |   dependencies:
1043 |     isobject "^3.0.0"
1044 | 
1045 | object.defaults@^1.1.0:
1046 |   version "1.1.0"
1047 |   resolved "https://registry.yarnpkg.com/object.defaults/-/object.defaults-1.1.0.tgz#3a7f868334b407dea06da16d88d5cd29e435fecf"
1048 |   integrity sha1-On+GgzS0B96gbaFtiNXNKeQ1/s8=
1049 |   dependencies:
1050 |     array-each "^1.0.1"
1051 |     array-slice "^1.0.0"
1052 |     for-own "^1.0.0"
1053 |     isobject "^3.0.0"
1054 | 
1055 | object.map@^1.0.0:
1056 |   version "1.0.1"
1057 |   resolved "https://registry.yarnpkg.com/object.map/-/object.map-1.0.1.tgz#cf83e59dc8fcc0ad5f4250e1f78b3b81bd801d37"
1058 |   integrity sha1-z4Plncj8wK1fQlDh94s7gb2AHTc=
1059 |   dependencies:
1060 |     for-own "^1.0.0"
1061 |     make-iterator "^1.0.0"
1062 | 
1063 | object.pick@^1.2.0, object.pick@^1.3.0:
1064 |   version "1.3.0"
1065 |   resolved "https://registry.yarnpkg.com/object.pick/-/object.pick-1.3.0.tgz#87a10ac4c1694bd2e1cbf53591a66141fb5dd747"
1066 |   integrity sha1-h6EKxMFpS9Lhy/U1kaZhQftd10c=
1067 |   dependencies:
1068 |     isobject "^3.0.1"
1069 | 
1070 | once@^1.3.0:
1071 |   version "1.4.0"
1072 |   resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1"
1073 |   integrity sha1-WDsap3WWHUsROsF9nFC6753Xa9E=
1074 |   dependencies:
1075 |     wrappy "1"
1076 | 
1077 | os-homedir@^1.0.0:
1078 |   version "1.0.2"
1079 |   resolved "https://registry.yarnpkg.com/os-homedir/-/os-homedir-1.0.2.tgz#ffbc4988336e0e833de0c168c7ef152121aa7fb3"
1080 |   integrity sha1-/7xJiDNuDoM94MFox+8VISGqf7M=
1081 | 
1082 | os-tmpdir@^1.0.0:
1083 |   version "1.0.2"
1084 |   resolved "https://registry.yarnpkg.com/os-tmpdir/-/os-tmpdir-1.0.2.tgz#bbe67406c79aa85c5cfec766fe5734555dfa1274"
1085 |   integrity sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ=
1086 | 
1087 | osenv@^0.1.4:
1088 |   version "0.1.5"
1089 |   resolved "https://registry.yarnpkg.com/osenv/-/osenv-0.1.5.tgz#85cdfafaeb28e8677f416e287592b5f3f49ea410"
1090 |   integrity sha512-0CWcCECdMVc2Rw3U5w9ZjqX6ga6ubk1xDVKxtBQPK7wis/0F2r9T6k4ydGYhecl7YUBxBVxhL5oisPsNxAPe2g==
1091 |   dependencies:
1092 |     os-homedir "^1.0.0"
1093 |     os-tmpdir "^1.0.0"
1094 | 
1095 | parse-filepath@^1.0.1:
1096 |   version "1.0.2"
1097 |   resolved "https://registry.yarnpkg.com/parse-filepath/-/parse-filepath-1.0.2.tgz#a632127f53aaf3d15876f5872f3ffac763d6c891"
1098 |   integrity sha1-pjISf1Oq89FYdvWHLz/6x2PWyJE=
1099 |   dependencies:
1100 |     is-absolute "^1.0.0"
1101 |     map-cache "^0.2.0"
1102 |     path-root "^0.1.1"
1103 | 
1104 | parse-passwd@^1.0.0:
1105 |   version "1.0.0"
1106 |   resolved "https://registry.yarnpkg.com/parse-passwd/-/parse-passwd-1.0.0.tgz#6d5b934a456993b23d37f40a382d6f1666a8e5c6"
1107 |   integrity sha1-bVuTSkVpk7I9N/QKOC1vFmao5cY=
1108 | 
1109 | pascalcase@^0.1.1:
1110 |   version "0.1.1"
1111 |   resolved "https://registry.yarnpkg.com/pascalcase/-/pascalcase-0.1.1.tgz#b363e55e8006ca6fe21784d2db22bd15d7917f14"
1112 |   integrity sha1-s2PlXoAGym/iF4TS2yK9FdeRfxQ=
1113 | 
1114 | path-is-absolute@^1.0.0:
1115 |   version "1.0.1"
1116 |   resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f"
1117 |   integrity sha1-F0uSaHNVNP+8es5r9TpanhtcX18=
1118 | 
1119 | path-parse@^1.0.6:
1120 |   version "1.0.6"
1121 |   resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.6.tgz#d62dbb5679405d72c4737ec58600e9ddcf06d24c"
1122 |   integrity sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw==
1123 | 
1124 | path-root-regex@^0.1.0:
1125 |   version "0.1.2"
1126 |   resolved "https://registry.yarnpkg.com/path-root-regex/-/path-root-regex-0.1.2.tgz#bfccdc8df5b12dc52c8b43ec38d18d72c04ba96d"
1127 |   integrity sha1-v8zcjfWxLcUsi0PsONGNcsBLqW0=
1128 | 
1129 | path-root@^0.1.1:
1130 |   version "0.1.1"
1131 |   resolved "https://registry.yarnpkg.com/path-root/-/path-root-0.1.1.tgz#9a4a6814cac1c0cd73360a95f32083c8ea4745b7"
1132 |   integrity sha1-mkpoFMrBwM1zNgqV8yCDyOpHRbc=
1133 |   dependencies:
1134 |     path-root-regex "^0.1.0"
1135 | 
1136 | posix-character-classes@^0.1.0:
1137 |   version "0.1.1"
1138 |   resolved "https://registry.yarnpkg.com/posix-character-classes/-/posix-character-classes-0.1.1.tgz#01eac0fe3b5af71a2a6c02feabb8c1fef7e00eab"
1139 |   integrity sha1-AerA/jta9xoqbAL+q7jB/vfgDqs=
1140 | 
1141 | qunit-assert-close@^2.1.2:
1142 |   version "2.1.2"
1143 |   resolved "https://registry.yarnpkg.com/qunit-assert-close/-/qunit-assert-close-2.1.2.tgz#702d69492af59010a2e4040dd64fe0cd2e043ee1"
1144 |   integrity sha1-cC1pSSr1kBCi5AQN1k/gzS4EPuE=
1145 | 
1146 | qunit@^2.8.0:
1147 |   version "2.15.0"
1148 |   resolved "https://registry.yarnpkg.com/qunit/-/qunit-2.15.0.tgz#8ba3a3c5d13369ab1740337680600a98a7f8b591"
1149 |   integrity sha512-9ZoOILeyRZzrdvy2m7M4S76bneGD75Bh4B2aot3uKRKZuoEvA9gevvzU339L805Ys0AN2C7cnAV9nIBD5t72IQ==
1150 |   dependencies:
1151 |     commander "7.1.0"
1152 |     js-reporters "2.0.0"
1153 |     node-watch "0.7.1"
1154 |     tiny-glob "0.2.8"
1155 | 
1156 | rechoir@^0.6.2:
1157 |   version "0.6.2"
1158 |   resolved "https://registry.yarnpkg.com/rechoir/-/rechoir-0.6.2.tgz#85204b54dba82d5742e28c96756ef43af50e3384"
1159 |   integrity sha1-hSBLVNuoLVdC4oyWdW70OvUOM4Q=
1160 |   dependencies:
1161 |     resolve "^1.1.6"
1162 | 
1163 | regex-not@^1.0.0, regex-not@^1.0.2:
1164 |   version "1.0.2"
1165 |   resolved "https://registry.yarnpkg.com/regex-not/-/regex-not-1.0.2.tgz#1f4ece27e00b0b65e0247a6810e6a85d83a5752c"
1166 |   integrity sha512-J6SDjUgDxQj5NusnOtdFxDwN/+HWykR8GELwctJ7mdqhcyy1xEc4SRFHUXvxTp661YaVKAjfRLZ9cCqS6tn32A==
1167 |   dependencies:
1168 |     extend-shallow "^3.0.2"
1169 |     safe-regex "^1.1.0"
1170 | 
1171 | repeat-element@^1.1.2:
1172 |   version "1.1.4"
1173 |   resolved "https://registry.yarnpkg.com/repeat-element/-/repeat-element-1.1.4.tgz#be681520847ab58c7568ac75fbfad28ed42d39e9"
1174 |   integrity sha512-LFiNfRcSu7KK3evMyYOuCzv3L10TW7yC1G2/+StMjK8Y6Vqd2MG7r/Qjw4ghtuCOjFvlnms/iMmLqpvW/ES/WQ==
1175 | 
1176 | repeat-string@^1.6.1:
1177 |   version "1.6.1"
1178 |   resolved "https://registry.yarnpkg.com/repeat-string/-/repeat-string-1.6.1.tgz#8dcae470e1c88abc2d600fff4a776286da75e637"
1179 |   integrity sha1-jcrkcOHIirwtYA//Sndihtp15jc=
1180 | 
1181 | resolve-dir@^1.0.0, resolve-dir@^1.0.1:
1182 |   version "1.0.1"
1183 |   resolved "https://registry.yarnpkg.com/resolve-dir/-/resolve-dir-1.0.1.tgz#79a40644c362be82f26effe739c9bb5382046f43"
1184 |   integrity sha1-eaQGRMNivoLybv/nOcm7U4IEb0M=
1185 |   dependencies:
1186 |     expand-tilde "^2.0.0"
1187 |     global-modules "^1.0.0"
1188 | 
1189 | resolve-url@^0.2.1:
1190 |   version "0.2.1"
1191 |   resolved "https://registry.yarnpkg.com/resolve-url/-/resolve-url-0.2.1.tgz#2c637fe77c893afd2a663fe21aa9080068e2052a"
1192 |   integrity sha1-LGN/53yJOv0qZj/iGqkIAGjiBSo=
1193 | 
1194 | resolve@^1.1.6, resolve@^1.1.7:
1195 |   version "1.20.0"
1196 |   resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.20.0.tgz#629a013fb3f70755d6f0b7935cc1c2c5378b1975"
1197 |   integrity sha512-wENBPt4ySzg4ybFQW2TT1zMQucPK95HSh/nq2CFTZVOGut2+pQvSsgtda4d26YrYcr067wjbmzOG8byDPBX63A==
1198 |   dependencies:
1199 |     is-core-module "^2.2.0"
1200 |     path-parse "^1.0.6"
1201 | 
1202 | ret@~0.1.10:
1203 |   version "0.1.15"
1204 |   resolved "https://registry.yarnpkg.com/ret/-/ret-0.1.15.tgz#b8a4825d5bdb1fc3f6f53c2bc33f81388681c7bc"
1205 |   integrity sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg==
1206 | 
1207 | rimraf@~3.0.2:
1208 |   version "3.0.2"
1209 |   resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-3.0.2.tgz#f1a5402ba6220ad52cc1282bac1ae3aa49fd061a"
1210 |   integrity sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==
1211 |   dependencies:
1212 |     glob "^7.1.3"
1213 | 
1214 | safe-regex@^1.1.0:
1215 |   version "1.1.0"
1216 |   resolved "https://registry.yarnpkg.com/safe-regex/-/safe-regex-1.1.0.tgz#40a3669f3b077d1e943d44629e157dd48023bf2e"
1217 |   integrity sha1-QKNmnzsHfR6UPURinhV91IAjvy4=
1218 |   dependencies:
1219 |     ret "~0.1.10"
1220 | 
1221 | "safer-buffer@>= 2.1.2 < 3":
1222 |   version "2.1.2"
1223 |   resolved "https://registry.yarnpkg.com/safer-buffer/-/safer-buffer-2.1.2.tgz#44fa161b0187b9549dd84bb91802f9bd8385cd6a"
1224 |   integrity sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==
1225 | 
1226 | set-value@^2.0.0, set-value@^2.0.1:
1227 |   version "2.0.1"
1228 |   resolved "https://registry.yarnpkg.com/set-value/-/set-value-2.0.1.tgz#a18d40530e6f07de4228c7defe4227af8cad005b"
1229 |   integrity sha512-JxHc1weCN68wRY0fhCoXpyK55m/XPHafOmK4UWD7m2CI14GMcFypt4w/0+NV5f/ZMby2F6S2wwA7fgynh9gWSw==
1230 |   dependencies:
1231 |     extend-shallow "^2.0.1"
1232 |     is-extendable "^0.1.1"
1233 |     is-plain-object "^2.0.3"
1234 |     split-string "^3.0.1"
1235 | 
1236 | snapdragon-node@^2.0.1:
1237 |   version "2.1.1"
1238 |   resolved "https://registry.yarnpkg.com/snapdragon-node/-/snapdragon-node-2.1.1.tgz#6c175f86ff14bdb0724563e8f3c1b021a286853b"
1239 |   integrity sha512-O27l4xaMYt/RSQ5TR3vpWCAB5Kb/czIcqUFOM/C4fYcLnbZUc1PkjTAMjof2pBWaSTwOUd6qUHcFGVGj7aIwnw==
1240 |   dependencies:
1241 |     define-property "^1.0.0"
1242 |     isobject "^3.0.0"
1243 |     snapdragon-util "^3.0.1"
1244 | 
1245 | snapdragon-util@^3.0.1:
1246 |   version "3.0.1"
1247 |   resolved "https://registry.yarnpkg.com/snapdragon-util/-/snapdragon-util-3.0.1.tgz#f956479486f2acd79700693f6f7b805e45ab56e2"
1248 |   integrity sha512-mbKkMdQKsjX4BAL4bRYTj21edOf8cN7XHdYUJEe+Zn99hVEYcMvKPct1IqNe7+AZPirn8BCDOQBHQZknqmKlZQ==
1249 |   dependencies:
1250 |     kind-of "^3.2.0"
1251 | 
1252 | snapdragon@^0.8.1:
1253 |   version "0.8.2"
1254 |   resolved "https://registry.yarnpkg.com/snapdragon/-/snapdragon-0.8.2.tgz#64922e7c565b0e14204ba1aa7d6964278d25182d"
1255 |   integrity sha512-FtyOnWN/wCHTVXOMwvSv26d+ko5vWlIDD6zoUJ7LW8vh+ZBC8QdljveRP+crNrtBwioEUWy/4dMtbBjA4ioNlg==
1256 |   dependencies:
1257 |     base "^0.11.1"
1258 |     debug "^2.2.0"
1259 |     define-property "^0.2.5"
1260 |     extend-shallow "^2.0.1"
1261 |     map-cache "^0.2.2"
1262 |     source-map "^0.5.6"
1263 |     source-map-resolve "^0.5.0"
1264 |     use "^3.1.0"
1265 | 
1266 | source-map-resolve@^0.5.0:
1267 |   version "0.5.3"
1268 |   resolved "https://registry.yarnpkg.com/source-map-resolve/-/source-map-resolve-0.5.3.tgz#190866bece7553e1f8f267a2ee82c606b5509a1a"
1269 |   integrity sha512-Htz+RnsXWk5+P2slx5Jh3Q66vhQj1Cllm0zvnaY98+NFx+Dv2CF/f5O/t8x+KaNdrdIAsruNzoh/KpialbqAnw==
1270 |   dependencies:
1271 |     atob "^2.1.2"
1272 |     decode-uri-component "^0.2.0"
1273 |     resolve-url "^0.2.1"
1274 |     source-map-url "^0.4.0"
1275 |     urix "^0.1.0"
1276 | 
1277 | source-map-url@^0.4.0:
1278 |   version "0.4.1"
1279 |   resolved "https://registry.yarnpkg.com/source-map-url/-/source-map-url-0.4.1.tgz#0af66605a745a5a2f91cf1bbf8a7afbc283dec56"
1280 |   integrity sha512-cPiFOTLUKvJFIg4SKVScy4ilPPW6rFgMgfuZJPNoDuMs3nC1HbMUycBoJw77xFIp6z1UJQJOfx6C9GMH80DiTw==
1281 | 
1282 | source-map@^0.5.6:
1283 |   version "0.5.7"
1284 |   resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.5.7.tgz#8a039d2d1021d22d1ea14c80d8ea468ba2ef3fcc"
1285 |   integrity sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=
1286 | 
1287 | source-map@~0.1.33:
1288 |   version "0.1.43"
1289 |   resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.1.43.tgz#c24bc146ca517c1471f5dacbe2571b2b7f9e3346"
1290 |   integrity sha1-wkvBRspRfBRx9drL4lcbK3+eM0Y=
1291 |   dependencies:
1292 |     amdefine ">=0.0.4"
1293 | 
1294 | split-string@^3.0.1, split-string@^3.0.2:
1295 |   version "3.1.0"
1296 |   resolved "https://registry.yarnpkg.com/split-string/-/split-string-3.1.0.tgz#7cb09dda3a86585705c64b39a6466038682e8fe2"
1297 |   integrity sha512-NzNVhJDYpwceVVii8/Hu6DKfD2G+NrQHlS/V/qgv763EYudVwEcMQNxd2lh+0VrUByXN/oJkl5grOhYWvQUYiw==
1298 |   dependencies:
1299 |     extend-shallow "^3.0.0"
1300 | 
1301 | sprintf-js@^1.0.3:
1302 |   version "1.1.2"
1303 |   resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.1.2.tgz#da1765262bf8c0f571749f2ad6c26300207ae673"
1304 |   integrity sha512-VE0SOVEHCk7Qc8ulkWw3ntAzXuqf7S2lvwQaDLRnUeIEaKNQJzV6BwmLKhOqT61aGhfUMrXeaBk+oDGCzvhcug==
1305 | 
1306 | sprintf-js@~1.0.2:
1307 |   version "1.0.3"
1308 |   resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.0.3.tgz#04e6926f662895354f3dd015203633b857297e2c"
1309 |   integrity sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw=
1310 | 
1311 | static-extend@^0.1.1:
1312 |   version "0.1.2"
1313 |   resolved "https://registry.yarnpkg.com/static-extend/-/static-extend-0.1.2.tgz#60809c39cbff55337226fd5e0b520f341f1fb5c6"
1314 |   integrity sha1-YICcOcv/VTNyJv1eC1IPNB8ftcY=
1315 |   dependencies:
1316 |     define-property "^0.2.5"
1317 |     object-copy "^0.1.0"
1318 | 
1319 | strip-ansi@~0.1.0:
1320 |   version "0.1.1"
1321 |   resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-0.1.1.tgz#39e8a98d044d150660abe4a6808acf70bb7bc991"
1322 |   integrity sha1-OeipjQRNFQZgq+SmgIrPcLt7yZE=
1323 | 
1324 | supports-color@^7.1.0:
1325 |   version "7.2.0"
1326 |   resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-7.2.0.tgz#1b7dcdcb32b8138801b3e478ba6a51caa89648da"
1327 |   integrity sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==
1328 |   dependencies:
1329 |     has-flag "^4.0.0"
1330 | 
1331 | tiny-glob@0.2.8:
1332 |   version "0.2.8"
1333 |   resolved "https://registry.yarnpkg.com/tiny-glob/-/tiny-glob-0.2.8.tgz#b2792c396cc62db891ffa161fe8b33e76123e531"
1334 |   integrity sha512-vkQP7qOslq63XRX9kMswlby99kyO5OvKptw7AMwBVMjXEI7Tb61eoI5DydyEMOseyGS5anDN1VPoVxEvH01q8w==
1335 |   dependencies:
1336 |     globalyzer "0.1.0"
1337 |     globrex "^0.1.2"
1338 | 
1339 | to-object-path@^0.3.0:
1340 |   version "0.3.0"
1341 |   resolved "https://registry.yarnpkg.com/to-object-path/-/to-object-path-0.3.0.tgz#297588b7b0e7e0ac08e04e672f85c1f4999e17af"
1342 |   integrity sha1-KXWIt7Dn4KwI4E5nL4XB9JmeF68=
1343 |   dependencies:
1344 |     kind-of "^3.0.2"
1345 | 
1346 | to-regex-range@^2.1.0:
1347 |   version "2.1.1"
1348 |   resolved "https://registry.yarnpkg.com/to-regex-range/-/to-regex-range-2.1.1.tgz#7c80c17b9dfebe599e27367e0d4dd5590141db38"
1349 |   integrity sha1-fIDBe53+vlmeJzZ+DU3VWQFB2zg=
1350 |   dependencies:
1351 |     is-number "^3.0.0"
1352 |     repeat-string "^1.6.1"
1353 | 
1354 | to-regex@^3.0.1, to-regex@^3.0.2:
1355 |   version "3.0.2"
1356 |   resolved "https://registry.yarnpkg.com/to-regex/-/to-regex-3.0.2.tgz#13cfdd9b336552f30b51f33a8ae1b42a7a7599ce"
1357 |   integrity sha512-FWtleNAtZ/Ki2qtqej2CXTOayOH9bHDQF+Q48VpWyDXjbYxA4Yz8iDB31zXOBUlOHHKidDbqGVrTUvQMPmBGBw==
1358 |   dependencies:
1359 |     define-property "^2.0.2"
1360 |     extend-shallow "^3.0.2"
1361 |     regex-not "^1.0.2"
1362 |     safe-regex "^1.1.0"
1363 | 
1364 | unc-path-regex@^0.1.2:
1365 |   version "0.1.2"
1366 |   resolved "https://registry.yarnpkg.com/unc-path-regex/-/unc-path-regex-0.1.2.tgz#e73dd3d7b0d7c5ed86fbac6b0ae7d8c6a69d50fa"
1367 |   integrity sha1-5z3T17DXxe2G+6xrCufYxqadUPo=
1368 | 
1369 | underscore.string@~3.3.5:
1370 |   version "3.3.5"
1371 |   resolved "https://registry.yarnpkg.com/underscore.string/-/underscore.string-3.3.5.tgz#fc2ad255b8bd309e239cbc5816fd23a9b7ea4023"
1372 |   integrity sha512-g+dpmgn+XBneLmXXo+sGlW5xQEt4ErkS3mgeN2GFbremYeMBSJKr9Wf2KJplQVaiPY/f7FN6atosWYNm9ovrYg==
1373 |   dependencies:
1374 |     sprintf-js "^1.0.3"
1375 |     util-deprecate "^1.0.2"
1376 | 
1377 | underscore@1.1.x:
1378 |   version "1.1.7"
1379 |   resolved "https://registry.yarnpkg.com/underscore/-/underscore-1.1.7.tgz#40bab84bad19d230096e8d6ef628bff055d83db0"
1380 |   integrity sha1-QLq4S60Z0jAJbo1u9ii/8FXYPbA=
1381 | 
1382 | underscore@1.4.4:
1383 |   version "1.4.4"
1384 |   resolved "https://registry.yarnpkg.com/underscore/-/underscore-1.4.4.tgz#61a6a32010622afa07963bf325203cf12239d604"
1385 |   integrity sha1-YaajIBBiKvoHljvzJSA88SI51gQ=
1386 | 
1387 | underscore@~1.6.0:
1388 |   version "1.6.0"
1389 |   resolved "https://registry.yarnpkg.com/underscore/-/underscore-1.6.0.tgz#8b38b10cacdef63337b8b24e4ff86d45aea529a8"
1390 |   integrity sha1-izixDKze9jM3uLJOT/htRa6lKag=
1391 | 
1392 | union-value@^1.0.0:
1393 |   version "1.0.1"
1394 |   resolved "https://registry.yarnpkg.com/union-value/-/union-value-1.0.1.tgz#0b6fe7b835aecda61c6ea4d4f02c14221e109847"
1395 |   integrity sha512-tJfXmxMeWYnczCVs7XAEvIV7ieppALdyepWMkHkwciRpZraG/xwT+s2JN8+pr1+8jCRf80FFzvr+MpQeeoF4Xg==
1396 |   dependencies:
1397 |     arr-union "^3.1.0"
1398 |     get-value "^2.0.6"
1399 |     is-extendable "^0.1.1"
1400 |     set-value "^2.0.1"
1401 | 
1402 | unset-value@^1.0.0:
1403 |   version "1.0.0"
1404 |   resolved "https://registry.yarnpkg.com/unset-value/-/unset-value-1.0.0.tgz#8376873f7d2335179ffb1e6fc3a8ed0dfc8ab559"
1405 |   integrity sha1-g3aHP30jNRef+x5vw6jtDfyKtVk=
1406 |   dependencies:
1407 |     has-value "^0.3.1"
1408 |     isobject "^3.0.0"
1409 | 
1410 | urix@^0.1.0:
1411 |   version "0.1.0"
1412 |   resolved "https://registry.yarnpkg.com/urix/-/urix-0.1.0.tgz#da937f7a62e21fec1fd18d49b35c2935067a6c72"
1413 |   integrity sha1-2pN/emLiH+wf0Y1Js1wpNQZ6bHI=
1414 | 
1415 | use@^3.1.0:
1416 |   version "3.1.1"
1417 |   resolved "https://registry.yarnpkg.com/use/-/use-3.1.1.tgz#d50c8cac79a19fbc20f2911f56eb973f4e10070f"
1418 |   integrity sha512-cwESVXlO3url9YWlFW/TA9cshCEhtu7IKJ/p5soJ/gGpj7vbvFrAY/eIioQ6Dw23KjZhYgiIo8HOs1nQ2vr/oQ==
1419 | 
1420 | util-deprecate@^1.0.2:
1421 |   version "1.0.2"
1422 |   resolved "https://registry.yarnpkg.com/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf"
1423 |   integrity sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=
1424 | 
1425 | v8flags@~3.1.1:
1426 |   version "3.1.3"
1427 |   resolved "https://registry.yarnpkg.com/v8flags/-/v8flags-3.1.3.tgz#fc9dc23521ca20c5433f81cc4eb9b3033bb105d8"
1428 |   integrity sha512-amh9CCg3ZxkzQ48Mhcb8iX7xpAfYJgePHxWMQCBWECpOSqJUXgY26ncA61UTV0BkPqfhcy6mzwCIoP4ygxpW8w==
1429 |   dependencies:
1430 |     homedir-polyfill "^1.0.1"
1431 | 
1432 | which@^1.2.14, which@~1.3.0:
1433 |   version "1.3.1"
1434 |   resolved "https://registry.yarnpkg.com/which/-/which-1.3.1.tgz#a45043d54f5805316da8d62f9f50918d3da70b0a"
1435 |   integrity sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==
1436 |   dependencies:
1437 |     isexe "^2.0.0"
1438 | 
1439 | wrappy@1:
1440 |   version "1.0.2"
1441 |   resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f"
1442 |   integrity sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=
1443 | 


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