├── .github
    └── FUNDING.yml
├── .gitignore
├── .npmignore
├── LICENSE
├── README.md
├── default.nix
├── examples
    ├── basic
    │   ├── .gitignore
    │   ├── build.js
    │   ├── elm.json
    │   ├── index.html
    │   ├── package.json
    │   ├── src
    │   │   ├── Main.elm
    │   │   └── index.js
    │   └── yarn.lock
    └── with-cwd
    │   ├── .gitignore
    │   ├── build.js
    │   ├── elm
    │       ├── elm.json
    │       └── src
    │       │   ├── Main.elm
    │       │   └── SomeModule.elm
    │   ├── index.html
    │   ├── index.js
    │   ├── package.json
    │   └── yarn.lock
├── index.js
├── package.json
└── yarn.lock


/.github/FUNDING.yml:
--------------------------------------------------------------------------------
1 | github: phenax
2 | custom: ["https://www.buymeacoffee.com/phenax"]
3 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules/
2 | elm-stuff/
3 | dist/
4 | *.log
5 | *.map
6 | 


--------------------------------------------------------------------------------
/.npmignore:
--------------------------------------------------------------------------------
1 | examples/
2 | node_modules/
3 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2021 Akshay Nair
 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.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # esbuild-plugin-elm
 2 | An esbuild plugin for building elm projects
 3 | 
 4 | [![npm](https://img.shields.io/npm/v/esbuild-plugin-elm?color=%2351e980&style=flat-square)](https://www.npmjs.com/package/esbuild-plugin-elm)
 5 | 
 6 | 
 7 | 
 8 | ### Install
 9 | Add this plugin to your project's dev-dependencies by running the following -
10 | 
11 | ```
12 | yarn add -D esbuild-plugin-elm
13 | // OR
14 | npm install -D esbuild-plugin-elm
15 | ```
16 | 
17 | 
18 | ### Usage
19 | 
20 | A simple example can be found in [./examples/basic/](https://github.com/phenax/esbuild-plugin-elm/tree/main/examples/basic).
21 | 
22 | ```js
23 | esbuild.build({
24 |   entryPoints: ['src/index.js'],
25 |   bundle: true,
26 |   outfile: 'dist/bundle.js',
27 |   plugins: [
28 |     ElmPlugin(options) // options are documented below
29 |   ],
30 | }).catch(e => (console.error(e), process.exit(1)))
31 | ```
32 | 
33 | ### Import paths
34 | 
35 | Import paths will be resolved using the paths listed in `source-directories` in `elm.json`. If none resolve, the import is assumed to be relative to the importing file.
36 | 
37 | ### Options
38 | 
39 | * `debug` *(default: `false`)*:
40 | 
41 |   Enable the time-travelling debugger
42 | 
43 | * `optimize` *(default: `NODE_ENV === 'production'`)*:
44 | 
45 |   Optimize the js output (true by default if `NODE_ENV` is production)
46 | 
47 | * `pathToElm` *(default: `node_modules/.bin/elm || elm`)*:
48 | 
49 |   Specify an explicit path to the elm executable
50 | 
51 | * `clearOnWatch` *(default: `false`)*:
52 | 
53 |   Clear the console before re-building on file changes
54 | 
55 | * `cwd` *(default: `<PWD>`)*:
56 | 
57 |   The current working directory/elm project root
58 | 
59 | * `verbose` *(default: `false`)*:
60 | 
61 |   Enable verbose output of `node-elm-compiler`
62 | 
63 | 
64 | ### Tutorials
65 | 
66 | * [How to Install Elm, on a Rails App, via esbuild, using `esbuild-plugin-elm`](https://benkoshy.github.io/2022/02/08/elm-via-esbuild-on-rails.html)
67 | 


--------------------------------------------------------------------------------
/default.nix:
--------------------------------------------------------------------------------
 1 | { pkgs ? import <nixpkgs> { }, ... }:
 2 | 
 3 | let
 4 |   packages = with pkgs; [
 5 |     elmPackages.elm
 6 |     elmPackages.create-elm-app
 7 |     elmPackages.elm-format
 8 |     elmPackages.elm-language-server
 9 |     nodejs-18_x
10 |     yarn
11 |   ];
12 | in
13 | pkgs.stdenv.mkDerivation {
14 |   name = "esbuild-plugin-elm";
15 |   buildInputs = packages;
16 | }
17 | 


--------------------------------------------------------------------------------
/examples/basic/.gitignore:
--------------------------------------------------------------------------------
1 | dist/
2 | 


--------------------------------------------------------------------------------
/examples/basic/build.js:
--------------------------------------------------------------------------------
 1 | const esbuild = require('esbuild');
 2 | const ElmPlugin = require('esbuild-plugin-elm');
 3 | 
 4 | const watch = process.argv.includes('--watch')
 5 | const isProd = process.env.NODE_ENV === 'production'
 6 | 
 7 | esbuild.build({
 8 |   entryPoints: ['src/index.js'],
 9 |   bundle: true,
10 |   outdir: 'dist',
11 |   minify: isProd,
12 |   watch,
13 |   plugins: [
14 |     ElmPlugin({
15 |       debug: true,
16 |       optimize: isProd,
17 |       clearOnWatch: watch,
18 |       verbose: true,
19 |     }),
20 |   ],
21 | }).catch(_e => process.exit(1))
22 | 


--------------------------------------------------------------------------------
/examples/basic/elm.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "type": "application",
 3 |     "source-directories": [
 4 |         "src"
 5 |     ],
 6 |     "elm-version": "0.19.1",
 7 |     "dependencies": {
 8 |         "direct": {
 9 |             "elm/browser": "1.0.2",
10 |             "elm/core": "1.0.5",
11 |             "elm/html": "1.0.0"
12 |         },
13 |         "indirect": {
14 |             "elm/json": "1.1.3",
15 |             "elm/time": "1.0.0",
16 |             "elm/url": "1.0.0",
17 |             "elm/virtual-dom": "1.0.2"
18 |         }
19 |     },
20 |     "test-dependencies": {
21 |         "direct": {},
22 |         "indirect": {}
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/examples/basic/index.html:
--------------------------------------------------------------------------------
   1 | <!DOCTYPE HTML>
   2 | <html>
   3 | <head>
   4 |   <meta charset="UTF-8">
   5 |   <title>Main</title>
   6 |   <style>body { padding: 0; margin: 0; }</style>
   7 | </head>
   8 | 
   9 | <body>
  10 | 
  11 | <pre id="elm"></pre>
  12 | 
  13 | <script>
  14 | try {
  15 | (function(scope){
  16 | 'use strict';
  17 | 
  18 | function F(arity, fun, wrapper) {
  19 |   wrapper.a = arity;
  20 |   wrapper.f = fun;
  21 |   return wrapper;
  22 | }
  23 | 
  24 | function F2(fun) {
  25 |   return F(2, fun, function(a) { return function(b) { return fun(a,b); }; })
  26 | }
  27 | function F3(fun) {
  28 |   return F(3, fun, function(a) {
  29 |     return function(b) { return function(c) { return fun(a, b, c); }; };
  30 |   });
  31 | }
  32 | function F4(fun) {
  33 |   return F(4, fun, function(a) { return function(b) { return function(c) {
  34 |     return function(d) { return fun(a, b, c, d); }; }; };
  35 |   });
  36 | }
  37 | function F5(fun) {
  38 |   return F(5, fun, function(a) { return function(b) { return function(c) {
  39 |     return function(d) { return function(e) { return fun(a, b, c, d, e); }; }; }; };
  40 |   });
  41 | }
  42 | function F6(fun) {
  43 |   return F(6, fun, function(a) { return function(b) { return function(c) {
  44 |     return function(d) { return function(e) { return function(f) {
  45 |     return fun(a, b, c, d, e, f); }; }; }; }; };
  46 |   });
  47 | }
  48 | function F7(fun) {
  49 |   return F(7, fun, function(a) { return function(b) { return function(c) {
  50 |     return function(d) { return function(e) { return function(f) {
  51 |     return function(g) { return fun(a, b, c, d, e, f, g); }; }; }; }; }; };
  52 |   });
  53 | }
  54 | function F8(fun) {
  55 |   return F(8, fun, function(a) { return function(b) { return function(c) {
  56 |     return function(d) { return function(e) { return function(f) {
  57 |     return function(g) { return function(h) {
  58 |     return fun(a, b, c, d, e, f, g, h); }; }; }; }; }; }; };
  59 |   });
  60 | }
  61 | function F9(fun) {
  62 |   return F(9, fun, function(a) { return function(b) { return function(c) {
  63 |     return function(d) { return function(e) { return function(f) {
  64 |     return function(g) { return function(h) { return function(i) {
  65 |     return fun(a, b, c, d, e, f, g, h, i); }; }; }; }; }; }; }; };
  66 |   });
  67 | }
  68 | 
  69 | function A2(fun, a, b) {
  70 |   return fun.a === 2 ? fun.f(a, b) : fun(a)(b);
  71 | }
  72 | function A3(fun, a, b, c) {
  73 |   return fun.a === 3 ? fun.f(a, b, c) : fun(a)(b)(c);
  74 | }
  75 | function A4(fun, a, b, c, d) {
  76 |   return fun.a === 4 ? fun.f(a, b, c, d) : fun(a)(b)(c)(d);
  77 | }
  78 | function A5(fun, a, b, c, d, e) {
  79 |   return fun.a === 5 ? fun.f(a, b, c, d, e) : fun(a)(b)(c)(d)(e);
  80 | }
  81 | function A6(fun, a, b, c, d, e, f) {
  82 |   return fun.a === 6 ? fun.f(a, b, c, d, e, f) : fun(a)(b)(c)(d)(e)(f);
  83 | }
  84 | function A7(fun, a, b, c, d, e, f, g) {
  85 |   return fun.a === 7 ? fun.f(a, b, c, d, e, f, g) : fun(a)(b)(c)(d)(e)(f)(g);
  86 | }
  87 | function A8(fun, a, b, c, d, e, f, g, h) {
  88 |   return fun.a === 8 ? fun.f(a, b, c, d, e, f, g, h) : fun(a)(b)(c)(d)(e)(f)(g)(h);
  89 | }
  90 | function A9(fun, a, b, c, d, e, f, g, h, i) {
  91 |   return fun.a === 9 ? fun.f(a, b, c, d, e, f, g, h, i) : fun(a)(b)(c)(d)(e)(f)(g)(h)(i);
  92 | }
  93 | 
  94 | console.warn('Compiled in DEV mode. Follow the advice at https://elm-lang.org/0.19.1/optimize for better performance and smaller assets.');
  95 | 
  96 | 
  97 | // EQUALITY
  98 | 
  99 | function _Utils_eq(x, y)
 100 | {
 101 | 	for (
 102 | 		var pair, stack = [], isEqual = _Utils_eqHelp(x, y, 0, stack);
 103 | 		isEqual && (pair = stack.pop());
 104 | 		isEqual = _Utils_eqHelp(pair.a, pair.b, 0, stack)
 105 | 		)
 106 | 	{}
 107 | 
 108 | 	return isEqual;
 109 | }
 110 | 
 111 | function _Utils_eqHelp(x, y, depth, stack)
 112 | {
 113 | 	if (x === y)
 114 | 	{
 115 | 		return true;
 116 | 	}
 117 | 
 118 | 	if (typeof x !== 'object' || x === null || y === null)
 119 | 	{
 120 | 		typeof x === 'function' && _Debug_crash(5);
 121 | 		return false;
 122 | 	}
 123 | 
 124 | 	if (depth > 100)
 125 | 	{
 126 | 		stack.push(_Utils_Tuple2(x,y));
 127 | 		return true;
 128 | 	}
 129 | 
 130 | 	/**/
 131 | 	if (x.$ === 'Set_elm_builtin')
 132 | 	{
 133 | 		x = $elm$core$Set$toList(x);
 134 | 		y = $elm$core$Set$toList(y);
 135 | 	}
 136 | 	if (x.$ === 'RBNode_elm_builtin' || x.$ === 'RBEmpty_elm_builtin')
 137 | 	{
 138 | 		x = $elm$core$Dict$toList(x);
 139 | 		y = $elm$core$Dict$toList(y);
 140 | 	}
 141 | 	//*/
 142 | 
 143 | 	/**_UNUSED/
 144 | 	if (x.$ < 0)
 145 | 	{
 146 | 		x = $elm$core$Dict$toList(x);
 147 | 		y = $elm$core$Dict$toList(y);
 148 | 	}
 149 | 	//*/
 150 | 
 151 | 	for (var key in x)
 152 | 	{
 153 | 		if (!_Utils_eqHelp(x[key], y[key], depth + 1, stack))
 154 | 		{
 155 | 			return false;
 156 | 		}
 157 | 	}
 158 | 	return true;
 159 | }
 160 | 
 161 | var _Utils_equal = F2(_Utils_eq);
 162 | var _Utils_notEqual = F2(function(a, b) { return !_Utils_eq(a,b); });
 163 | 
 164 | 
 165 | 
 166 | // COMPARISONS
 167 | 
 168 | // Code in Generate/JavaScript.hs, Basics.js, and List.js depends on
 169 | // the particular integer values assigned to LT, EQ, and GT.
 170 | 
 171 | function _Utils_cmp(x, y, ord)
 172 | {
 173 | 	if (typeof x !== 'object')
 174 | 	{
 175 | 		return x === y ? /*EQ*/ 0 : x < y ? /*LT*/ -1 : /*GT*/ 1;
 176 | 	}
 177 | 
 178 | 	/**/
 179 | 	if (x instanceof String)
 180 | 	{
 181 | 		var a = x.valueOf();
 182 | 		var b = y.valueOf();
 183 | 		return a === b ? 0 : a < b ? -1 : 1;
 184 | 	}
 185 | 	//*/
 186 | 
 187 | 	/**_UNUSED/
 188 | 	if (typeof x.$ === 'undefined')
 189 | 	//*/
 190 | 	/**/
 191 | 	if (x.$[0] === '#')
 192 | 	//*/
 193 | 	{
 194 | 		return (ord = _Utils_cmp(x.a, y.a))
 195 | 			? ord
 196 | 			: (ord = _Utils_cmp(x.b, y.b))
 197 | 				? ord
 198 | 				: _Utils_cmp(x.c, y.c);
 199 | 	}
 200 | 
 201 | 	// traverse conses until end of a list or a mismatch
 202 | 	for (; x.b && y.b && !(ord = _Utils_cmp(x.a, y.a)); x = x.b, y = y.b) {} // WHILE_CONSES
 203 | 	return ord || (x.b ? /*GT*/ 1 : y.b ? /*LT*/ -1 : /*EQ*/ 0);
 204 | }
 205 | 
 206 | var _Utils_lt = F2(function(a, b) { return _Utils_cmp(a, b) < 0; });
 207 | var _Utils_le = F2(function(a, b) { return _Utils_cmp(a, b) < 1; });
 208 | var _Utils_gt = F2(function(a, b) { return _Utils_cmp(a, b) > 0; });
 209 | var _Utils_ge = F2(function(a, b) { return _Utils_cmp(a, b) >= 0; });
 210 | 
 211 | var _Utils_compare = F2(function(x, y)
 212 | {
 213 | 	var n = _Utils_cmp(x, y);
 214 | 	return n < 0 ? $elm$core$Basics$LT : n ? $elm$core$Basics$GT : $elm$core$Basics$EQ;
 215 | });
 216 | 
 217 | 
 218 | // COMMON VALUES
 219 | 
 220 | var _Utils_Tuple0_UNUSED = 0;
 221 | var _Utils_Tuple0 = { $: '#0' };
 222 | 
 223 | function _Utils_Tuple2_UNUSED(a, b) { return { a: a, b: b }; }
 224 | function _Utils_Tuple2(a, b) { return { $: '#2', a: a, b: b }; }
 225 | 
 226 | function _Utils_Tuple3_UNUSED(a, b, c) { return { a: a, b: b, c: c }; }
 227 | function _Utils_Tuple3(a, b, c) { return { $: '#3', a: a, b: b, c: c }; }
 228 | 
 229 | function _Utils_chr_UNUSED(c) { return c; }
 230 | function _Utils_chr(c) { return new String(c); }
 231 | 
 232 | 
 233 | // RECORDS
 234 | 
 235 | function _Utils_update(oldRecord, updatedFields)
 236 | {
 237 | 	var newRecord = {};
 238 | 
 239 | 	for (var key in oldRecord)
 240 | 	{
 241 | 		newRecord[key] = oldRecord[key];
 242 | 	}
 243 | 
 244 | 	for (var key in updatedFields)
 245 | 	{
 246 | 		newRecord[key] = updatedFields[key];
 247 | 	}
 248 | 
 249 | 	return newRecord;
 250 | }
 251 | 
 252 | 
 253 | // APPEND
 254 | 
 255 | var _Utils_append = F2(_Utils_ap);
 256 | 
 257 | function _Utils_ap(xs, ys)
 258 | {
 259 | 	// append Strings
 260 | 	if (typeof xs === 'string')
 261 | 	{
 262 | 		return xs + ys;
 263 | 	}
 264 | 
 265 | 	// append Lists
 266 | 	if (!xs.b)
 267 | 	{
 268 | 		return ys;
 269 | 	}
 270 | 	var root = _List_Cons(xs.a, ys);
 271 | 	xs = xs.b
 272 | 	for (var curr = root; xs.b; xs = xs.b) // WHILE_CONS
 273 | 	{
 274 | 		curr = curr.b = _List_Cons(xs.a, ys);
 275 | 	}
 276 | 	return root;
 277 | }
 278 | 
 279 | 
 280 | 
 281 | var _List_Nil_UNUSED = { $: 0 };
 282 | var _List_Nil = { $: '[]' };
 283 | 
 284 | function _List_Cons_UNUSED(hd, tl) { return { $: 1, a: hd, b: tl }; }
 285 | function _List_Cons(hd, tl) { return { $: '::', a: hd, b: tl }; }
 286 | 
 287 | 
 288 | var _List_cons = F2(_List_Cons);
 289 | 
 290 | function _List_fromArray(arr)
 291 | {
 292 | 	var out = _List_Nil;
 293 | 	for (var i = arr.length; i--; )
 294 | 	{
 295 | 		out = _List_Cons(arr[i], out);
 296 | 	}
 297 | 	return out;
 298 | }
 299 | 
 300 | function _List_toArray(xs)
 301 | {
 302 | 	for (var out = []; xs.b; xs = xs.b) // WHILE_CONS
 303 | 	{
 304 | 		out.push(xs.a);
 305 | 	}
 306 | 	return out;
 307 | }
 308 | 
 309 | var _List_map2 = F3(function(f, xs, ys)
 310 | {
 311 | 	for (var arr = []; xs.b && ys.b; xs = xs.b, ys = ys.b) // WHILE_CONSES
 312 | 	{
 313 | 		arr.push(A2(f, xs.a, ys.a));
 314 | 	}
 315 | 	return _List_fromArray(arr);
 316 | });
 317 | 
 318 | var _List_map3 = F4(function(f, xs, ys, zs)
 319 | {
 320 | 	for (var arr = []; xs.b && ys.b && zs.b; xs = xs.b, ys = ys.b, zs = zs.b) // WHILE_CONSES
 321 | 	{
 322 | 		arr.push(A3(f, xs.a, ys.a, zs.a));
 323 | 	}
 324 | 	return _List_fromArray(arr);
 325 | });
 326 | 
 327 | var _List_map4 = F5(function(f, ws, xs, ys, zs)
 328 | {
 329 | 	for (var arr = []; ws.b && xs.b && ys.b && zs.b; ws = ws.b, xs = xs.b, ys = ys.b, zs = zs.b) // WHILE_CONSES
 330 | 	{
 331 | 		arr.push(A4(f, ws.a, xs.a, ys.a, zs.a));
 332 | 	}
 333 | 	return _List_fromArray(arr);
 334 | });
 335 | 
 336 | var _List_map5 = F6(function(f, vs, ws, xs, ys, zs)
 337 | {
 338 | 	for (var arr = []; vs.b && ws.b && xs.b && ys.b && zs.b; vs = vs.b, ws = ws.b, xs = xs.b, ys = ys.b, zs = zs.b) // WHILE_CONSES
 339 | 	{
 340 | 		arr.push(A5(f, vs.a, ws.a, xs.a, ys.a, zs.a));
 341 | 	}
 342 | 	return _List_fromArray(arr);
 343 | });
 344 | 
 345 | var _List_sortBy = F2(function(f, xs)
 346 | {
 347 | 	return _List_fromArray(_List_toArray(xs).sort(function(a, b) {
 348 | 		return _Utils_cmp(f(a), f(b));
 349 | 	}));
 350 | });
 351 | 
 352 | var _List_sortWith = F2(function(f, xs)
 353 | {
 354 | 	return _List_fromArray(_List_toArray(xs).sort(function(a, b) {
 355 | 		var ord = A2(f, a, b);
 356 | 		return ord === $elm$core$Basics$EQ ? 0 : ord === $elm$core$Basics$LT ? -1 : 1;
 357 | 	}));
 358 | });
 359 | 
 360 | 
 361 | 
 362 | var _JsArray_empty = [];
 363 | 
 364 | function _JsArray_singleton(value)
 365 | {
 366 |     return [value];
 367 | }
 368 | 
 369 | function _JsArray_length(array)
 370 | {
 371 |     return array.length;
 372 | }
 373 | 
 374 | var _JsArray_initialize = F3(function(size, offset, func)
 375 | {
 376 |     var result = new Array(size);
 377 | 
 378 |     for (var i = 0; i < size; i++)
 379 |     {
 380 |         result[i] = func(offset + i);
 381 |     }
 382 | 
 383 |     return result;
 384 | });
 385 | 
 386 | var _JsArray_initializeFromList = F2(function (max, ls)
 387 | {
 388 |     var result = new Array(max);
 389 | 
 390 |     for (var i = 0; i < max && ls.b; i++)
 391 |     {
 392 |         result[i] = ls.a;
 393 |         ls = ls.b;
 394 |     }
 395 | 
 396 |     result.length = i;
 397 |     return _Utils_Tuple2(result, ls);
 398 | });
 399 | 
 400 | var _JsArray_unsafeGet = F2(function(index, array)
 401 | {
 402 |     return array[index];
 403 | });
 404 | 
 405 | var _JsArray_unsafeSet = F3(function(index, value, array)
 406 | {
 407 |     var length = array.length;
 408 |     var result = new Array(length);
 409 | 
 410 |     for (var i = 0; i < length; i++)
 411 |     {
 412 |         result[i] = array[i];
 413 |     }
 414 | 
 415 |     result[index] = value;
 416 |     return result;
 417 | });
 418 | 
 419 | var _JsArray_push = F2(function(value, array)
 420 | {
 421 |     var length = array.length;
 422 |     var result = new Array(length + 1);
 423 | 
 424 |     for (var i = 0; i < length; i++)
 425 |     {
 426 |         result[i] = array[i];
 427 |     }
 428 | 
 429 |     result[length] = value;
 430 |     return result;
 431 | });
 432 | 
 433 | var _JsArray_foldl = F3(function(func, acc, array)
 434 | {
 435 |     var length = array.length;
 436 | 
 437 |     for (var i = 0; i < length; i++)
 438 |     {
 439 |         acc = A2(func, array[i], acc);
 440 |     }
 441 | 
 442 |     return acc;
 443 | });
 444 | 
 445 | var _JsArray_foldr = F3(function(func, acc, array)
 446 | {
 447 |     for (var i = array.length - 1; i >= 0; i--)
 448 |     {
 449 |         acc = A2(func, array[i], acc);
 450 |     }
 451 | 
 452 |     return acc;
 453 | });
 454 | 
 455 | var _JsArray_map = F2(function(func, array)
 456 | {
 457 |     var length = array.length;
 458 |     var result = new Array(length);
 459 | 
 460 |     for (var i = 0; i < length; i++)
 461 |     {
 462 |         result[i] = func(array[i]);
 463 |     }
 464 | 
 465 |     return result;
 466 | });
 467 | 
 468 | var _JsArray_indexedMap = F3(function(func, offset, array)
 469 | {
 470 |     var length = array.length;
 471 |     var result = new Array(length);
 472 | 
 473 |     for (var i = 0; i < length; i++)
 474 |     {
 475 |         result[i] = A2(func, offset + i, array[i]);
 476 |     }
 477 | 
 478 |     return result;
 479 | });
 480 | 
 481 | var _JsArray_slice = F3(function(from, to, array)
 482 | {
 483 |     return array.slice(from, to);
 484 | });
 485 | 
 486 | var _JsArray_appendN = F3(function(n, dest, source)
 487 | {
 488 |     var destLen = dest.length;
 489 |     var itemsToCopy = n - destLen;
 490 | 
 491 |     if (itemsToCopy > source.length)
 492 |     {
 493 |         itemsToCopy = source.length;
 494 |     }
 495 | 
 496 |     var size = destLen + itemsToCopy;
 497 |     var result = new Array(size);
 498 | 
 499 |     for (var i = 0; i < destLen; i++)
 500 |     {
 501 |         result[i] = dest[i];
 502 |     }
 503 | 
 504 |     for (var i = 0; i < itemsToCopy; i++)
 505 |     {
 506 |         result[i + destLen] = source[i];
 507 |     }
 508 | 
 509 |     return result;
 510 | });
 511 | 
 512 | 
 513 | 
 514 | // LOG
 515 | 
 516 | var _Debug_log_UNUSED = F2(function(tag, value)
 517 | {
 518 | 	return value;
 519 | });
 520 | 
 521 | var _Debug_log = F2(function(tag, value)
 522 | {
 523 | 	console.log(tag + ': ' + _Debug_toString(value));
 524 | 	return value;
 525 | });
 526 | 
 527 | 
 528 | // TODOS
 529 | 
 530 | function _Debug_todo(moduleName, region)
 531 | {
 532 | 	return function(message) {
 533 | 		_Debug_crash(8, moduleName, region, message);
 534 | 	};
 535 | }
 536 | 
 537 | function _Debug_todoCase(moduleName, region, value)
 538 | {
 539 | 	return function(message) {
 540 | 		_Debug_crash(9, moduleName, region, value, message);
 541 | 	};
 542 | }
 543 | 
 544 | 
 545 | // TO STRING
 546 | 
 547 | function _Debug_toString_UNUSED(value)
 548 | {
 549 | 	return '<internals>';
 550 | }
 551 | 
 552 | function _Debug_toString(value)
 553 | {
 554 | 	return _Debug_toAnsiString(false, value);
 555 | }
 556 | 
 557 | function _Debug_toAnsiString(ansi, value)
 558 | {
 559 | 	if (typeof value === 'function')
 560 | 	{
 561 | 		return _Debug_internalColor(ansi, '<function>');
 562 | 	}
 563 | 
 564 | 	if (typeof value === 'boolean')
 565 | 	{
 566 | 		return _Debug_ctorColor(ansi, value ? 'True' : 'False');
 567 | 	}
 568 | 
 569 | 	if (typeof value === 'number')
 570 | 	{
 571 | 		return _Debug_numberColor(ansi, value + '');
 572 | 	}
 573 | 
 574 | 	if (value instanceof String)
 575 | 	{
 576 | 		return _Debug_charColor(ansi, "'" + _Debug_addSlashes(value, true) + "'");
 577 | 	}
 578 | 
 579 | 	if (typeof value === 'string')
 580 | 	{
 581 | 		return _Debug_stringColor(ansi, '"' + _Debug_addSlashes(value, false) + '"');
 582 | 	}
 583 | 
 584 | 	if (typeof value === 'object' && '$' in value)
 585 | 	{
 586 | 		var tag = value.$;
 587 | 
 588 | 		if (typeof tag === 'number')
 589 | 		{
 590 | 			return _Debug_internalColor(ansi, '<internals>');
 591 | 		}
 592 | 
 593 | 		if (tag[0] === '#')
 594 | 		{
 595 | 			var output = [];
 596 | 			for (var k in value)
 597 | 			{
 598 | 				if (k === '$') continue;
 599 | 				output.push(_Debug_toAnsiString(ansi, value[k]));
 600 | 			}
 601 | 			return '(' + output.join(',') + ')';
 602 | 		}
 603 | 
 604 | 		if (tag === 'Set_elm_builtin')
 605 | 		{
 606 | 			return _Debug_ctorColor(ansi, 'Set')
 607 | 				+ _Debug_fadeColor(ansi, '.fromList') + ' '
 608 | 				+ _Debug_toAnsiString(ansi, $elm$core$Set$toList(value));
 609 | 		}
 610 | 
 611 | 		if (tag === 'RBNode_elm_builtin' || tag === 'RBEmpty_elm_builtin')
 612 | 		{
 613 | 			return _Debug_ctorColor(ansi, 'Dict')
 614 | 				+ _Debug_fadeColor(ansi, '.fromList') + ' '
 615 | 				+ _Debug_toAnsiString(ansi, $elm$core$Dict$toList(value));
 616 | 		}
 617 | 
 618 | 		if (tag === 'Array_elm_builtin')
 619 | 		{
 620 | 			return _Debug_ctorColor(ansi, 'Array')
 621 | 				+ _Debug_fadeColor(ansi, '.fromList') + ' '
 622 | 				+ _Debug_toAnsiString(ansi, $elm$core$Array$toList(value));
 623 | 		}
 624 | 
 625 | 		if (tag === '::' || tag === '[]')
 626 | 		{
 627 | 			var output = '[';
 628 | 
 629 | 			value.b && (output += _Debug_toAnsiString(ansi, value.a), value = value.b)
 630 | 
 631 | 			for (; value.b; value = value.b) // WHILE_CONS
 632 | 			{
 633 | 				output += ',' + _Debug_toAnsiString(ansi, value.a);
 634 | 			}
 635 | 			return output + ']';
 636 | 		}
 637 | 
 638 | 		var output = '';
 639 | 		for (var i in value)
 640 | 		{
 641 | 			if (i === '$') continue;
 642 | 			var str = _Debug_toAnsiString(ansi, value[i]);
 643 | 			var c0 = str[0];
 644 | 			var parenless = c0 === '{' || c0 === '(' || c0 === '[' || c0 === '<' || c0 === '"' || str.indexOf(' ') < 0;
 645 | 			output += ' ' + (parenless ? str : '(' + str + ')');
 646 | 		}
 647 | 		return _Debug_ctorColor(ansi, tag) + output;
 648 | 	}
 649 | 
 650 | 	if (typeof DataView === 'function' && value instanceof DataView)
 651 | 	{
 652 | 		return _Debug_stringColor(ansi, '<' + value.byteLength + ' bytes>');
 653 | 	}
 654 | 
 655 | 	if (typeof File !== 'undefined' && value instanceof File)
 656 | 	{
 657 | 		return _Debug_internalColor(ansi, '<' + value.name + '>');
 658 | 	}
 659 | 
 660 | 	if (typeof value === 'object')
 661 | 	{
 662 | 		var output = [];
 663 | 		for (var key in value)
 664 | 		{
 665 | 			var field = key[0] === '_' ? key.slice(1) : key;
 666 | 			output.push(_Debug_fadeColor(ansi, field) + ' = ' + _Debug_toAnsiString(ansi, value[key]));
 667 | 		}
 668 | 		if (output.length === 0)
 669 | 		{
 670 | 			return '{}';
 671 | 		}
 672 | 		return '{ ' + output.join(', ') + ' }';
 673 | 	}
 674 | 
 675 | 	return _Debug_internalColor(ansi, '<internals>');
 676 | }
 677 | 
 678 | function _Debug_addSlashes(str, isChar)
 679 | {
 680 | 	var s = str
 681 | 		.replace(/\\/g, '\\\\')
 682 | 		.replace(/\n/g, '\\n')
 683 | 		.replace(/\t/g, '\\t')
 684 | 		.replace(/\r/g, '\\r')
 685 | 		.replace(/\v/g, '\\v')
 686 | 		.replace(/\0/g, '\\0');
 687 | 
 688 | 	if (isChar)
 689 | 	{
 690 | 		return s.replace(/\'/g, '\\\'');
 691 | 	}
 692 | 	else
 693 | 	{
 694 | 		return s.replace(/\"/g, '\\"');
 695 | 	}
 696 | }
 697 | 
 698 | function _Debug_ctorColor(ansi, string)
 699 | {
 700 | 	return ansi ? '\x1b[96m' + string + '\x1b[0m' : string;
 701 | }
 702 | 
 703 | function _Debug_numberColor(ansi, string)
 704 | {
 705 | 	return ansi ? '\x1b[95m' + string + '\x1b[0m' : string;
 706 | }
 707 | 
 708 | function _Debug_stringColor(ansi, string)
 709 | {
 710 | 	return ansi ? '\x1b[93m' + string + '\x1b[0m' : string;
 711 | }
 712 | 
 713 | function _Debug_charColor(ansi, string)
 714 | {
 715 | 	return ansi ? '\x1b[92m' + string + '\x1b[0m' : string;
 716 | }
 717 | 
 718 | function _Debug_fadeColor(ansi, string)
 719 | {
 720 | 	return ansi ? '\x1b[37m' + string + '\x1b[0m' : string;
 721 | }
 722 | 
 723 | function _Debug_internalColor(ansi, string)
 724 | {
 725 | 	return ansi ? '\x1b[36m' + string + '\x1b[0m' : string;
 726 | }
 727 | 
 728 | function _Debug_toHexDigit(n)
 729 | {
 730 | 	return String.fromCharCode(n < 10 ? 48 + n : 55 + n);
 731 | }
 732 | 
 733 | 
 734 | // CRASH
 735 | 
 736 | 
 737 | function _Debug_crash_UNUSED(identifier)
 738 | {
 739 | 	throw new Error('https://github.com/elm/core/blob/1.0.0/hints/' + identifier + '.md');
 740 | }
 741 | 
 742 | 
 743 | function _Debug_crash(identifier, fact1, fact2, fact3, fact4)
 744 | {
 745 | 	switch(identifier)
 746 | 	{
 747 | 		case 0:
 748 | 			throw new Error('What node should I take over? In JavaScript I need something like:\n\n    Elm.Main.init({\n        node: document.getElementById("elm-node")\n    })\n\nYou need to do this with any Browser.sandbox or Browser.element program.');
 749 | 
 750 | 		case 1:
 751 | 			throw new Error('Browser.application programs cannot handle URLs like this:\n\n    ' + document.location.href + '\n\nWhat is the root? The root of your file system? Try looking at this program with `elm reactor` or some other server.');
 752 | 
 753 | 		case 2:
 754 | 			var jsonErrorString = fact1;
 755 | 			throw new Error('Problem with the flags given to your Elm program on initialization.\n\n' + jsonErrorString);
 756 | 
 757 | 		case 3:
 758 | 			var portName = fact1;
 759 | 			throw new Error('There can only be one port named `' + portName + '`, but your program has multiple.');
 760 | 
 761 | 		case 4:
 762 | 			var portName = fact1;
 763 | 			var problem = fact2;
 764 | 			throw new Error('Trying to send an unexpected type of value through port `' + portName + '`:\n' + problem);
 765 | 
 766 | 		case 5:
 767 | 			throw new Error('Trying to use `(==)` on functions.\nThere is no way to know if functions are "the same" in the Elm sense.\nRead more about this at https://package.elm-lang.org/packages/elm/core/latest/Basics#== which describes why it is this way and what the better version will look like.');
 768 | 
 769 | 		case 6:
 770 | 			var moduleName = fact1;
 771 | 			throw new Error('Your page is loading multiple Elm scripts with a module named ' + moduleName + '. Maybe a duplicate script is getting loaded accidentally? If not, rename one of them so I know which is which!');
 772 | 
 773 | 		case 8:
 774 | 			var moduleName = fact1;
 775 | 			var region = fact2;
 776 | 			var message = fact3;
 777 | 			throw new Error('TODO in module `' + moduleName + '` ' + _Debug_regionToString(region) + '\n\n' + message);
 778 | 
 779 | 		case 9:
 780 | 			var moduleName = fact1;
 781 | 			var region = fact2;
 782 | 			var value = fact3;
 783 | 			var message = fact4;
 784 | 			throw new Error(
 785 | 				'TODO in module `' + moduleName + '` from the `case` expression '
 786 | 				+ _Debug_regionToString(region) + '\n\nIt received the following value:\n\n    '
 787 | 				+ _Debug_toString(value).replace('\n', '\n    ')
 788 | 				+ '\n\nBut the branch that handles it says:\n\n    ' + message.replace('\n', '\n    ')
 789 | 			);
 790 | 
 791 | 		case 10:
 792 | 			throw new Error('Bug in https://github.com/elm/virtual-dom/issues');
 793 | 
 794 | 		case 11:
 795 | 			throw new Error('Cannot perform mod 0. Division by zero error.');
 796 | 	}
 797 | }
 798 | 
 799 | function _Debug_regionToString(region)
 800 | {
 801 | 	if (region.start.line === region.end.line)
 802 | 	{
 803 | 		return 'on line ' + region.start.line;
 804 | 	}
 805 | 	return 'on lines ' + region.start.line + ' through ' + region.end.line;
 806 | }
 807 | 
 808 | 
 809 | 
 810 | // MATH
 811 | 
 812 | var _Basics_add = F2(function(a, b) { return a + b; });
 813 | var _Basics_sub = F2(function(a, b) { return a - b; });
 814 | var _Basics_mul = F2(function(a, b) { return a * b; });
 815 | var _Basics_fdiv = F2(function(a, b) { return a / b; });
 816 | var _Basics_idiv = F2(function(a, b) { return (a / b) | 0; });
 817 | var _Basics_pow = F2(Math.pow);
 818 | 
 819 | var _Basics_remainderBy = F2(function(b, a) { return a % b; });
 820 | 
 821 | // https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf
 822 | var _Basics_modBy = F2(function(modulus, x)
 823 | {
 824 | 	var answer = x % modulus;
 825 | 	return modulus === 0
 826 | 		? _Debug_crash(11)
 827 | 		:
 828 | 	((answer > 0 && modulus < 0) || (answer < 0 && modulus > 0))
 829 | 		? answer + modulus
 830 | 		: answer;
 831 | });
 832 | 
 833 | 
 834 | // TRIGONOMETRY
 835 | 
 836 | var _Basics_pi = Math.PI;
 837 | var _Basics_e = Math.E;
 838 | var _Basics_cos = Math.cos;
 839 | var _Basics_sin = Math.sin;
 840 | var _Basics_tan = Math.tan;
 841 | var _Basics_acos = Math.acos;
 842 | var _Basics_asin = Math.asin;
 843 | var _Basics_atan = Math.atan;
 844 | var _Basics_atan2 = F2(Math.atan2);
 845 | 
 846 | 
 847 | // MORE MATH
 848 | 
 849 | function _Basics_toFloat(x) { return x; }
 850 | function _Basics_truncate(n) { return n | 0; }
 851 | function _Basics_isInfinite(n) { return n === Infinity || n === -Infinity; }
 852 | 
 853 | var _Basics_ceiling = Math.ceil;
 854 | var _Basics_floor = Math.floor;
 855 | var _Basics_round = Math.round;
 856 | var _Basics_sqrt = Math.sqrt;
 857 | var _Basics_log = Math.log;
 858 | var _Basics_isNaN = isNaN;
 859 | 
 860 | 
 861 | // BOOLEANS
 862 | 
 863 | function _Basics_not(bool) { return !bool; }
 864 | var _Basics_and = F2(function(a, b) { return a && b; });
 865 | var _Basics_or  = F2(function(a, b) { return a || b; });
 866 | var _Basics_xor = F2(function(a, b) { return a !== b; });
 867 | 
 868 | 
 869 | 
 870 | var _String_cons = F2(function(chr, str)
 871 | {
 872 | 	return chr + str;
 873 | });
 874 | 
 875 | function _String_uncons(string)
 876 | {
 877 | 	var word = string.charCodeAt(0);
 878 | 	return !isNaN(word)
 879 | 		? $elm$core$Maybe$Just(
 880 | 			0xD800 <= word && word <= 0xDBFF
 881 | 				? _Utils_Tuple2(_Utils_chr(string[0] + string[1]), string.slice(2))
 882 | 				: _Utils_Tuple2(_Utils_chr(string[0]), string.slice(1))
 883 | 		)
 884 | 		: $elm$core$Maybe$Nothing;
 885 | }
 886 | 
 887 | var _String_append = F2(function(a, b)
 888 | {
 889 | 	return a + b;
 890 | });
 891 | 
 892 | function _String_length(str)
 893 | {
 894 | 	return str.length;
 895 | }
 896 | 
 897 | var _String_map = F2(function(func, string)
 898 | {
 899 | 	var len = string.length;
 900 | 	var array = new Array(len);
 901 | 	var i = 0;
 902 | 	while (i < len)
 903 | 	{
 904 | 		var word = string.charCodeAt(i);
 905 | 		if (0xD800 <= word && word <= 0xDBFF)
 906 | 		{
 907 | 			array[i] = func(_Utils_chr(string[i] + string[i+1]));
 908 | 			i += 2;
 909 | 			continue;
 910 | 		}
 911 | 		array[i] = func(_Utils_chr(string[i]));
 912 | 		i++;
 913 | 	}
 914 | 	return array.join('');
 915 | });
 916 | 
 917 | var _String_filter = F2(function(isGood, str)
 918 | {
 919 | 	var arr = [];
 920 | 	var len = str.length;
 921 | 	var i = 0;
 922 | 	while (i < len)
 923 | 	{
 924 | 		var char = str[i];
 925 | 		var word = str.charCodeAt(i);
 926 | 		i++;
 927 | 		if (0xD800 <= word && word <= 0xDBFF)
 928 | 		{
 929 | 			char += str[i];
 930 | 			i++;
 931 | 		}
 932 | 
 933 | 		if (isGood(_Utils_chr(char)))
 934 | 		{
 935 | 			arr.push(char);
 936 | 		}
 937 | 	}
 938 | 	return arr.join('');
 939 | });
 940 | 
 941 | function _String_reverse(str)
 942 | {
 943 | 	var len = str.length;
 944 | 	var arr = new Array(len);
 945 | 	var i = 0;
 946 | 	while (i < len)
 947 | 	{
 948 | 		var word = str.charCodeAt(i);
 949 | 		if (0xD800 <= word && word <= 0xDBFF)
 950 | 		{
 951 | 			arr[len - i] = str[i + 1];
 952 | 			i++;
 953 | 			arr[len - i] = str[i - 1];
 954 | 			i++;
 955 | 		}
 956 | 		else
 957 | 		{
 958 | 			arr[len - i] = str[i];
 959 | 			i++;
 960 | 		}
 961 | 	}
 962 | 	return arr.join('');
 963 | }
 964 | 
 965 | var _String_foldl = F3(function(func, state, string)
 966 | {
 967 | 	var len = string.length;
 968 | 	var i = 0;
 969 | 	while (i < len)
 970 | 	{
 971 | 		var char = string[i];
 972 | 		var word = string.charCodeAt(i);
 973 | 		i++;
 974 | 		if (0xD800 <= word && word <= 0xDBFF)
 975 | 		{
 976 | 			char += string[i];
 977 | 			i++;
 978 | 		}
 979 | 		state = A2(func, _Utils_chr(char), state);
 980 | 	}
 981 | 	return state;
 982 | });
 983 | 
 984 | var _String_foldr = F3(function(func, state, string)
 985 | {
 986 | 	var i = string.length;
 987 | 	while (i--)
 988 | 	{
 989 | 		var char = string[i];
 990 | 		var word = string.charCodeAt(i);
 991 | 		if (0xDC00 <= word && word <= 0xDFFF)
 992 | 		{
 993 | 			i--;
 994 | 			char = string[i] + char;
 995 | 		}
 996 | 		state = A2(func, _Utils_chr(char), state);
 997 | 	}
 998 | 	return state;
 999 | });
1000 | 
1001 | var _String_split = F2(function(sep, str)
1002 | {
1003 | 	return str.split(sep);
1004 | });
1005 | 
1006 | var _String_join = F2(function(sep, strs)
1007 | {
1008 | 	return strs.join(sep);
1009 | });
1010 | 
1011 | var _String_slice = F3(function(start, end, str) {
1012 | 	return str.slice(start, end);
1013 | });
1014 | 
1015 | function _String_trim(str)
1016 | {
1017 | 	return str.trim();
1018 | }
1019 | 
1020 | function _String_trimLeft(str)
1021 | {
1022 | 	return str.replace(/^\s+/, '');
1023 | }
1024 | 
1025 | function _String_trimRight(str)
1026 | {
1027 | 	return str.replace(/\s+$/, '');
1028 | }
1029 | 
1030 | function _String_words(str)
1031 | {
1032 | 	return _List_fromArray(str.trim().split(/\s+/g));
1033 | }
1034 | 
1035 | function _String_lines(str)
1036 | {
1037 | 	return _List_fromArray(str.split(/\r\n|\r|\n/g));
1038 | }
1039 | 
1040 | function _String_toUpper(str)
1041 | {
1042 | 	return str.toUpperCase();
1043 | }
1044 | 
1045 | function _String_toLower(str)
1046 | {
1047 | 	return str.toLowerCase();
1048 | }
1049 | 
1050 | var _String_any = F2(function(isGood, string)
1051 | {
1052 | 	var i = string.length;
1053 | 	while (i--)
1054 | 	{
1055 | 		var char = string[i];
1056 | 		var word = string.charCodeAt(i);
1057 | 		if (0xDC00 <= word && word <= 0xDFFF)
1058 | 		{
1059 | 			i--;
1060 | 			char = string[i] + char;
1061 | 		}
1062 | 		if (isGood(_Utils_chr(char)))
1063 | 		{
1064 | 			return true;
1065 | 		}
1066 | 	}
1067 | 	return false;
1068 | });
1069 | 
1070 | var _String_all = F2(function(isGood, string)
1071 | {
1072 | 	var i = string.length;
1073 | 	while (i--)
1074 | 	{
1075 | 		var char = string[i];
1076 | 		var word = string.charCodeAt(i);
1077 | 		if (0xDC00 <= word && word <= 0xDFFF)
1078 | 		{
1079 | 			i--;
1080 | 			char = string[i] + char;
1081 | 		}
1082 | 		if (!isGood(_Utils_chr(char)))
1083 | 		{
1084 | 			return false;
1085 | 		}
1086 | 	}
1087 | 	return true;
1088 | });
1089 | 
1090 | var _String_contains = F2(function(sub, str)
1091 | {
1092 | 	return str.indexOf(sub) > -1;
1093 | });
1094 | 
1095 | var _String_startsWith = F2(function(sub, str)
1096 | {
1097 | 	return str.indexOf(sub) === 0;
1098 | });
1099 | 
1100 | var _String_endsWith = F2(function(sub, str)
1101 | {
1102 | 	return str.length >= sub.length &&
1103 | 		str.lastIndexOf(sub) === str.length - sub.length;
1104 | });
1105 | 
1106 | var _String_indexes = F2(function(sub, str)
1107 | {
1108 | 	var subLen = sub.length;
1109 | 
1110 | 	if (subLen < 1)
1111 | 	{
1112 | 		return _List_Nil;
1113 | 	}
1114 | 
1115 | 	var i = 0;
1116 | 	var is = [];
1117 | 
1118 | 	while ((i = str.indexOf(sub, i)) > -1)
1119 | 	{
1120 | 		is.push(i);
1121 | 		i = i + subLen;
1122 | 	}
1123 | 
1124 | 	return _List_fromArray(is);
1125 | });
1126 | 
1127 | 
1128 | // TO STRING
1129 | 
1130 | function _String_fromNumber(number)
1131 | {
1132 | 	return number + '';
1133 | }
1134 | 
1135 | 
1136 | // INT CONVERSIONS
1137 | 
1138 | function _String_toInt(str)
1139 | {
1140 | 	var total = 0;
1141 | 	var code0 = str.charCodeAt(0);
1142 | 	var start = code0 == 0x2B /* + */ || code0 == 0x2D /* - */ ? 1 : 0;
1143 | 
1144 | 	for (var i = start; i < str.length; ++i)
1145 | 	{
1146 | 		var code = str.charCodeAt(i);
1147 | 		if (code < 0x30 || 0x39 < code)
1148 | 		{
1149 | 			return $elm$core$Maybe$Nothing;
1150 | 		}
1151 | 		total = 10 * total + code - 0x30;
1152 | 	}
1153 | 
1154 | 	return i == start
1155 | 		? $elm$core$Maybe$Nothing
1156 | 		: $elm$core$Maybe$Just(code0 == 0x2D ? -total : total);
1157 | }
1158 | 
1159 | 
1160 | // FLOAT CONVERSIONS
1161 | 
1162 | function _String_toFloat(s)
1163 | {
1164 | 	// check if it is a hex, octal, or binary number
1165 | 	if (s.length === 0 || /[\sxbo]/.test(s))
1166 | 	{
1167 | 		return $elm$core$Maybe$Nothing;
1168 | 	}
1169 | 	var n = +s;
1170 | 	// faster isNaN check
1171 | 	return n === n ? $elm$core$Maybe$Just(n) : $elm$core$Maybe$Nothing;
1172 | }
1173 | 
1174 | function _String_fromList(chars)
1175 | {
1176 | 	return _List_toArray(chars).join('');
1177 | }
1178 | 
1179 | 
1180 | 
1181 | 
1182 | function _Char_toCode(char)
1183 | {
1184 | 	var code = char.charCodeAt(0);
1185 | 	if (0xD800 <= code && code <= 0xDBFF)
1186 | 	{
1187 | 		return (code - 0xD800) * 0x400 + char.charCodeAt(1) - 0xDC00 + 0x10000
1188 | 	}
1189 | 	return code;
1190 | }
1191 | 
1192 | function _Char_fromCode(code)
1193 | {
1194 | 	return _Utils_chr(
1195 | 		(code < 0 || 0x10FFFF < code)
1196 | 			? '\uFFFD'
1197 | 			:
1198 | 		(code <= 0xFFFF)
1199 | 			? String.fromCharCode(code)
1200 | 			:
1201 | 		(code -= 0x10000,
1202 | 			String.fromCharCode(Math.floor(code / 0x400) + 0xD800, code % 0x400 + 0xDC00)
1203 | 		)
1204 | 	);
1205 | }
1206 | 
1207 | function _Char_toUpper(char)
1208 | {
1209 | 	return _Utils_chr(char.toUpperCase());
1210 | }
1211 | 
1212 | function _Char_toLower(char)
1213 | {
1214 | 	return _Utils_chr(char.toLowerCase());
1215 | }
1216 | 
1217 | function _Char_toLocaleUpper(char)
1218 | {
1219 | 	return _Utils_chr(char.toLocaleUpperCase());
1220 | }
1221 | 
1222 | function _Char_toLocaleLower(char)
1223 | {
1224 | 	return _Utils_chr(char.toLocaleLowerCase());
1225 | }
1226 | 
1227 | 
1228 | 
1229 | /**/
1230 | function _Json_errorToString(error)
1231 | {
1232 | 	return $elm$json$Json$Decode$errorToString(error);
1233 | }
1234 | //*/
1235 | 
1236 | 
1237 | // CORE DECODERS
1238 | 
1239 | function _Json_succeed(msg)
1240 | {
1241 | 	return {
1242 | 		$: 0,
1243 | 		a: msg
1244 | 	};
1245 | }
1246 | 
1247 | function _Json_fail(msg)
1248 | {
1249 | 	return {
1250 | 		$: 1,
1251 | 		a: msg
1252 | 	};
1253 | }
1254 | 
1255 | function _Json_decodePrim(decoder)
1256 | {
1257 | 	return { $: 2, b: decoder };
1258 | }
1259 | 
1260 | var _Json_decodeInt = _Json_decodePrim(function(value) {
1261 | 	return (typeof value !== 'number')
1262 | 		? _Json_expecting('an INT', value)
1263 | 		:
1264 | 	(-2147483647 < value && value < 2147483647 && (value | 0) === value)
1265 | 		? $elm$core$Result$Ok(value)
1266 | 		:
1267 | 	(isFinite(value) && !(value % 1))
1268 | 		? $elm$core$Result$Ok(value)
1269 | 		: _Json_expecting('an INT', value);
1270 | });
1271 | 
1272 | var _Json_decodeBool = _Json_decodePrim(function(value) {
1273 | 	return (typeof value === 'boolean')
1274 | 		? $elm$core$Result$Ok(value)
1275 | 		: _Json_expecting('a BOOL', value);
1276 | });
1277 | 
1278 | var _Json_decodeFloat = _Json_decodePrim(function(value) {
1279 | 	return (typeof value === 'number')
1280 | 		? $elm$core$Result$Ok(value)
1281 | 		: _Json_expecting('a FLOAT', value);
1282 | });
1283 | 
1284 | var _Json_decodeValue = _Json_decodePrim(function(value) {
1285 | 	return $elm$core$Result$Ok(_Json_wrap(value));
1286 | });
1287 | 
1288 | var _Json_decodeString = _Json_decodePrim(function(value) {
1289 | 	return (typeof value === 'string')
1290 | 		? $elm$core$Result$Ok(value)
1291 | 		: (value instanceof String)
1292 | 			? $elm$core$Result$Ok(value + '')
1293 | 			: _Json_expecting('a STRING', value);
1294 | });
1295 | 
1296 | function _Json_decodeList(decoder) { return { $: 3, b: decoder }; }
1297 | function _Json_decodeArray(decoder) { return { $: 4, b: decoder }; }
1298 | 
1299 | function _Json_decodeNull(value) { return { $: 5, c: value }; }
1300 | 
1301 | var _Json_decodeField = F2(function(field, decoder)
1302 | {
1303 | 	return {
1304 | 		$: 6,
1305 | 		d: field,
1306 | 		b: decoder
1307 | 	};
1308 | });
1309 | 
1310 | var _Json_decodeIndex = F2(function(index, decoder)
1311 | {
1312 | 	return {
1313 | 		$: 7,
1314 | 		e: index,
1315 | 		b: decoder
1316 | 	};
1317 | });
1318 | 
1319 | function _Json_decodeKeyValuePairs(decoder)
1320 | {
1321 | 	return {
1322 | 		$: 8,
1323 | 		b: decoder
1324 | 	};
1325 | }
1326 | 
1327 | function _Json_mapMany(f, decoders)
1328 | {
1329 | 	return {
1330 | 		$: 9,
1331 | 		f: f,
1332 | 		g: decoders
1333 | 	};
1334 | }
1335 | 
1336 | var _Json_andThen = F2(function(callback, decoder)
1337 | {
1338 | 	return {
1339 | 		$: 10,
1340 | 		b: decoder,
1341 | 		h: callback
1342 | 	};
1343 | });
1344 | 
1345 | function _Json_oneOf(decoders)
1346 | {
1347 | 	return {
1348 | 		$: 11,
1349 | 		g: decoders
1350 | 	};
1351 | }
1352 | 
1353 | 
1354 | // DECODING OBJECTS
1355 | 
1356 | var _Json_map1 = F2(function(f, d1)
1357 | {
1358 | 	return _Json_mapMany(f, [d1]);
1359 | });
1360 | 
1361 | var _Json_map2 = F3(function(f, d1, d2)
1362 | {
1363 | 	return _Json_mapMany(f, [d1, d2]);
1364 | });
1365 | 
1366 | var _Json_map3 = F4(function(f, d1, d2, d3)
1367 | {
1368 | 	return _Json_mapMany(f, [d1, d2, d3]);
1369 | });
1370 | 
1371 | var _Json_map4 = F5(function(f, d1, d2, d3, d4)
1372 | {
1373 | 	return _Json_mapMany(f, [d1, d2, d3, d4]);
1374 | });
1375 | 
1376 | var _Json_map5 = F6(function(f, d1, d2, d3, d4, d5)
1377 | {
1378 | 	return _Json_mapMany(f, [d1, d2, d3, d4, d5]);
1379 | });
1380 | 
1381 | var _Json_map6 = F7(function(f, d1, d2, d3, d4, d5, d6)
1382 | {
1383 | 	return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6]);
1384 | });
1385 | 
1386 | var _Json_map7 = F8(function(f, d1, d2, d3, d4, d5, d6, d7)
1387 | {
1388 | 	return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6, d7]);
1389 | });
1390 | 
1391 | var _Json_map8 = F9(function(f, d1, d2, d3, d4, d5, d6, d7, d8)
1392 | {
1393 | 	return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6, d7, d8]);
1394 | });
1395 | 
1396 | 
1397 | // DECODE
1398 | 
1399 | var _Json_runOnString = F2(function(decoder, string)
1400 | {
1401 | 	try
1402 | 	{
1403 | 		var value = JSON.parse(string);
1404 | 		return _Json_runHelp(decoder, value);
1405 | 	}
1406 | 	catch (e)
1407 | 	{
1408 | 		return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, 'This is not valid JSON! ' + e.message, _Json_wrap(string)));
1409 | 	}
1410 | });
1411 | 
1412 | var _Json_run = F2(function(decoder, value)
1413 | {
1414 | 	return _Json_runHelp(decoder, _Json_unwrap(value));
1415 | });
1416 | 
1417 | function _Json_runHelp(decoder, value)
1418 | {
1419 | 	switch (decoder.$)
1420 | 	{
1421 | 		case 2:
1422 | 			return decoder.b(value);
1423 | 
1424 | 		case 5:
1425 | 			return (value === null)
1426 | 				? $elm$core$Result$Ok(decoder.c)
1427 | 				: _Json_expecting('null', value);
1428 | 
1429 | 		case 3:
1430 | 			if (!_Json_isArray(value))
1431 | 			{
1432 | 				return _Json_expecting('a LIST', value);
1433 | 			}
1434 | 			return _Json_runArrayDecoder(decoder.b, value, _List_fromArray);
1435 | 
1436 | 		case 4:
1437 | 			if (!_Json_isArray(value))
1438 | 			{
1439 | 				return _Json_expecting('an ARRAY', value);
1440 | 			}
1441 | 			return _Json_runArrayDecoder(decoder.b, value, _Json_toElmArray);
1442 | 
1443 | 		case 6:
1444 | 			var field = decoder.d;
1445 | 			if (typeof value !== 'object' || value === null || !(field in value))
1446 | 			{
1447 | 				return _Json_expecting('an OBJECT with a field named `' + field + '`', value);
1448 | 			}
1449 | 			var result = _Json_runHelp(decoder.b, value[field]);
1450 | 			return ($elm$core$Result$isOk(result)) ? result : $elm$core$Result$Err(A2($elm$json$Json$Decode$Field, field, result.a));
1451 | 
1452 | 		case 7:
1453 | 			var index = decoder.e;
1454 | 			if (!_Json_isArray(value))
1455 | 			{
1456 | 				return _Json_expecting('an ARRAY', value);
1457 | 			}
1458 | 			if (index >= value.length)
1459 | 			{
1460 | 				return _Json_expecting('a LONGER array. Need index ' + index + ' but only see ' + value.length + ' entries', value);
1461 | 			}
1462 | 			var result = _Json_runHelp(decoder.b, value[index]);
1463 | 			return ($elm$core$Result$isOk(result)) ? result : $elm$core$Result$Err(A2($elm$json$Json$Decode$Index, index, result.a));
1464 | 
1465 | 		case 8:
1466 | 			if (typeof value !== 'object' || value === null || _Json_isArray(value))
1467 | 			{
1468 | 				return _Json_expecting('an OBJECT', value);
1469 | 			}
1470 | 
1471 | 			var keyValuePairs = _List_Nil;
1472 | 			// TODO test perf of Object.keys and switch when support is good enough
1473 | 			for (var key in value)
1474 | 			{
1475 | 				if (value.hasOwnProperty(key))
1476 | 				{
1477 | 					var result = _Json_runHelp(decoder.b, value[key]);
1478 | 					if (!$elm$core$Result$isOk(result))
1479 | 					{
1480 | 						return $elm$core$Result$Err(A2($elm$json$Json$Decode$Field, key, result.a));
1481 | 					}
1482 | 					keyValuePairs = _List_Cons(_Utils_Tuple2(key, result.a), keyValuePairs);
1483 | 				}
1484 | 			}
1485 | 			return $elm$core$Result$Ok($elm$core$List$reverse(keyValuePairs));
1486 | 
1487 | 		case 9:
1488 | 			var answer = decoder.f;
1489 | 			var decoders = decoder.g;
1490 | 			for (var i = 0; i < decoders.length; i++)
1491 | 			{
1492 | 				var result = _Json_runHelp(decoders[i], value);
1493 | 				if (!$elm$core$Result$isOk(result))
1494 | 				{
1495 | 					return result;
1496 | 				}
1497 | 				answer = answer(result.a);
1498 | 			}
1499 | 			return $elm$core$Result$Ok(answer);
1500 | 
1501 | 		case 10:
1502 | 			var result = _Json_runHelp(decoder.b, value);
1503 | 			return (!$elm$core$Result$isOk(result))
1504 | 				? result
1505 | 				: _Json_runHelp(decoder.h(result.a), value);
1506 | 
1507 | 		case 11:
1508 | 			var errors = _List_Nil;
1509 | 			for (var temp = decoder.g; temp.b; temp = temp.b) // WHILE_CONS
1510 | 			{
1511 | 				var result = _Json_runHelp(temp.a, value);
1512 | 				if ($elm$core$Result$isOk(result))
1513 | 				{
1514 | 					return result;
1515 | 				}
1516 | 				errors = _List_Cons(result.a, errors);
1517 | 			}
1518 | 			return $elm$core$Result$Err($elm$json$Json$Decode$OneOf($elm$core$List$reverse(errors)));
1519 | 
1520 | 		case 1:
1521 | 			return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, decoder.a, _Json_wrap(value)));
1522 | 
1523 | 		case 0:
1524 | 			return $elm$core$Result$Ok(decoder.a);
1525 | 	}
1526 | }
1527 | 
1528 | function _Json_runArrayDecoder(decoder, value, toElmValue)
1529 | {
1530 | 	var len = value.length;
1531 | 	var array = new Array(len);
1532 | 	for (var i = 0; i < len; i++)
1533 | 	{
1534 | 		var result = _Json_runHelp(decoder, value[i]);
1535 | 		if (!$elm$core$Result$isOk(result))
1536 | 		{
1537 | 			return $elm$core$Result$Err(A2($elm$json$Json$Decode$Index, i, result.a));
1538 | 		}
1539 | 		array[i] = result.a;
1540 | 	}
1541 | 	return $elm$core$Result$Ok(toElmValue(array));
1542 | }
1543 | 
1544 | function _Json_isArray(value)
1545 | {
1546 | 	return Array.isArray(value) || (typeof FileList !== 'undefined' && value instanceof FileList);
1547 | }
1548 | 
1549 | function _Json_toElmArray(array)
1550 | {
1551 | 	return A2($elm$core$Array$initialize, array.length, function(i) { return array[i]; });
1552 | }
1553 | 
1554 | function _Json_expecting(type, value)
1555 | {
1556 | 	return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, 'Expecting ' + type, _Json_wrap(value)));
1557 | }
1558 | 
1559 | 
1560 | // EQUALITY
1561 | 
1562 | function _Json_equality(x, y)
1563 | {
1564 | 	if (x === y)
1565 | 	{
1566 | 		return true;
1567 | 	}
1568 | 
1569 | 	if (x.$ !== y.$)
1570 | 	{
1571 | 		return false;
1572 | 	}
1573 | 
1574 | 	switch (x.$)
1575 | 	{
1576 | 		case 0:
1577 | 		case 1:
1578 | 			return x.a === y.a;
1579 | 
1580 | 		case 2:
1581 | 			return x.b === y.b;
1582 | 
1583 | 		case 5:
1584 | 			return x.c === y.c;
1585 | 
1586 | 		case 3:
1587 | 		case 4:
1588 | 		case 8:
1589 | 			return _Json_equality(x.b, y.b);
1590 | 
1591 | 		case 6:
1592 | 			return x.d === y.d && _Json_equality(x.b, y.b);
1593 | 
1594 | 		case 7:
1595 | 			return x.e === y.e && _Json_equality(x.b, y.b);
1596 | 
1597 | 		case 9:
1598 | 			return x.f === y.f && _Json_listEquality(x.g, y.g);
1599 | 
1600 | 		case 10:
1601 | 			return x.h === y.h && _Json_equality(x.b, y.b);
1602 | 
1603 | 		case 11:
1604 | 			return _Json_listEquality(x.g, y.g);
1605 | 	}
1606 | }
1607 | 
1608 | function _Json_listEquality(aDecoders, bDecoders)
1609 | {
1610 | 	var len = aDecoders.length;
1611 | 	if (len !== bDecoders.length)
1612 | 	{
1613 | 		return false;
1614 | 	}
1615 | 	for (var i = 0; i < len; i++)
1616 | 	{
1617 | 		if (!_Json_equality(aDecoders[i], bDecoders[i]))
1618 | 		{
1619 | 			return false;
1620 | 		}
1621 | 	}
1622 | 	return true;
1623 | }
1624 | 
1625 | 
1626 | // ENCODE
1627 | 
1628 | var _Json_encode = F2(function(indentLevel, value)
1629 | {
1630 | 	return JSON.stringify(_Json_unwrap(value), null, indentLevel) + '';
1631 | });
1632 | 
1633 | function _Json_wrap(value) { return { $: 0, a: value }; }
1634 | function _Json_unwrap(value) { return value.a; }
1635 | 
1636 | function _Json_wrap_UNUSED(value) { return value; }
1637 | function _Json_unwrap_UNUSED(value) { return value; }
1638 | 
1639 | function _Json_emptyArray() { return []; }
1640 | function _Json_emptyObject() { return {}; }
1641 | 
1642 | var _Json_addField = F3(function(key, value, object)
1643 | {
1644 | 	object[key] = _Json_unwrap(value);
1645 | 	return object;
1646 | });
1647 | 
1648 | function _Json_addEntry(func)
1649 | {
1650 | 	return F2(function(entry, array)
1651 | 	{
1652 | 		array.push(_Json_unwrap(func(entry)));
1653 | 		return array;
1654 | 	});
1655 | }
1656 | 
1657 | var _Json_encodeNull = _Json_wrap(null);
1658 | 
1659 | 
1660 | 
1661 | // TASKS
1662 | 
1663 | function _Scheduler_succeed(value)
1664 | {
1665 | 	return {
1666 | 		$: 0,
1667 | 		a: value
1668 | 	};
1669 | }
1670 | 
1671 | function _Scheduler_fail(error)
1672 | {
1673 | 	return {
1674 | 		$: 1,
1675 | 		a: error
1676 | 	};
1677 | }
1678 | 
1679 | function _Scheduler_binding(callback)
1680 | {
1681 | 	return {
1682 | 		$: 2,
1683 | 		b: callback,
1684 | 		c: null
1685 | 	};
1686 | }
1687 | 
1688 | var _Scheduler_andThen = F2(function(callback, task)
1689 | {
1690 | 	return {
1691 | 		$: 3,
1692 | 		b: callback,
1693 | 		d: task
1694 | 	};
1695 | });
1696 | 
1697 | var _Scheduler_onError = F2(function(callback, task)
1698 | {
1699 | 	return {
1700 | 		$: 4,
1701 | 		b: callback,
1702 | 		d: task
1703 | 	};
1704 | });
1705 | 
1706 | function _Scheduler_receive(callback)
1707 | {
1708 | 	return {
1709 | 		$: 5,
1710 | 		b: callback
1711 | 	};
1712 | }
1713 | 
1714 | 
1715 | // PROCESSES
1716 | 
1717 | var _Scheduler_guid = 0;
1718 | 
1719 | function _Scheduler_rawSpawn(task)
1720 | {
1721 | 	var proc = {
1722 | 		$: 0,
1723 | 		e: _Scheduler_guid++,
1724 | 		f: task,
1725 | 		g: null,
1726 | 		h: []
1727 | 	};
1728 | 
1729 | 	_Scheduler_enqueue(proc);
1730 | 
1731 | 	return proc;
1732 | }
1733 | 
1734 | function _Scheduler_spawn(task)
1735 | {
1736 | 	return _Scheduler_binding(function(callback) {
1737 | 		callback(_Scheduler_succeed(_Scheduler_rawSpawn(task)));
1738 | 	});
1739 | }
1740 | 
1741 | function _Scheduler_rawSend(proc, msg)
1742 | {
1743 | 	proc.h.push(msg);
1744 | 	_Scheduler_enqueue(proc);
1745 | }
1746 | 
1747 | var _Scheduler_send = F2(function(proc, msg)
1748 | {
1749 | 	return _Scheduler_binding(function(callback) {
1750 | 		_Scheduler_rawSend(proc, msg);
1751 | 		callback(_Scheduler_succeed(_Utils_Tuple0));
1752 | 	});
1753 | });
1754 | 
1755 | function _Scheduler_kill(proc)
1756 | {
1757 | 	return _Scheduler_binding(function(callback) {
1758 | 		var task = proc.f;
1759 | 		if (task.$ === 2 && task.c)
1760 | 		{
1761 | 			task.c();
1762 | 		}
1763 | 
1764 | 		proc.f = null;
1765 | 
1766 | 		callback(_Scheduler_succeed(_Utils_Tuple0));
1767 | 	});
1768 | }
1769 | 
1770 | 
1771 | /* STEP PROCESSES
1772 | 
1773 | type alias Process =
1774 |   { $ : tag
1775 |   , id : unique_id
1776 |   , root : Task
1777 |   , stack : null | { $: SUCCEED | FAIL, a: callback, b: stack }
1778 |   , mailbox : [msg]
1779 |   }
1780 | 
1781 | */
1782 | 
1783 | 
1784 | var _Scheduler_working = false;
1785 | var _Scheduler_queue = [];
1786 | 
1787 | 
1788 | function _Scheduler_enqueue(proc)
1789 | {
1790 | 	_Scheduler_queue.push(proc);
1791 | 	if (_Scheduler_working)
1792 | 	{
1793 | 		return;
1794 | 	}
1795 | 	_Scheduler_working = true;
1796 | 	while (proc = _Scheduler_queue.shift())
1797 | 	{
1798 | 		_Scheduler_step(proc);
1799 | 	}
1800 | 	_Scheduler_working = false;
1801 | }
1802 | 
1803 | 
1804 | function _Scheduler_step(proc)
1805 | {
1806 | 	while (proc.f)
1807 | 	{
1808 | 		var rootTag = proc.f.$;
1809 | 		if (rootTag === 0 || rootTag === 1)
1810 | 		{
1811 | 			while (proc.g && proc.g.$ !== rootTag)
1812 | 			{
1813 | 				proc.g = proc.g.i;
1814 | 			}
1815 | 			if (!proc.g)
1816 | 			{
1817 | 				return;
1818 | 			}
1819 | 			proc.f = proc.g.b(proc.f.a);
1820 | 			proc.g = proc.g.i;
1821 | 		}
1822 | 		else if (rootTag === 2)
1823 | 		{
1824 | 			proc.f.c = proc.f.b(function(newRoot) {
1825 | 				proc.f = newRoot;
1826 | 				_Scheduler_enqueue(proc);
1827 | 			});
1828 | 			return;
1829 | 		}
1830 | 		else if (rootTag === 5)
1831 | 		{
1832 | 			if (proc.h.length === 0)
1833 | 			{
1834 | 				return;
1835 | 			}
1836 | 			proc.f = proc.f.b(proc.h.shift());
1837 | 		}
1838 | 		else // if (rootTag === 3 || rootTag === 4)
1839 | 		{
1840 | 			proc.g = {
1841 | 				$: rootTag === 3 ? 0 : 1,
1842 | 				b: proc.f.b,
1843 | 				i: proc.g
1844 | 			};
1845 | 			proc.f = proc.f.d;
1846 | 		}
1847 | 	}
1848 | }
1849 | 
1850 | 
1851 | 
1852 | function _Process_sleep(time)
1853 | {
1854 | 	return _Scheduler_binding(function(callback) {
1855 | 		var id = setTimeout(function() {
1856 | 			callback(_Scheduler_succeed(_Utils_Tuple0));
1857 | 		}, time);
1858 | 
1859 | 		return function() { clearTimeout(id); };
1860 | 	});
1861 | }
1862 | 
1863 | 
1864 | 
1865 | 
1866 | // PROGRAMS
1867 | 
1868 | 
1869 | var _Platform_worker = F4(function(impl, flagDecoder, debugMetadata, args)
1870 | {
1871 | 	return _Platform_initialize(
1872 | 		flagDecoder,
1873 | 		args,
1874 | 		impl.init,
1875 | 		impl.update,
1876 | 		impl.subscriptions,
1877 | 		function() { return function() {} }
1878 | 	);
1879 | });
1880 | 
1881 | 
1882 | 
1883 | // INITIALIZE A PROGRAM
1884 | 
1885 | 
1886 | function _Platform_initialize(flagDecoder, args, init, update, subscriptions, stepperBuilder)
1887 | {
1888 | 	var result = A2(_Json_run, flagDecoder, _Json_wrap(args ? args['flags'] : undefined));
1889 | 	$elm$core$Result$isOk(result) || _Debug_crash(2 /**/, _Json_errorToString(result.a) /**/);
1890 | 	var managers = {};
1891 | 	var initPair = init(result.a);
1892 | 	var model = initPair.a;
1893 | 	var stepper = stepperBuilder(sendToApp, model);
1894 | 	var ports = _Platform_setupEffects(managers, sendToApp);
1895 | 
1896 | 	function sendToApp(msg, viewMetadata)
1897 | 	{
1898 | 		var pair = A2(update, msg, model);
1899 | 		stepper(model = pair.a, viewMetadata);
1900 | 		_Platform_enqueueEffects(managers, pair.b, subscriptions(model));
1901 | 	}
1902 | 
1903 | 	_Platform_enqueueEffects(managers, initPair.b, subscriptions(model));
1904 | 
1905 | 	return ports ? { ports: ports } : {};
1906 | }
1907 | 
1908 | 
1909 | 
1910 | // TRACK PRELOADS
1911 | //
1912 | // This is used by code in elm/browser and elm/http
1913 | // to register any HTTP requests that are triggered by init.
1914 | //
1915 | 
1916 | 
1917 | var _Platform_preload;
1918 | 
1919 | 
1920 | function _Platform_registerPreload(url)
1921 | {
1922 | 	_Platform_preload.add(url);
1923 | }
1924 | 
1925 | 
1926 | 
1927 | // EFFECT MANAGERS
1928 | 
1929 | 
1930 | var _Platform_effectManagers = {};
1931 | 
1932 | 
1933 | function _Platform_setupEffects(managers, sendToApp)
1934 | {
1935 | 	var ports;
1936 | 
1937 | 	// setup all necessary effect managers
1938 | 	for (var key in _Platform_effectManagers)
1939 | 	{
1940 | 		var manager = _Platform_effectManagers[key];
1941 | 
1942 | 		if (manager.a)
1943 | 		{
1944 | 			ports = ports || {};
1945 | 			ports[key] = manager.a(key, sendToApp);
1946 | 		}
1947 | 
1948 | 		managers[key] = _Platform_instantiateManager(manager, sendToApp);
1949 | 	}
1950 | 
1951 | 	return ports;
1952 | }
1953 | 
1954 | 
1955 | function _Platform_createManager(init, onEffects, onSelfMsg, cmdMap, subMap)
1956 | {
1957 | 	return {
1958 | 		b: init,
1959 | 		c: onEffects,
1960 | 		d: onSelfMsg,
1961 | 		e: cmdMap,
1962 | 		f: subMap
1963 | 	};
1964 | }
1965 | 
1966 | 
1967 | function _Platform_instantiateManager(info, sendToApp)
1968 | {
1969 | 	var router = {
1970 | 		g: sendToApp,
1971 | 		h: undefined
1972 | 	};
1973 | 
1974 | 	var onEffects = info.c;
1975 | 	var onSelfMsg = info.d;
1976 | 	var cmdMap = info.e;
1977 | 	var subMap = info.f;
1978 | 
1979 | 	function loop(state)
1980 | 	{
1981 | 		return A2(_Scheduler_andThen, loop, _Scheduler_receive(function(msg)
1982 | 		{
1983 | 			var value = msg.a;
1984 | 
1985 | 			if (msg.$ === 0)
1986 | 			{
1987 | 				return A3(onSelfMsg, router, value, state);
1988 | 			}
1989 | 
1990 | 			return cmdMap && subMap
1991 | 				? A4(onEffects, router, value.i, value.j, state)
1992 | 				: A3(onEffects, router, cmdMap ? value.i : value.j, state);
1993 | 		}));
1994 | 	}
1995 | 
1996 | 	return router.h = _Scheduler_rawSpawn(A2(_Scheduler_andThen, loop, info.b));
1997 | }
1998 | 
1999 | 
2000 | 
2001 | // ROUTING
2002 | 
2003 | 
2004 | var _Platform_sendToApp = F2(function(router, msg)
2005 | {
2006 | 	return _Scheduler_binding(function(callback)
2007 | 	{
2008 | 		router.g(msg);
2009 | 		callback(_Scheduler_succeed(_Utils_Tuple0));
2010 | 	});
2011 | });
2012 | 
2013 | 
2014 | var _Platform_sendToSelf = F2(function(router, msg)
2015 | {
2016 | 	return A2(_Scheduler_send, router.h, {
2017 | 		$: 0,
2018 | 		a: msg
2019 | 	});
2020 | });
2021 | 
2022 | 
2023 | 
2024 | // BAGS
2025 | 
2026 | 
2027 | function _Platform_leaf(home)
2028 | {
2029 | 	return function(value)
2030 | 	{
2031 | 		return {
2032 | 			$: 1,
2033 | 			k: home,
2034 | 			l: value
2035 | 		};
2036 | 	};
2037 | }
2038 | 
2039 | 
2040 | function _Platform_batch(list)
2041 | {
2042 | 	return {
2043 | 		$: 2,
2044 | 		m: list
2045 | 	};
2046 | }
2047 | 
2048 | 
2049 | var _Platform_map = F2(function(tagger, bag)
2050 | {
2051 | 	return {
2052 | 		$: 3,
2053 | 		n: tagger,
2054 | 		o: bag
2055 | 	}
2056 | });
2057 | 
2058 | 
2059 | 
2060 | // PIPE BAGS INTO EFFECT MANAGERS
2061 | //
2062 | // Effects must be queued!
2063 | //
2064 | // Say your init contains a synchronous command, like Time.now or Time.here
2065 | //
2066 | //   - This will produce a batch of effects (FX_1)
2067 | //   - The synchronous task triggers the subsequent `update` call
2068 | //   - This will produce a batch of effects (FX_2)
2069 | //
2070 | // If we just start dispatching FX_2, subscriptions from FX_2 can be processed
2071 | // before subscriptions from FX_1. No good! Earlier versions of this code had
2072 | // this problem, leading to these reports:
2073 | //
2074 | //   https://github.com/elm/core/issues/980
2075 | //   https://github.com/elm/core/pull/981
2076 | //   https://github.com/elm/compiler/issues/1776
2077 | //
2078 | // The queue is necessary to avoid ordering issues for synchronous commands.
2079 | 
2080 | 
2081 | // Why use true/false here? Why not just check the length of the queue?
2082 | // The goal is to detect "are we currently dispatching effects?" If we
2083 | // are, we need to bail and let the ongoing while loop handle things.
2084 | //
2085 | // Now say the queue has 1 element. When we dequeue the final element,
2086 | // the queue will be empty, but we are still actively dispatching effects.
2087 | // So you could get queue jumping in a really tricky category of cases.
2088 | //
2089 | var _Platform_effectsQueue = [];
2090 | var _Platform_effectsActive = false;
2091 | 
2092 | 
2093 | function _Platform_enqueueEffects(managers, cmdBag, subBag)
2094 | {
2095 | 	_Platform_effectsQueue.push({ p: managers, q: cmdBag, r: subBag });
2096 | 
2097 | 	if (_Platform_effectsActive) return;
2098 | 
2099 | 	_Platform_effectsActive = true;
2100 | 	for (var fx; fx = _Platform_effectsQueue.shift(); )
2101 | 	{
2102 | 		_Platform_dispatchEffects(fx.p, fx.q, fx.r);
2103 | 	}
2104 | 	_Platform_effectsActive = false;
2105 | }
2106 | 
2107 | 
2108 | function _Platform_dispatchEffects(managers, cmdBag, subBag)
2109 | {
2110 | 	var effectsDict = {};
2111 | 	_Platform_gatherEffects(true, cmdBag, effectsDict, null);
2112 | 	_Platform_gatherEffects(false, subBag, effectsDict, null);
2113 | 
2114 | 	for (var home in managers)
2115 | 	{
2116 | 		_Scheduler_rawSend(managers[home], {
2117 | 			$: 'fx',
2118 | 			a: effectsDict[home] || { i: _List_Nil, j: _List_Nil }
2119 | 		});
2120 | 	}
2121 | }
2122 | 
2123 | 
2124 | function _Platform_gatherEffects(isCmd, bag, effectsDict, taggers)
2125 | {
2126 | 	switch (bag.$)
2127 | 	{
2128 | 		case 1:
2129 | 			var home = bag.k;
2130 | 			var effect = _Platform_toEffect(isCmd, home, taggers, bag.l);
2131 | 			effectsDict[home] = _Platform_insert(isCmd, effect, effectsDict[home]);
2132 | 			return;
2133 | 
2134 | 		case 2:
2135 | 			for (var list = bag.m; list.b; list = list.b) // WHILE_CONS
2136 | 			{
2137 | 				_Platform_gatherEffects(isCmd, list.a, effectsDict, taggers);
2138 | 			}
2139 | 			return;
2140 | 
2141 | 		case 3:
2142 | 			_Platform_gatherEffects(isCmd, bag.o, effectsDict, {
2143 | 				s: bag.n,
2144 | 				t: taggers
2145 | 			});
2146 | 			return;
2147 | 	}
2148 | }
2149 | 
2150 | 
2151 | function _Platform_toEffect(isCmd, home, taggers, value)
2152 | {
2153 | 	function applyTaggers(x)
2154 | 	{
2155 | 		for (var temp = taggers; temp; temp = temp.t)
2156 | 		{
2157 | 			x = temp.s(x);
2158 | 		}
2159 | 		return x;
2160 | 	}
2161 | 
2162 | 	var map = isCmd
2163 | 		? _Platform_effectManagers[home].e
2164 | 		: _Platform_effectManagers[home].f;
2165 | 
2166 | 	return A2(map, applyTaggers, value)
2167 | }
2168 | 
2169 | 
2170 | function _Platform_insert(isCmd, newEffect, effects)
2171 | {
2172 | 	effects = effects || { i: _List_Nil, j: _List_Nil };
2173 | 
2174 | 	isCmd
2175 | 		? (effects.i = _List_Cons(newEffect, effects.i))
2176 | 		: (effects.j = _List_Cons(newEffect, effects.j));
2177 | 
2178 | 	return effects;
2179 | }
2180 | 
2181 | 
2182 | 
2183 | // PORTS
2184 | 
2185 | 
2186 | function _Platform_checkPortName(name)
2187 | {
2188 | 	if (_Platform_effectManagers[name])
2189 | 	{
2190 | 		_Debug_crash(3, name)
2191 | 	}
2192 | }
2193 | 
2194 | 
2195 | 
2196 | // OUTGOING PORTS
2197 | 
2198 | 
2199 | function _Platform_outgoingPort(name, converter)
2200 | {
2201 | 	_Platform_checkPortName(name);
2202 | 	_Platform_effectManagers[name] = {
2203 | 		e: _Platform_outgoingPortMap,
2204 | 		u: converter,
2205 | 		a: _Platform_setupOutgoingPort
2206 | 	};
2207 | 	return _Platform_leaf(name);
2208 | }
2209 | 
2210 | 
2211 | var _Platform_outgoingPortMap = F2(function(tagger, value) { return value; });
2212 | 
2213 | 
2214 | function _Platform_setupOutgoingPort(name)
2215 | {
2216 | 	var subs = [];
2217 | 	var converter = _Platform_effectManagers[name].u;
2218 | 
2219 | 	// CREATE MANAGER
2220 | 
2221 | 	var init = _Process_sleep(0);
2222 | 
2223 | 	_Platform_effectManagers[name].b = init;
2224 | 	_Platform_effectManagers[name].c = F3(function(router, cmdList, state)
2225 | 	{
2226 | 		for ( ; cmdList.b; cmdList = cmdList.b) // WHILE_CONS
2227 | 		{
2228 | 			// grab a separate reference to subs in case unsubscribe is called
2229 | 			var currentSubs = subs;
2230 | 			var value = _Json_unwrap(converter(cmdList.a));
2231 | 			for (var i = 0; i < currentSubs.length; i++)
2232 | 			{
2233 | 				currentSubs[i](value);
2234 | 			}
2235 | 		}
2236 | 		return init;
2237 | 	});
2238 | 
2239 | 	// PUBLIC API
2240 | 
2241 | 	function subscribe(callback)
2242 | 	{
2243 | 		subs.push(callback);
2244 | 	}
2245 | 
2246 | 	function unsubscribe(callback)
2247 | 	{
2248 | 		// copy subs into a new array in case unsubscribe is called within a
2249 | 		// subscribed callback
2250 | 		subs = subs.slice();
2251 | 		var index = subs.indexOf(callback);
2252 | 		if (index >= 0)
2253 | 		{
2254 | 			subs.splice(index, 1);
2255 | 		}
2256 | 	}
2257 | 
2258 | 	return {
2259 | 		subscribe: subscribe,
2260 | 		unsubscribe: unsubscribe
2261 | 	};
2262 | }
2263 | 
2264 | 
2265 | 
2266 | // INCOMING PORTS
2267 | 
2268 | 
2269 | function _Platform_incomingPort(name, converter)
2270 | {
2271 | 	_Platform_checkPortName(name);
2272 | 	_Platform_effectManagers[name] = {
2273 | 		f: _Platform_incomingPortMap,
2274 | 		u: converter,
2275 | 		a: _Platform_setupIncomingPort
2276 | 	};
2277 | 	return _Platform_leaf(name);
2278 | }
2279 | 
2280 | 
2281 | var _Platform_incomingPortMap = F2(function(tagger, finalTagger)
2282 | {
2283 | 	return function(value)
2284 | 	{
2285 | 		return tagger(finalTagger(value));
2286 | 	};
2287 | });
2288 | 
2289 | 
2290 | function _Platform_setupIncomingPort(name, sendToApp)
2291 | {
2292 | 	var subs = _List_Nil;
2293 | 	var converter = _Platform_effectManagers[name].u;
2294 | 
2295 | 	// CREATE MANAGER
2296 | 
2297 | 	var init = _Scheduler_succeed(null);
2298 | 
2299 | 	_Platform_effectManagers[name].b = init;
2300 | 	_Platform_effectManagers[name].c = F3(function(router, subList, state)
2301 | 	{
2302 | 		subs = subList;
2303 | 		return init;
2304 | 	});
2305 | 
2306 | 	// PUBLIC API
2307 | 
2308 | 	function send(incomingValue)
2309 | 	{
2310 | 		var result = A2(_Json_run, converter, _Json_wrap(incomingValue));
2311 | 
2312 | 		$elm$core$Result$isOk(result) || _Debug_crash(4, name, result.a);
2313 | 
2314 | 		var value = result.a;
2315 | 		for (var temp = subs; temp.b; temp = temp.b) // WHILE_CONS
2316 | 		{
2317 | 			sendToApp(temp.a(value));
2318 | 		}
2319 | 	}
2320 | 
2321 | 	return { send: send };
2322 | }
2323 | 
2324 | 
2325 | 
2326 | // EXPORT ELM MODULES
2327 | //
2328 | // Have DEBUG and PROD versions so that we can (1) give nicer errors in
2329 | // debug mode and (2) not pay for the bits needed for that in prod mode.
2330 | //
2331 | 
2332 | 
2333 | function _Platform_export_UNUSED(exports)
2334 | {
2335 | 	scope['Elm']
2336 | 		? _Platform_mergeExportsProd(scope['Elm'], exports)
2337 | 		: scope['Elm'] = exports;
2338 | }
2339 | 
2340 | 
2341 | function _Platform_mergeExportsProd(obj, exports)
2342 | {
2343 | 	for (var name in exports)
2344 | 	{
2345 | 		(name in obj)
2346 | 			? (name == 'init')
2347 | 				? _Debug_crash(6)
2348 | 				: _Platform_mergeExportsProd(obj[name], exports[name])
2349 | 			: (obj[name] = exports[name]);
2350 | 	}
2351 | }
2352 | 
2353 | 
2354 | function _Platform_export(exports)
2355 | {
2356 | 	scope['Elm']
2357 | 		? _Platform_mergeExportsDebug('Elm', scope['Elm'], exports)
2358 | 		: scope['Elm'] = exports;
2359 | }
2360 | 
2361 | 
2362 | function _Platform_mergeExportsDebug(moduleName, obj, exports)
2363 | {
2364 | 	for (var name in exports)
2365 | 	{
2366 | 		(name in obj)
2367 | 			? (name == 'init')
2368 | 				? _Debug_crash(6, moduleName)
2369 | 				: _Platform_mergeExportsDebug(moduleName + '.' + name, obj[name], exports[name])
2370 | 			: (obj[name] = exports[name]);
2371 | 	}
2372 | }
2373 | 
2374 | 
2375 | 
2376 | 
2377 | // HELPERS
2378 | 
2379 | 
2380 | var _VirtualDom_divertHrefToApp;
2381 | 
2382 | var _VirtualDom_doc = typeof document !== 'undefined' ? document : {};
2383 | 
2384 | 
2385 | function _VirtualDom_appendChild(parent, child)
2386 | {
2387 | 	parent.appendChild(child);
2388 | }
2389 | 
2390 | var _VirtualDom_init = F4(function(virtualNode, flagDecoder, debugMetadata, args)
2391 | {
2392 | 	// NOTE: this function needs _Platform_export available to work
2393 | 
2394 | 	/**_UNUSED/
2395 | 	var node = args['node'];
2396 | 	//*/
2397 | 	/**/
2398 | 	var node = args && args['node'] ? args['node'] : _Debug_crash(0);
2399 | 	//*/
2400 | 
2401 | 	node.parentNode.replaceChild(
2402 | 		_VirtualDom_render(virtualNode, function() {}),
2403 | 		node
2404 | 	);
2405 | 
2406 | 	return {};
2407 | });
2408 | 
2409 | 
2410 | 
2411 | // TEXT
2412 | 
2413 | 
2414 | function _VirtualDom_text(string)
2415 | {
2416 | 	return {
2417 | 		$: 0,
2418 | 		a: string
2419 | 	};
2420 | }
2421 | 
2422 | 
2423 | 
2424 | // NODE
2425 | 
2426 | 
2427 | var _VirtualDom_nodeNS = F2(function(namespace, tag)
2428 | {
2429 | 	return F2(function(factList, kidList)
2430 | 	{
2431 | 		for (var kids = [], descendantsCount = 0; kidList.b; kidList = kidList.b) // WHILE_CONS
2432 | 		{
2433 | 			var kid = kidList.a;
2434 | 			descendantsCount += (kid.b || 0);
2435 | 			kids.push(kid);
2436 | 		}
2437 | 		descendantsCount += kids.length;
2438 | 
2439 | 		return {
2440 | 			$: 1,
2441 | 			c: tag,
2442 | 			d: _VirtualDom_organizeFacts(factList),
2443 | 			e: kids,
2444 | 			f: namespace,
2445 | 			b: descendantsCount
2446 | 		};
2447 | 	});
2448 | });
2449 | 
2450 | 
2451 | var _VirtualDom_node = _VirtualDom_nodeNS(undefined);
2452 | 
2453 | 
2454 | 
2455 | // KEYED NODE
2456 | 
2457 | 
2458 | var _VirtualDom_keyedNodeNS = F2(function(namespace, tag)
2459 | {
2460 | 	return F2(function(factList, kidList)
2461 | 	{
2462 | 		for (var kids = [], descendantsCount = 0; kidList.b; kidList = kidList.b) // WHILE_CONS
2463 | 		{
2464 | 			var kid = kidList.a;
2465 | 			descendantsCount += (kid.b.b || 0);
2466 | 			kids.push(kid);
2467 | 		}
2468 | 		descendantsCount += kids.length;
2469 | 
2470 | 		return {
2471 | 			$: 2,
2472 | 			c: tag,
2473 | 			d: _VirtualDom_organizeFacts(factList),
2474 | 			e: kids,
2475 | 			f: namespace,
2476 | 			b: descendantsCount
2477 | 		};
2478 | 	});
2479 | });
2480 | 
2481 | 
2482 | var _VirtualDom_keyedNode = _VirtualDom_keyedNodeNS(undefined);
2483 | 
2484 | 
2485 | 
2486 | // CUSTOM
2487 | 
2488 | 
2489 | function _VirtualDom_custom(factList, model, render, diff)
2490 | {
2491 | 	return {
2492 | 		$: 3,
2493 | 		d: _VirtualDom_organizeFacts(factList),
2494 | 		g: model,
2495 | 		h: render,
2496 | 		i: diff
2497 | 	};
2498 | }
2499 | 
2500 | 
2501 | 
2502 | // MAP
2503 | 
2504 | 
2505 | var _VirtualDom_map = F2(function(tagger, node)
2506 | {
2507 | 	return {
2508 | 		$: 4,
2509 | 		j: tagger,
2510 | 		k: node,
2511 | 		b: 1 + (node.b || 0)
2512 | 	};
2513 | });
2514 | 
2515 | 
2516 | 
2517 | // LAZY
2518 | 
2519 | 
2520 | function _VirtualDom_thunk(refs, thunk)
2521 | {
2522 | 	return {
2523 | 		$: 5,
2524 | 		l: refs,
2525 | 		m: thunk,
2526 | 		k: undefined
2527 | 	};
2528 | }
2529 | 
2530 | var _VirtualDom_lazy = F2(function(func, a)
2531 | {
2532 | 	return _VirtualDom_thunk([func, a], function() {
2533 | 		return func(a);
2534 | 	});
2535 | });
2536 | 
2537 | var _VirtualDom_lazy2 = F3(function(func, a, b)
2538 | {
2539 | 	return _VirtualDom_thunk([func, a, b], function() {
2540 | 		return A2(func, a, b);
2541 | 	});
2542 | });
2543 | 
2544 | var _VirtualDom_lazy3 = F4(function(func, a, b, c)
2545 | {
2546 | 	return _VirtualDom_thunk([func, a, b, c], function() {
2547 | 		return A3(func, a, b, c);
2548 | 	});
2549 | });
2550 | 
2551 | var _VirtualDom_lazy4 = F5(function(func, a, b, c, d)
2552 | {
2553 | 	return _VirtualDom_thunk([func, a, b, c, d], function() {
2554 | 		return A4(func, a, b, c, d);
2555 | 	});
2556 | });
2557 | 
2558 | var _VirtualDom_lazy5 = F6(function(func, a, b, c, d, e)
2559 | {
2560 | 	return _VirtualDom_thunk([func, a, b, c, d, e], function() {
2561 | 		return A5(func, a, b, c, d, e);
2562 | 	});
2563 | });
2564 | 
2565 | var _VirtualDom_lazy6 = F7(function(func, a, b, c, d, e, f)
2566 | {
2567 | 	return _VirtualDom_thunk([func, a, b, c, d, e, f], function() {
2568 | 		return A6(func, a, b, c, d, e, f);
2569 | 	});
2570 | });
2571 | 
2572 | var _VirtualDom_lazy7 = F8(function(func, a, b, c, d, e, f, g)
2573 | {
2574 | 	return _VirtualDom_thunk([func, a, b, c, d, e, f, g], function() {
2575 | 		return A7(func, a, b, c, d, e, f, g);
2576 | 	});
2577 | });
2578 | 
2579 | var _VirtualDom_lazy8 = F9(function(func, a, b, c, d, e, f, g, h)
2580 | {
2581 | 	return _VirtualDom_thunk([func, a, b, c, d, e, f, g, h], function() {
2582 | 		return A8(func, a, b, c, d, e, f, g, h);
2583 | 	});
2584 | });
2585 | 
2586 | 
2587 | 
2588 | // FACTS
2589 | 
2590 | 
2591 | var _VirtualDom_on = F2(function(key, handler)
2592 | {
2593 | 	return {
2594 | 		$: 'a0',
2595 | 		n: key,
2596 | 		o: handler
2597 | 	};
2598 | });
2599 | var _VirtualDom_style = F2(function(key, value)
2600 | {
2601 | 	return {
2602 | 		$: 'a1',
2603 | 		n: key,
2604 | 		o: value
2605 | 	};
2606 | });
2607 | var _VirtualDom_property = F2(function(key, value)
2608 | {
2609 | 	return {
2610 | 		$: 'a2',
2611 | 		n: key,
2612 | 		o: value
2613 | 	};
2614 | });
2615 | var _VirtualDom_attribute = F2(function(key, value)
2616 | {
2617 | 	return {
2618 | 		$: 'a3',
2619 | 		n: key,
2620 | 		o: value
2621 | 	};
2622 | });
2623 | var _VirtualDom_attributeNS = F3(function(namespace, key, value)
2624 | {
2625 | 	return {
2626 | 		$: 'a4',
2627 | 		n: key,
2628 | 		o: { f: namespace, o: value }
2629 | 	};
2630 | });
2631 | 
2632 | 
2633 | 
2634 | // XSS ATTACK VECTOR CHECKS
2635 | 
2636 | 
2637 | function _VirtualDom_noScript(tag)
2638 | {
2639 | 	return tag == 'script' ? 'p' : tag;
2640 | }
2641 | 
2642 | function _VirtualDom_noOnOrFormAction(key)
2643 | {
2644 | 	return /^(on|formAction$)/i.test(key) ? 'data-' + key : key;
2645 | }
2646 | 
2647 | function _VirtualDom_noInnerHtmlOrFormAction(key)
2648 | {
2649 | 	return key == 'innerHTML' || key == 'formAction' ? 'data-' + key : key;
2650 | }
2651 | 
2652 | function _VirtualDom_noJavaScriptUri_UNUSED(value)
2653 | {
2654 | 	return /^javascript:/i.test(value.replace(/\s/g,'')) ? '' : value;
2655 | }
2656 | 
2657 | function _VirtualDom_noJavaScriptUri(value)
2658 | {
2659 | 	return /^javascript:/i.test(value.replace(/\s/g,''))
2660 | 		? 'javascript:alert("This is an XSS vector. Please use ports or web components instead.")'
2661 | 		: value;
2662 | }
2663 | 
2664 | function _VirtualDom_noJavaScriptOrHtmlUri_UNUSED(value)
2665 | {
2666 | 	return /^\s*(javascript:|data:text\/html)/i.test(value) ? '' : value;
2667 | }
2668 | 
2669 | function _VirtualDom_noJavaScriptOrHtmlUri(value)
2670 | {
2671 | 	return /^\s*(javascript:|data:text\/html)/i.test(value)
2672 | 		? 'javascript:alert("This is an XSS vector. Please use ports or web components instead.")'
2673 | 		: value;
2674 | }
2675 | 
2676 | 
2677 | 
2678 | // MAP FACTS
2679 | 
2680 | 
2681 | var _VirtualDom_mapAttribute = F2(function(func, attr)
2682 | {
2683 | 	return (attr.$ === 'a0')
2684 | 		? A2(_VirtualDom_on, attr.n, _VirtualDom_mapHandler(func, attr.o))
2685 | 		: attr;
2686 | });
2687 | 
2688 | function _VirtualDom_mapHandler(func, handler)
2689 | {
2690 | 	var tag = $elm$virtual_dom$VirtualDom$toHandlerInt(handler);
2691 | 
2692 | 	// 0 = Normal
2693 | 	// 1 = MayStopPropagation
2694 | 	// 2 = MayPreventDefault
2695 | 	// 3 = Custom
2696 | 
2697 | 	return {
2698 | 		$: handler.$,
2699 | 		a:
2700 | 			!tag
2701 | 				? A2($elm$json$Json$Decode$map, func, handler.a)
2702 | 				:
2703 | 			A3($elm$json$Json$Decode$map2,
2704 | 				tag < 3
2705 | 					? _VirtualDom_mapEventTuple
2706 | 					: _VirtualDom_mapEventRecord,
2707 | 				$elm$json$Json$Decode$succeed(func),
2708 | 				handler.a
2709 | 			)
2710 | 	};
2711 | }
2712 | 
2713 | var _VirtualDom_mapEventTuple = F2(function(func, tuple)
2714 | {
2715 | 	return _Utils_Tuple2(func(tuple.a), tuple.b);
2716 | });
2717 | 
2718 | var _VirtualDom_mapEventRecord = F2(function(func, record)
2719 | {
2720 | 	return {
2721 | 		message: func(record.message),
2722 | 		stopPropagation: record.stopPropagation,
2723 | 		preventDefault: record.preventDefault
2724 | 	}
2725 | });
2726 | 
2727 | 
2728 | 
2729 | // ORGANIZE FACTS
2730 | 
2731 | 
2732 | function _VirtualDom_organizeFacts(factList)
2733 | {
2734 | 	for (var facts = {}; factList.b; factList = factList.b) // WHILE_CONS
2735 | 	{
2736 | 		var entry = factList.a;
2737 | 
2738 | 		var tag = entry.$;
2739 | 		var key = entry.n;
2740 | 		var value = entry.o;
2741 | 
2742 | 		if (tag === 'a2')
2743 | 		{
2744 | 			(key === 'className')
2745 | 				? _VirtualDom_addClass(facts, key, _Json_unwrap(value))
2746 | 				: facts[key] = _Json_unwrap(value);
2747 | 
2748 | 			continue;
2749 | 		}
2750 | 
2751 | 		var subFacts = facts[tag] || (facts[tag] = {});
2752 | 		(tag === 'a3' && key === 'class')
2753 | 			? _VirtualDom_addClass(subFacts, key, value)
2754 | 			: subFacts[key] = value;
2755 | 	}
2756 | 
2757 | 	return facts;
2758 | }
2759 | 
2760 | function _VirtualDom_addClass(object, key, newClass)
2761 | {
2762 | 	var classes = object[key];
2763 | 	object[key] = classes ? classes + ' ' + newClass : newClass;
2764 | }
2765 | 
2766 | 
2767 | 
2768 | // RENDER
2769 | 
2770 | 
2771 | function _VirtualDom_render(vNode, eventNode)
2772 | {
2773 | 	var tag = vNode.$;
2774 | 
2775 | 	if (tag === 5)
2776 | 	{
2777 | 		return _VirtualDom_render(vNode.k || (vNode.k = vNode.m()), eventNode);
2778 | 	}
2779 | 
2780 | 	if (tag === 0)
2781 | 	{
2782 | 		return _VirtualDom_doc.createTextNode(vNode.a);
2783 | 	}
2784 | 
2785 | 	if (tag === 4)
2786 | 	{
2787 | 		var subNode = vNode.k;
2788 | 		var tagger = vNode.j;
2789 | 
2790 | 		while (subNode.$ === 4)
2791 | 		{
2792 | 			typeof tagger !== 'object'
2793 | 				? tagger = [tagger, subNode.j]
2794 | 				: tagger.push(subNode.j);
2795 | 
2796 | 			subNode = subNode.k;
2797 | 		}
2798 | 
2799 | 		var subEventRoot = { j: tagger, p: eventNode };
2800 | 		var domNode = _VirtualDom_render(subNode, subEventRoot);
2801 | 		domNode.elm_event_node_ref = subEventRoot;
2802 | 		return domNode;
2803 | 	}
2804 | 
2805 | 	if (tag === 3)
2806 | 	{
2807 | 		var domNode = vNode.h(vNode.g);
2808 | 		_VirtualDom_applyFacts(domNode, eventNode, vNode.d);
2809 | 		return domNode;
2810 | 	}
2811 | 
2812 | 	// at this point `tag` must be 1 or 2
2813 | 
2814 | 	var domNode = vNode.f
2815 | 		? _VirtualDom_doc.createElementNS(vNode.f, vNode.c)
2816 | 		: _VirtualDom_doc.createElement(vNode.c);
2817 | 
2818 | 	if (_VirtualDom_divertHrefToApp && vNode.c == 'a')
2819 | 	{
2820 | 		domNode.addEventListener('click', _VirtualDom_divertHrefToApp(domNode));
2821 | 	}
2822 | 
2823 | 	_VirtualDom_applyFacts(domNode, eventNode, vNode.d);
2824 | 
2825 | 	for (var kids = vNode.e, i = 0; i < kids.length; i++)
2826 | 	{
2827 | 		_VirtualDom_appendChild(domNode, _VirtualDom_render(tag === 1 ? kids[i] : kids[i].b, eventNode));
2828 | 	}
2829 | 
2830 | 	return domNode;
2831 | }
2832 | 
2833 | 
2834 | 
2835 | // APPLY FACTS
2836 | 
2837 | 
2838 | function _VirtualDom_applyFacts(domNode, eventNode, facts)
2839 | {
2840 | 	for (var key in facts)
2841 | 	{
2842 | 		var value = facts[key];
2843 | 
2844 | 		key === 'a1'
2845 | 			? _VirtualDom_applyStyles(domNode, value)
2846 | 			:
2847 | 		key === 'a0'
2848 | 			? _VirtualDom_applyEvents(domNode, eventNode, value)
2849 | 			:
2850 | 		key === 'a3'
2851 | 			? _VirtualDom_applyAttrs(domNode, value)
2852 | 			:
2853 | 		key === 'a4'
2854 | 			? _VirtualDom_applyAttrsNS(domNode, value)
2855 | 			:
2856 | 		((key !== 'value' && key !== 'checked') || domNode[key] !== value) && (domNode[key] = value);
2857 | 	}
2858 | }
2859 | 
2860 | 
2861 | 
2862 | // APPLY STYLES
2863 | 
2864 | 
2865 | function _VirtualDom_applyStyles(domNode, styles)
2866 | {
2867 | 	var domNodeStyle = domNode.style;
2868 | 
2869 | 	for (var key in styles)
2870 | 	{
2871 | 		domNodeStyle[key] = styles[key];
2872 | 	}
2873 | }
2874 | 
2875 | 
2876 | 
2877 | // APPLY ATTRS
2878 | 
2879 | 
2880 | function _VirtualDom_applyAttrs(domNode, attrs)
2881 | {
2882 | 	for (var key in attrs)
2883 | 	{
2884 | 		var value = attrs[key];
2885 | 		typeof value !== 'undefined'
2886 | 			? domNode.setAttribute(key, value)
2887 | 			: domNode.removeAttribute(key);
2888 | 	}
2889 | }
2890 | 
2891 | 
2892 | 
2893 | // APPLY NAMESPACED ATTRS
2894 | 
2895 | 
2896 | function _VirtualDom_applyAttrsNS(domNode, nsAttrs)
2897 | {
2898 | 	for (var key in nsAttrs)
2899 | 	{
2900 | 		var pair = nsAttrs[key];
2901 | 		var namespace = pair.f;
2902 | 		var value = pair.o;
2903 | 
2904 | 		typeof value !== 'undefined'
2905 | 			? domNode.setAttributeNS(namespace, key, value)
2906 | 			: domNode.removeAttributeNS(namespace, key);
2907 | 	}
2908 | }
2909 | 
2910 | 
2911 | 
2912 | // APPLY EVENTS
2913 | 
2914 | 
2915 | function _VirtualDom_applyEvents(domNode, eventNode, events)
2916 | {
2917 | 	var allCallbacks = domNode.elmFs || (domNode.elmFs = {});
2918 | 
2919 | 	for (var key in events)
2920 | 	{
2921 | 		var newHandler = events[key];
2922 | 		var oldCallback = allCallbacks[key];
2923 | 
2924 | 		if (!newHandler)
2925 | 		{
2926 | 			domNode.removeEventListener(key, oldCallback);
2927 | 			allCallbacks[key] = undefined;
2928 | 			continue;
2929 | 		}
2930 | 
2931 | 		if (oldCallback)
2932 | 		{
2933 | 			var oldHandler = oldCallback.q;
2934 | 			if (oldHandler.$ === newHandler.$)
2935 | 			{
2936 | 				oldCallback.q = newHandler;
2937 | 				continue;
2938 | 			}
2939 | 			domNode.removeEventListener(key, oldCallback);
2940 | 		}
2941 | 
2942 | 		oldCallback = _VirtualDom_makeCallback(eventNode, newHandler);
2943 | 		domNode.addEventListener(key, oldCallback,
2944 | 			_VirtualDom_passiveSupported
2945 | 			&& { passive: $elm$virtual_dom$VirtualDom$toHandlerInt(newHandler) < 2 }
2946 | 		);
2947 | 		allCallbacks[key] = oldCallback;
2948 | 	}
2949 | }
2950 | 
2951 | 
2952 | 
2953 | // PASSIVE EVENTS
2954 | 
2955 | 
2956 | var _VirtualDom_passiveSupported;
2957 | 
2958 | try
2959 | {
2960 | 	window.addEventListener('t', null, Object.defineProperty({}, 'passive', {
2961 | 		get: function() { _VirtualDom_passiveSupported = true; }
2962 | 	}));
2963 | }
2964 | catch(e) {}
2965 | 
2966 | 
2967 | 
2968 | // EVENT HANDLERS
2969 | 
2970 | 
2971 | function _VirtualDom_makeCallback(eventNode, initialHandler)
2972 | {
2973 | 	function callback(event)
2974 | 	{
2975 | 		var handler = callback.q;
2976 | 		var result = _Json_runHelp(handler.a, event);
2977 | 
2978 | 		if (!$elm$core$Result$isOk(result))
2979 | 		{
2980 | 			return;
2981 | 		}
2982 | 
2983 | 		var tag = $elm$virtual_dom$VirtualDom$toHandlerInt(handler);
2984 | 
2985 | 		// 0 = Normal
2986 | 		// 1 = MayStopPropagation
2987 | 		// 2 = MayPreventDefault
2988 | 		// 3 = Custom
2989 | 
2990 | 		var value = result.a;
2991 | 		var message = !tag ? value : tag < 3 ? value.a : value.message;
2992 | 		var stopPropagation = tag == 1 ? value.b : tag == 3 && value.stopPropagation;
2993 | 		var currentEventNode = (
2994 | 			stopPropagation && event.stopPropagation(),
2995 | 			(tag == 2 ? value.b : tag == 3 && value.preventDefault) && event.preventDefault(),
2996 | 			eventNode
2997 | 		);
2998 | 		var tagger;
2999 | 		var i;
3000 | 		while (tagger = currentEventNode.j)
3001 | 		{
3002 | 			if (typeof tagger == 'function')
3003 | 			{
3004 | 				message = tagger(message);
3005 | 			}
3006 | 			else
3007 | 			{
3008 | 				for (var i = tagger.length; i--; )
3009 | 				{
3010 | 					message = tagger[i](message);
3011 | 				}
3012 | 			}
3013 | 			currentEventNode = currentEventNode.p;
3014 | 		}
3015 | 		currentEventNode(message, stopPropagation); // stopPropagation implies isSync
3016 | 	}
3017 | 
3018 | 	callback.q = initialHandler;
3019 | 
3020 | 	return callback;
3021 | }
3022 | 
3023 | function _VirtualDom_equalEvents(x, y)
3024 | {
3025 | 	return x.$ == y.$ && _Json_equality(x.a, y.a);
3026 | }
3027 | 
3028 | 
3029 | 
3030 | // DIFF
3031 | 
3032 | 
3033 | // TODO: Should we do patches like in iOS?
3034 | //
3035 | // type Patch
3036 | //   = At Int Patch
3037 | //   | Batch (List Patch)
3038 | //   | Change ...
3039 | //
3040 | // How could it not be better?
3041 | //
3042 | function _VirtualDom_diff(x, y)
3043 | {
3044 | 	var patches = [];
3045 | 	_VirtualDom_diffHelp(x, y, patches, 0);
3046 | 	return patches;
3047 | }
3048 | 
3049 | 
3050 | function _VirtualDom_pushPatch(patches, type, index, data)
3051 | {
3052 | 	var patch = {
3053 | 		$: type,
3054 | 		r: index,
3055 | 		s: data,
3056 | 		t: undefined,
3057 | 		u: undefined
3058 | 	};
3059 | 	patches.push(patch);
3060 | 	return patch;
3061 | }
3062 | 
3063 | 
3064 | function _VirtualDom_diffHelp(x, y, patches, index)
3065 | {
3066 | 	if (x === y)
3067 | 	{
3068 | 		return;
3069 | 	}
3070 | 
3071 | 	var xType = x.$;
3072 | 	var yType = y.$;
3073 | 
3074 | 	// Bail if you run into different types of nodes. Implies that the
3075 | 	// structure has changed significantly and it's not worth a diff.
3076 | 	if (xType !== yType)
3077 | 	{
3078 | 		if (xType === 1 && yType === 2)
3079 | 		{
3080 | 			y = _VirtualDom_dekey(y);
3081 | 			yType = 1;
3082 | 		}
3083 | 		else
3084 | 		{
3085 | 			_VirtualDom_pushPatch(patches, 0, index, y);
3086 | 			return;
3087 | 		}
3088 | 	}
3089 | 
3090 | 	// Now we know that both nodes are the same $.
3091 | 	switch (yType)
3092 | 	{
3093 | 		case 5:
3094 | 			var xRefs = x.l;
3095 | 			var yRefs = y.l;
3096 | 			var i = xRefs.length;
3097 | 			var same = i === yRefs.length;
3098 | 			while (same && i--)
3099 | 			{
3100 | 				same = xRefs[i] === yRefs[i];
3101 | 			}
3102 | 			if (same)
3103 | 			{
3104 | 				y.k = x.k;
3105 | 				return;
3106 | 			}
3107 | 			y.k = y.m();
3108 | 			var subPatches = [];
3109 | 			_VirtualDom_diffHelp(x.k, y.k, subPatches, 0);
3110 | 			subPatches.length > 0 && _VirtualDom_pushPatch(patches, 1, index, subPatches);
3111 | 			return;
3112 | 
3113 | 		case 4:
3114 | 			// gather nested taggers
3115 | 			var xTaggers = x.j;
3116 | 			var yTaggers = y.j;
3117 | 			var nesting = false;
3118 | 
3119 | 			var xSubNode = x.k;
3120 | 			while (xSubNode.$ === 4)
3121 | 			{
3122 | 				nesting = true;
3123 | 
3124 | 				typeof xTaggers !== 'object'
3125 | 					? xTaggers = [xTaggers, xSubNode.j]
3126 | 					: xTaggers.push(xSubNode.j);
3127 | 
3128 | 				xSubNode = xSubNode.k;
3129 | 			}
3130 | 
3131 | 			var ySubNode = y.k;
3132 | 			while (ySubNode.$ === 4)
3133 | 			{
3134 | 				nesting = true;
3135 | 
3136 | 				typeof yTaggers !== 'object'
3137 | 					? yTaggers = [yTaggers, ySubNode.j]
3138 | 					: yTaggers.push(ySubNode.j);
3139 | 
3140 | 				ySubNode = ySubNode.k;
3141 | 			}
3142 | 
3143 | 			// Just bail if different numbers of taggers. This implies the
3144 | 			// structure of the virtual DOM has changed.
3145 | 			if (nesting && xTaggers.length !== yTaggers.length)
3146 | 			{
3147 | 				_VirtualDom_pushPatch(patches, 0, index, y);
3148 | 				return;
3149 | 			}
3150 | 
3151 | 			// check if taggers are "the same"
3152 | 			if (nesting ? !_VirtualDom_pairwiseRefEqual(xTaggers, yTaggers) : xTaggers !== yTaggers)
3153 | 			{
3154 | 				_VirtualDom_pushPatch(patches, 2, index, yTaggers);
3155 | 			}
3156 | 
3157 | 			// diff everything below the taggers
3158 | 			_VirtualDom_diffHelp(xSubNode, ySubNode, patches, index + 1);
3159 | 			return;
3160 | 
3161 | 		case 0:
3162 | 			if (x.a !== y.a)
3163 | 			{
3164 | 				_VirtualDom_pushPatch(patches, 3, index, y.a);
3165 | 			}
3166 | 			return;
3167 | 
3168 | 		case 1:
3169 | 			_VirtualDom_diffNodes(x, y, patches, index, _VirtualDom_diffKids);
3170 | 			return;
3171 | 
3172 | 		case 2:
3173 | 			_VirtualDom_diffNodes(x, y, patches, index, _VirtualDom_diffKeyedKids);
3174 | 			return;
3175 | 
3176 | 		case 3:
3177 | 			if (x.h !== y.h)
3178 | 			{
3179 | 				_VirtualDom_pushPatch(patches, 0, index, y);
3180 | 				return;
3181 | 			}
3182 | 
3183 | 			var factsDiff = _VirtualDom_diffFacts(x.d, y.d);
3184 | 			factsDiff && _VirtualDom_pushPatch(patches, 4, index, factsDiff);
3185 | 
3186 | 			var patch = y.i(x.g, y.g);
3187 | 			patch && _VirtualDom_pushPatch(patches, 5, index, patch);
3188 | 
3189 | 			return;
3190 | 	}
3191 | }
3192 | 
3193 | // assumes the incoming arrays are the same length
3194 | function _VirtualDom_pairwiseRefEqual(as, bs)
3195 | {
3196 | 	for (var i = 0; i < as.length; i++)
3197 | 	{
3198 | 		if (as[i] !== bs[i])
3199 | 		{
3200 | 			return false;
3201 | 		}
3202 | 	}
3203 | 
3204 | 	return true;
3205 | }
3206 | 
3207 | function _VirtualDom_diffNodes(x, y, patches, index, diffKids)
3208 | {
3209 | 	// Bail if obvious indicators have changed. Implies more serious
3210 | 	// structural changes such that it's not worth it to diff.
3211 | 	if (x.c !== y.c || x.f !== y.f)
3212 | 	{
3213 | 		_VirtualDom_pushPatch(patches, 0, index, y);
3214 | 		return;
3215 | 	}
3216 | 
3217 | 	var factsDiff = _VirtualDom_diffFacts(x.d, y.d);
3218 | 	factsDiff && _VirtualDom_pushPatch(patches, 4, index, factsDiff);
3219 | 
3220 | 	diffKids(x, y, patches, index);
3221 | }
3222 | 
3223 | 
3224 | 
3225 | // DIFF FACTS
3226 | 
3227 | 
3228 | // TODO Instead of creating a new diff object, it's possible to just test if
3229 | // there *is* a diff. During the actual patch, do the diff again and make the
3230 | // modifications directly. This way, there's no new allocations. Worth it?
3231 | function _VirtualDom_diffFacts(x, y, category)
3232 | {
3233 | 	var diff;
3234 | 
3235 | 	// look for changes and removals
3236 | 	for (var xKey in x)
3237 | 	{
3238 | 		if (xKey === 'a1' || xKey === 'a0' || xKey === 'a3' || xKey === 'a4')
3239 | 		{
3240 | 			var subDiff = _VirtualDom_diffFacts(x[xKey], y[xKey] || {}, xKey);
3241 | 			if (subDiff)
3242 | 			{
3243 | 				diff = diff || {};
3244 | 				diff[xKey] = subDiff;
3245 | 			}
3246 | 			continue;
3247 | 		}
3248 | 
3249 | 		// remove if not in the new facts
3250 | 		if (!(xKey in y))
3251 | 		{
3252 | 			diff = diff || {};
3253 | 			diff[xKey] =
3254 | 				!category
3255 | 					? (typeof x[xKey] === 'string' ? '' : null)
3256 | 					:
3257 | 				(category === 'a1')
3258 | 					? ''
3259 | 					:
3260 | 				(category === 'a0' || category === 'a3')
3261 | 					? undefined
3262 | 					:
3263 | 				{ f: x[xKey].f, o: undefined };
3264 | 
3265 | 			continue;
3266 | 		}
3267 | 
3268 | 		var xValue = x[xKey];
3269 | 		var yValue = y[xKey];
3270 | 
3271 | 		// reference equal, so don't worry about it
3272 | 		if (xValue === yValue && xKey !== 'value' && xKey !== 'checked'
3273 | 			|| category === 'a0' && _VirtualDom_equalEvents(xValue, yValue))
3274 | 		{
3275 | 			continue;
3276 | 		}
3277 | 
3278 | 		diff = diff || {};
3279 | 		diff[xKey] = yValue;
3280 | 	}
3281 | 
3282 | 	// add new stuff
3283 | 	for (var yKey in y)
3284 | 	{
3285 | 		if (!(yKey in x))
3286 | 		{
3287 | 			diff = diff || {};
3288 | 			diff[yKey] = y[yKey];
3289 | 		}
3290 | 	}
3291 | 
3292 | 	return diff;
3293 | }
3294 | 
3295 | 
3296 | 
3297 | // DIFF KIDS
3298 | 
3299 | 
3300 | function _VirtualDom_diffKids(xParent, yParent, patches, index)
3301 | {
3302 | 	var xKids = xParent.e;
3303 | 	var yKids = yParent.e;
3304 | 
3305 | 	var xLen = xKids.length;
3306 | 	var yLen = yKids.length;
3307 | 
3308 | 	// FIGURE OUT IF THERE ARE INSERTS OR REMOVALS
3309 | 
3310 | 	if (xLen > yLen)
3311 | 	{
3312 | 		_VirtualDom_pushPatch(patches, 6, index, {
3313 | 			v: yLen,
3314 | 			i: xLen - yLen
3315 | 		});
3316 | 	}
3317 | 	else if (xLen < yLen)
3318 | 	{
3319 | 		_VirtualDom_pushPatch(patches, 7, index, {
3320 | 			v: xLen,
3321 | 			e: yKids
3322 | 		});
3323 | 	}
3324 | 
3325 | 	// PAIRWISE DIFF EVERYTHING ELSE
3326 | 
3327 | 	for (var minLen = xLen < yLen ? xLen : yLen, i = 0; i < minLen; i++)
3328 | 	{
3329 | 		var xKid = xKids[i];
3330 | 		_VirtualDom_diffHelp(xKid, yKids[i], patches, ++index);
3331 | 		index += xKid.b || 0;
3332 | 	}
3333 | }
3334 | 
3335 | 
3336 | 
3337 | // KEYED DIFF
3338 | 
3339 | 
3340 | function _VirtualDom_diffKeyedKids(xParent, yParent, patches, rootIndex)
3341 | {
3342 | 	var localPatches = [];
3343 | 
3344 | 	var changes = {}; // Dict String Entry
3345 | 	var inserts = []; // Array { index : Int, entry : Entry }
3346 | 	// type Entry = { tag : String, vnode : VNode, index : Int, data : _ }
3347 | 
3348 | 	var xKids = xParent.e;
3349 | 	var yKids = yParent.e;
3350 | 	var xLen = xKids.length;
3351 | 	var yLen = yKids.length;
3352 | 	var xIndex = 0;
3353 | 	var yIndex = 0;
3354 | 
3355 | 	var index = rootIndex;
3356 | 
3357 | 	while (xIndex < xLen && yIndex < yLen)
3358 | 	{
3359 | 		var x = xKids[xIndex];
3360 | 		var y = yKids[yIndex];
3361 | 
3362 | 		var xKey = x.a;
3363 | 		var yKey = y.a;
3364 | 		var xNode = x.b;
3365 | 		var yNode = y.b;
3366 | 
3367 | 		var newMatch = undefined;
3368 | 		var oldMatch = undefined;
3369 | 
3370 | 		// check if keys match
3371 | 
3372 | 		if (xKey === yKey)
3373 | 		{
3374 | 			index++;
3375 | 			_VirtualDom_diffHelp(xNode, yNode, localPatches, index);
3376 | 			index += xNode.b || 0;
3377 | 
3378 | 			xIndex++;
3379 | 			yIndex++;
3380 | 			continue;
3381 | 		}
3382 | 
3383 | 		// look ahead 1 to detect insertions and removals.
3384 | 
3385 | 		var xNext = xKids[xIndex + 1];
3386 | 		var yNext = yKids[yIndex + 1];
3387 | 
3388 | 		if (xNext)
3389 | 		{
3390 | 			var xNextKey = xNext.a;
3391 | 			var xNextNode = xNext.b;
3392 | 			oldMatch = yKey === xNextKey;
3393 | 		}
3394 | 
3395 | 		if (yNext)
3396 | 		{
3397 | 			var yNextKey = yNext.a;
3398 | 			var yNextNode = yNext.b;
3399 | 			newMatch = xKey === yNextKey;
3400 | 		}
3401 | 
3402 | 
3403 | 		// swap x and y
3404 | 		if (newMatch && oldMatch)
3405 | 		{
3406 | 			index++;
3407 | 			_VirtualDom_diffHelp(xNode, yNextNode, localPatches, index);
3408 | 			_VirtualDom_insertNode(changes, localPatches, xKey, yNode, yIndex, inserts);
3409 | 			index += xNode.b || 0;
3410 | 
3411 | 			index++;
3412 | 			_VirtualDom_removeNode(changes, localPatches, xKey, xNextNode, index);
3413 | 			index += xNextNode.b || 0;
3414 | 
3415 | 			xIndex += 2;
3416 | 			yIndex += 2;
3417 | 			continue;
3418 | 		}
3419 | 
3420 | 		// insert y
3421 | 		if (newMatch)
3422 | 		{
3423 | 			index++;
3424 | 			_VirtualDom_insertNode(changes, localPatches, yKey, yNode, yIndex, inserts);
3425 | 			_VirtualDom_diffHelp(xNode, yNextNode, localPatches, index);
3426 | 			index += xNode.b || 0;
3427 | 
3428 | 			xIndex += 1;
3429 | 			yIndex += 2;
3430 | 			continue;
3431 | 		}
3432 | 
3433 | 		// remove x
3434 | 		if (oldMatch)
3435 | 		{
3436 | 			index++;
3437 | 			_VirtualDom_removeNode(changes, localPatches, xKey, xNode, index);
3438 | 			index += xNode.b || 0;
3439 | 
3440 | 			index++;
3441 | 			_VirtualDom_diffHelp(xNextNode, yNode, localPatches, index);
3442 | 			index += xNextNode.b || 0;
3443 | 
3444 | 			xIndex += 2;
3445 | 			yIndex += 1;
3446 | 			continue;
3447 | 		}
3448 | 
3449 | 		// remove x, insert y
3450 | 		if (xNext && xNextKey === yNextKey)
3451 | 		{
3452 | 			index++;
3453 | 			_VirtualDom_removeNode(changes, localPatches, xKey, xNode, index);
3454 | 			_VirtualDom_insertNode(changes, localPatches, yKey, yNode, yIndex, inserts);
3455 | 			index += xNode.b || 0;
3456 | 
3457 | 			index++;
3458 | 			_VirtualDom_diffHelp(xNextNode, yNextNode, localPatches, index);
3459 | 			index += xNextNode.b || 0;
3460 | 
3461 | 			xIndex += 2;
3462 | 			yIndex += 2;
3463 | 			continue;
3464 | 		}
3465 | 
3466 | 		break;
3467 | 	}
3468 | 
3469 | 	// eat up any remaining nodes with removeNode and insertNode
3470 | 
3471 | 	while (xIndex < xLen)
3472 | 	{
3473 | 		index++;
3474 | 		var x = xKids[xIndex];
3475 | 		var xNode = x.b;
3476 | 		_VirtualDom_removeNode(changes, localPatches, x.a, xNode, index);
3477 | 		index += xNode.b || 0;
3478 | 		xIndex++;
3479 | 	}
3480 | 
3481 | 	while (yIndex < yLen)
3482 | 	{
3483 | 		var endInserts = endInserts || [];
3484 | 		var y = yKids[yIndex];
3485 | 		_VirtualDom_insertNode(changes, localPatches, y.a, y.b, undefined, endInserts);
3486 | 		yIndex++;
3487 | 	}
3488 | 
3489 | 	if (localPatches.length > 0 || inserts.length > 0 || endInserts)
3490 | 	{
3491 | 		_VirtualDom_pushPatch(patches, 8, rootIndex, {
3492 | 			w: localPatches,
3493 | 			x: inserts,
3494 | 			y: endInserts
3495 | 		});
3496 | 	}
3497 | }
3498 | 
3499 | 
3500 | 
3501 | // CHANGES FROM KEYED DIFF
3502 | 
3503 | 
3504 | var _VirtualDom_POSTFIX = '_elmW6BL';
3505 | 
3506 | 
3507 | function _VirtualDom_insertNode(changes, localPatches, key, vnode, yIndex, inserts)
3508 | {
3509 | 	var entry = changes[key];
3510 | 
3511 | 	// never seen this key before
3512 | 	if (!entry)
3513 | 	{
3514 | 		entry = {
3515 | 			c: 0,
3516 | 			z: vnode,
3517 | 			r: yIndex,
3518 | 			s: undefined
3519 | 		};
3520 | 
3521 | 		inserts.push({ r: yIndex, A: entry });
3522 | 		changes[key] = entry;
3523 | 
3524 | 		return;
3525 | 	}
3526 | 
3527 | 	// this key was removed earlier, a match!
3528 | 	if (entry.c === 1)
3529 | 	{
3530 | 		inserts.push({ r: yIndex, A: entry });
3531 | 
3532 | 		entry.c = 2;
3533 | 		var subPatches = [];
3534 | 		_VirtualDom_diffHelp(entry.z, vnode, subPatches, entry.r);
3535 | 		entry.r = yIndex;
3536 | 		entry.s.s = {
3537 | 			w: subPatches,
3538 | 			A: entry
3539 | 		};
3540 | 
3541 | 		return;
3542 | 	}
3543 | 
3544 | 	// this key has already been inserted or moved, a duplicate!
3545 | 	_VirtualDom_insertNode(changes, localPatches, key + _VirtualDom_POSTFIX, vnode, yIndex, inserts);
3546 | }
3547 | 
3548 | 
3549 | function _VirtualDom_removeNode(changes, localPatches, key, vnode, index)
3550 | {
3551 | 	var entry = changes[key];
3552 | 
3553 | 	// never seen this key before
3554 | 	if (!entry)
3555 | 	{
3556 | 		var patch = _VirtualDom_pushPatch(localPatches, 9, index, undefined);
3557 | 
3558 | 		changes[key] = {
3559 | 			c: 1,
3560 | 			z: vnode,
3561 | 			r: index,
3562 | 			s: patch
3563 | 		};
3564 | 
3565 | 		return;
3566 | 	}
3567 | 
3568 | 	// this key was inserted earlier, a match!
3569 | 	if (entry.c === 0)
3570 | 	{
3571 | 		entry.c = 2;
3572 | 		var subPatches = [];
3573 | 		_VirtualDom_diffHelp(vnode, entry.z, subPatches, index);
3574 | 
3575 | 		_VirtualDom_pushPatch(localPatches, 9, index, {
3576 | 			w: subPatches,
3577 | 			A: entry
3578 | 		});
3579 | 
3580 | 		return;
3581 | 	}
3582 | 
3583 | 	// this key has already been removed or moved, a duplicate!
3584 | 	_VirtualDom_removeNode(changes, localPatches, key + _VirtualDom_POSTFIX, vnode, index);
3585 | }
3586 | 
3587 | 
3588 | 
3589 | // ADD DOM NODES
3590 | //
3591 | // Each DOM node has an "index" assigned in order of traversal. It is important
3592 | // to minimize our crawl over the actual DOM, so these indexes (along with the
3593 | // descendantsCount of virtual nodes) let us skip touching entire subtrees of
3594 | // the DOM if we know there are no patches there.
3595 | 
3596 | 
3597 | function _VirtualDom_addDomNodes(domNode, vNode, patches, eventNode)
3598 | {
3599 | 	_VirtualDom_addDomNodesHelp(domNode, vNode, patches, 0, 0, vNode.b, eventNode);
3600 | }
3601 | 
3602 | 
3603 | // assumes `patches` is non-empty and indexes increase monotonically.
3604 | function _VirtualDom_addDomNodesHelp(domNode, vNode, patches, i, low, high, eventNode)
3605 | {
3606 | 	var patch = patches[i];
3607 | 	var index = patch.r;
3608 | 
3609 | 	while (index === low)
3610 | 	{
3611 | 		var patchType = patch.$;
3612 | 
3613 | 		if (patchType === 1)
3614 | 		{
3615 | 			_VirtualDom_addDomNodes(domNode, vNode.k, patch.s, eventNode);
3616 | 		}
3617 | 		else if (patchType === 8)
3618 | 		{
3619 | 			patch.t = domNode;
3620 | 			patch.u = eventNode;
3621 | 
3622 | 			var subPatches = patch.s.w;
3623 | 			if (subPatches.length > 0)
3624 | 			{
3625 | 				_VirtualDom_addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode);
3626 | 			}
3627 | 		}
3628 | 		else if (patchType === 9)
3629 | 		{
3630 | 			patch.t = domNode;
3631 | 			patch.u = eventNode;
3632 | 
3633 | 			var data = patch.s;
3634 | 			if (data)
3635 | 			{
3636 | 				data.A.s = domNode;
3637 | 				var subPatches = data.w;
3638 | 				if (subPatches.length > 0)
3639 | 				{
3640 | 					_VirtualDom_addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode);
3641 | 				}
3642 | 			}
3643 | 		}
3644 | 		else
3645 | 		{
3646 | 			patch.t = domNode;
3647 | 			patch.u = eventNode;
3648 | 		}
3649 | 
3650 | 		i++;
3651 | 
3652 | 		if (!(patch = patches[i]) || (index = patch.r) > high)
3653 | 		{
3654 | 			return i;
3655 | 		}
3656 | 	}
3657 | 
3658 | 	var tag = vNode.$;
3659 | 
3660 | 	if (tag === 4)
3661 | 	{
3662 | 		var subNode = vNode.k;
3663 | 
3664 | 		while (subNode.$ === 4)
3665 | 		{
3666 | 			subNode = subNode.k;
3667 | 		}
3668 | 
3669 | 		return _VirtualDom_addDomNodesHelp(domNode, subNode, patches, i, low + 1, high, domNode.elm_event_node_ref);
3670 | 	}
3671 | 
3672 | 	// tag must be 1 or 2 at this point
3673 | 
3674 | 	var vKids = vNode.e;
3675 | 	var childNodes = domNode.childNodes;
3676 | 	for (var j = 0; j < vKids.length; j++)
3677 | 	{
3678 | 		low++;
3679 | 		var vKid = tag === 1 ? vKids[j] : vKids[j].b;
3680 | 		var nextLow = low + (vKid.b || 0);
3681 | 		if (low <= index && index <= nextLow)
3682 | 		{
3683 | 			i = _VirtualDom_addDomNodesHelp(childNodes[j], vKid, patches, i, low, nextLow, eventNode);
3684 | 			if (!(patch = patches[i]) || (index = patch.r) > high)
3685 | 			{
3686 | 				return i;
3687 | 			}
3688 | 		}
3689 | 		low = nextLow;
3690 | 	}
3691 | 	return i;
3692 | }
3693 | 
3694 | 
3695 | 
3696 | // APPLY PATCHES
3697 | 
3698 | 
3699 | function _VirtualDom_applyPatches(rootDomNode, oldVirtualNode, patches, eventNode)
3700 | {
3701 | 	if (patches.length === 0)
3702 | 	{
3703 | 		return rootDomNode;
3704 | 	}
3705 | 
3706 | 	_VirtualDom_addDomNodes(rootDomNode, oldVirtualNode, patches, eventNode);
3707 | 	return _VirtualDom_applyPatchesHelp(rootDomNode, patches);
3708 | }
3709 | 
3710 | function _VirtualDom_applyPatchesHelp(rootDomNode, patches)
3711 | {
3712 | 	for (var i = 0; i < patches.length; i++)
3713 | 	{
3714 | 		var patch = patches[i];
3715 | 		var localDomNode = patch.t
3716 | 		var newNode = _VirtualDom_applyPatch(localDomNode, patch);
3717 | 		if (localDomNode === rootDomNode)
3718 | 		{
3719 | 			rootDomNode = newNode;
3720 | 		}
3721 | 	}
3722 | 	return rootDomNode;
3723 | }
3724 | 
3725 | function _VirtualDom_applyPatch(domNode, patch)
3726 | {
3727 | 	switch (patch.$)
3728 | 	{
3729 | 		case 0:
3730 | 			return _VirtualDom_applyPatchRedraw(domNode, patch.s, patch.u);
3731 | 
3732 | 		case 4:
3733 | 			_VirtualDom_applyFacts(domNode, patch.u, patch.s);
3734 | 			return domNode;
3735 | 
3736 | 		case 3:
3737 | 			domNode.replaceData(0, domNode.length, patch.s);
3738 | 			return domNode;
3739 | 
3740 | 		case 1:
3741 | 			return _VirtualDom_applyPatchesHelp(domNode, patch.s);
3742 | 
3743 | 		case 2:
3744 | 			if (domNode.elm_event_node_ref)
3745 | 			{
3746 | 				domNode.elm_event_node_ref.j = patch.s;
3747 | 			}
3748 | 			else
3749 | 			{
3750 | 				domNode.elm_event_node_ref = { j: patch.s, p: patch.u };
3751 | 			}
3752 | 			return domNode;
3753 | 
3754 | 		case 6:
3755 | 			var data = patch.s;
3756 | 			for (var i = 0; i < data.i; i++)
3757 | 			{
3758 | 				domNode.removeChild(domNode.childNodes[data.v]);
3759 | 			}
3760 | 			return domNode;
3761 | 
3762 | 		case 7:
3763 | 			var data = patch.s;
3764 | 			var kids = data.e;
3765 | 			var i = data.v;
3766 | 			var theEnd = domNode.childNodes[i];
3767 | 			for (; i < kids.length; i++)
3768 | 			{
3769 | 				domNode.insertBefore(_VirtualDom_render(kids[i], patch.u), theEnd);
3770 | 			}
3771 | 			return domNode;
3772 | 
3773 | 		case 9:
3774 | 			var data = patch.s;
3775 | 			if (!data)
3776 | 			{
3777 | 				domNode.parentNode.removeChild(domNode);
3778 | 				return domNode;
3779 | 			}
3780 | 			var entry = data.A;
3781 | 			if (typeof entry.r !== 'undefined')
3782 | 			{
3783 | 				domNode.parentNode.removeChild(domNode);
3784 | 			}
3785 | 			entry.s = _VirtualDom_applyPatchesHelp(domNode, data.w);
3786 | 			return domNode;
3787 | 
3788 | 		case 8:
3789 | 			return _VirtualDom_applyPatchReorder(domNode, patch);
3790 | 
3791 | 		case 5:
3792 | 			return patch.s(domNode);
3793 | 
3794 | 		default:
3795 | 			_Debug_crash(10); // 'Ran into an unknown patch!'
3796 | 	}
3797 | }
3798 | 
3799 | 
3800 | function _VirtualDom_applyPatchRedraw(domNode, vNode, eventNode)
3801 | {
3802 | 	var parentNode = domNode.parentNode;
3803 | 	var newNode = _VirtualDom_render(vNode, eventNode);
3804 | 
3805 | 	if (!newNode.elm_event_node_ref)
3806 | 	{
3807 | 		newNode.elm_event_node_ref = domNode.elm_event_node_ref;
3808 | 	}
3809 | 
3810 | 	if (parentNode && newNode !== domNode)
3811 | 	{
3812 | 		parentNode.replaceChild(newNode, domNode);
3813 | 	}
3814 | 	return newNode;
3815 | }
3816 | 
3817 | 
3818 | function _VirtualDom_applyPatchReorder(domNode, patch)
3819 | {
3820 | 	var data = patch.s;
3821 | 
3822 | 	// remove end inserts
3823 | 	var frag = _VirtualDom_applyPatchReorderEndInsertsHelp(data.y, patch);
3824 | 
3825 | 	// removals
3826 | 	domNode = _VirtualDom_applyPatchesHelp(domNode, data.w);
3827 | 
3828 | 	// inserts
3829 | 	var inserts = data.x;
3830 | 	for (var i = 0; i < inserts.length; i++)
3831 | 	{
3832 | 		var insert = inserts[i];
3833 | 		var entry = insert.A;
3834 | 		var node = entry.c === 2
3835 | 			? entry.s
3836 | 			: _VirtualDom_render(entry.z, patch.u);
3837 | 		domNode.insertBefore(node, domNode.childNodes[insert.r]);
3838 | 	}
3839 | 
3840 | 	// add end inserts
3841 | 	if (frag)
3842 | 	{
3843 | 		_VirtualDom_appendChild(domNode, frag);
3844 | 	}
3845 | 
3846 | 	return domNode;
3847 | }
3848 | 
3849 | 
3850 | function _VirtualDom_applyPatchReorderEndInsertsHelp(endInserts, patch)
3851 | {
3852 | 	if (!endInserts)
3853 | 	{
3854 | 		return;
3855 | 	}
3856 | 
3857 | 	var frag = _VirtualDom_doc.createDocumentFragment();
3858 | 	for (var i = 0; i < endInserts.length; i++)
3859 | 	{
3860 | 		var insert = endInserts[i];
3861 | 		var entry = insert.A;
3862 | 		_VirtualDom_appendChild(frag, entry.c === 2
3863 | 			? entry.s
3864 | 			: _VirtualDom_render(entry.z, patch.u)
3865 | 		);
3866 | 	}
3867 | 	return frag;
3868 | }
3869 | 
3870 | 
3871 | function _VirtualDom_virtualize(node)
3872 | {
3873 | 	// TEXT NODES
3874 | 
3875 | 	if (node.nodeType === 3)
3876 | 	{
3877 | 		return _VirtualDom_text(node.textContent);
3878 | 	}
3879 | 
3880 | 
3881 | 	// WEIRD NODES
3882 | 
3883 | 	if (node.nodeType !== 1)
3884 | 	{
3885 | 		return _VirtualDom_text('');
3886 | 	}
3887 | 
3888 | 
3889 | 	// ELEMENT NODES
3890 | 
3891 | 	var attrList = _List_Nil;
3892 | 	var attrs = node.attributes;
3893 | 	for (var i = attrs.length; i--; )
3894 | 	{
3895 | 		var attr = attrs[i];
3896 | 		var name = attr.name;
3897 | 		var value = attr.value;
3898 | 		attrList = _List_Cons( A2(_VirtualDom_attribute, name, value), attrList );
3899 | 	}
3900 | 
3901 | 	var tag = node.tagName.toLowerCase();
3902 | 	var kidList = _List_Nil;
3903 | 	var kids = node.childNodes;
3904 | 
3905 | 	for (var i = kids.length; i--; )
3906 | 	{
3907 | 		kidList = _List_Cons(_VirtualDom_virtualize(kids[i]), kidList);
3908 | 	}
3909 | 	return A3(_VirtualDom_node, tag, attrList, kidList);
3910 | }
3911 | 
3912 | function _VirtualDom_dekey(keyedNode)
3913 | {
3914 | 	var keyedKids = keyedNode.e;
3915 | 	var len = keyedKids.length;
3916 | 	var kids = new Array(len);
3917 | 	for (var i = 0; i < len; i++)
3918 | 	{
3919 | 		kids[i] = keyedKids[i].b;
3920 | 	}
3921 | 
3922 | 	return {
3923 | 		$: 1,
3924 | 		c: keyedNode.c,
3925 | 		d: keyedNode.d,
3926 | 		e: kids,
3927 | 		f: keyedNode.f,
3928 | 		b: keyedNode.b
3929 | 	};
3930 | }
3931 | 
3932 | 
3933 | 
3934 | 
3935 | // ELEMENT
3936 | 
3937 | 
3938 | var _Debugger_element;
3939 | 
3940 | var _Browser_element = _Debugger_element || F4(function(impl, flagDecoder, debugMetadata, args)
3941 | {
3942 | 	return _Platform_initialize(
3943 | 		flagDecoder,
3944 | 		args,
3945 | 		impl.init,
3946 | 		impl.update,
3947 | 		impl.subscriptions,
3948 | 		function(sendToApp, initialModel) {
3949 | 			var view = impl.view;
3950 | 			/**_UNUSED/
3951 | 			var domNode = args['node'];
3952 | 			//*/
3953 | 			/**/
3954 | 			var domNode = args && args['node'] ? args['node'] : _Debug_crash(0);
3955 | 			//*/
3956 | 			var currNode = _VirtualDom_virtualize(domNode);
3957 | 
3958 | 			return _Browser_makeAnimator(initialModel, function(model)
3959 | 			{
3960 | 				var nextNode = view(model);
3961 | 				var patches = _VirtualDom_diff(currNode, nextNode);
3962 | 				domNode = _VirtualDom_applyPatches(domNode, currNode, patches, sendToApp);
3963 | 				currNode = nextNode;
3964 | 			});
3965 | 		}
3966 | 	);
3967 | });
3968 | 
3969 | 
3970 | 
3971 | // DOCUMENT
3972 | 
3973 | 
3974 | var _Debugger_document;
3975 | 
3976 | var _Browser_document = _Debugger_document || F4(function(impl, flagDecoder, debugMetadata, args)
3977 | {
3978 | 	return _Platform_initialize(
3979 | 		flagDecoder,
3980 | 		args,
3981 | 		impl.init,
3982 | 		impl.update,
3983 | 		impl.subscriptions,
3984 | 		function(sendToApp, initialModel) {
3985 | 			var divertHrefToApp = impl.setup && impl.setup(sendToApp)
3986 | 			var view = impl.view;
3987 | 			var title = _VirtualDom_doc.title;
3988 | 			var bodyNode = _VirtualDom_doc.body;
3989 | 			var currNode = _VirtualDom_virtualize(bodyNode);
3990 | 			return _Browser_makeAnimator(initialModel, function(model)
3991 | 			{
3992 | 				_VirtualDom_divertHrefToApp = divertHrefToApp;
3993 | 				var doc = view(model);
3994 | 				var nextNode = _VirtualDom_node('body')(_List_Nil)(doc.body);
3995 | 				var patches = _VirtualDom_diff(currNode, nextNode);
3996 | 				bodyNode = _VirtualDom_applyPatches(bodyNode, currNode, patches, sendToApp);
3997 | 				currNode = nextNode;
3998 | 				_VirtualDom_divertHrefToApp = 0;
3999 | 				(title !== doc.title) && (_VirtualDom_doc.title = title = doc.title);
4000 | 			});
4001 | 		}
4002 | 	);
4003 | });
4004 | 
4005 | 
4006 | 
4007 | // ANIMATION
4008 | 
4009 | 
4010 | var _Browser_cancelAnimationFrame =
4011 | 	typeof cancelAnimationFrame !== 'undefined'
4012 | 		? cancelAnimationFrame
4013 | 		: function(id) { clearTimeout(id); };
4014 | 
4015 | var _Browser_requestAnimationFrame =
4016 | 	typeof requestAnimationFrame !== 'undefined'
4017 | 		? requestAnimationFrame
4018 | 		: function(callback) { return setTimeout(callback, 1000 / 60); };
4019 | 
4020 | 
4021 | function _Browser_makeAnimator(model, draw)
4022 | {
4023 | 	draw(model);
4024 | 
4025 | 	var state = 0;
4026 | 
4027 | 	function updateIfNeeded()
4028 | 	{
4029 | 		state = state === 1
4030 | 			? 0
4031 | 			: ( _Browser_requestAnimationFrame(updateIfNeeded), draw(model), 1 );
4032 | 	}
4033 | 
4034 | 	return function(nextModel, isSync)
4035 | 	{
4036 | 		model = nextModel;
4037 | 
4038 | 		isSync
4039 | 			? ( draw(model),
4040 | 				state === 2 && (state = 1)
4041 | 				)
4042 | 			: ( state === 0 && _Browser_requestAnimationFrame(updateIfNeeded),
4043 | 				state = 2
4044 | 				);
4045 | 	};
4046 | }
4047 | 
4048 | 
4049 | 
4050 | // APPLICATION
4051 | 
4052 | 
4053 | function _Browser_application(impl)
4054 | {
4055 | 	var onUrlChange = impl.onUrlChange;
4056 | 	var onUrlRequest = impl.onUrlRequest;
4057 | 	var key = function() { key.a(onUrlChange(_Browser_getUrl())); };
4058 | 
4059 | 	return _Browser_document({
4060 | 		setup: function(sendToApp)
4061 | 		{
4062 | 			key.a = sendToApp;
4063 | 			_Browser_window.addEventListener('popstate', key);
4064 | 			_Browser_window.navigator.userAgent.indexOf('Trident') < 0 || _Browser_window.addEventListener('hashchange', key);
4065 | 
4066 | 			return F2(function(domNode, event)
4067 | 			{
4068 | 				if (!event.ctrlKey && !event.metaKey && !event.shiftKey && event.button < 1 && !domNode.target && !domNode.hasAttribute('download'))
4069 | 				{
4070 | 					event.preventDefault();
4071 | 					var href = domNode.href;
4072 | 					var curr = _Browser_getUrl();
4073 | 					var next = $elm$url$Url$fromString(href).a;
4074 | 					sendToApp(onUrlRequest(
4075 | 						(next
4076 | 							&& curr.protocol === next.protocol
4077 | 							&& curr.host === next.host
4078 | 							&& curr.port_.a === next.port_.a
4079 | 						)
4080 | 							? $elm$browser$Browser$Internal(next)
4081 | 							: $elm$browser$Browser$External(href)
4082 | 					));
4083 | 				}
4084 | 			});
4085 | 		},
4086 | 		init: function(flags)
4087 | 		{
4088 | 			return A3(impl.init, flags, _Browser_getUrl(), key);
4089 | 		},
4090 | 		view: impl.view,
4091 | 		update: impl.update,
4092 | 		subscriptions: impl.subscriptions
4093 | 	});
4094 | }
4095 | 
4096 | function _Browser_getUrl()
4097 | {
4098 | 	return $elm$url$Url$fromString(_VirtualDom_doc.location.href).a || _Debug_crash(1);
4099 | }
4100 | 
4101 | var _Browser_go = F2(function(key, n)
4102 | {
4103 | 	return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function() {
4104 | 		n && history.go(n);
4105 | 		key();
4106 | 	}));
4107 | });
4108 | 
4109 | var _Browser_pushUrl = F2(function(key, url)
4110 | {
4111 | 	return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function() {
4112 | 		history.pushState({}, '', url);
4113 | 		key();
4114 | 	}));
4115 | });
4116 | 
4117 | var _Browser_replaceUrl = F2(function(key, url)
4118 | {
4119 | 	return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function() {
4120 | 		history.replaceState({}, '', url);
4121 | 		key();
4122 | 	}));
4123 | });
4124 | 
4125 | 
4126 | 
4127 | // GLOBAL EVENTS
4128 | 
4129 | 
4130 | var _Browser_fakeNode = { addEventListener: function() {}, removeEventListener: function() {} };
4131 | var _Browser_doc = typeof document !== 'undefined' ? document : _Browser_fakeNode;
4132 | var _Browser_window = typeof window !== 'undefined' ? window : _Browser_fakeNode;
4133 | 
4134 | var _Browser_on = F3(function(node, eventName, sendToSelf)
4135 | {
4136 | 	return _Scheduler_spawn(_Scheduler_binding(function(callback)
4137 | 	{
4138 | 		function handler(event)	{ _Scheduler_rawSpawn(sendToSelf(event)); }
4139 | 		node.addEventListener(eventName, handler, _VirtualDom_passiveSupported && { passive: true });
4140 | 		return function() { node.removeEventListener(eventName, handler); };
4141 | 	}));
4142 | });
4143 | 
4144 | var _Browser_decodeEvent = F2(function(decoder, event)
4145 | {
4146 | 	var result = _Json_runHelp(decoder, event);
4147 | 	return $elm$core$Result$isOk(result) ? $elm$core$Maybe$Just(result.a) : $elm$core$Maybe$Nothing;
4148 | });
4149 | 
4150 | 
4151 | 
4152 | // PAGE VISIBILITY
4153 | 
4154 | 
4155 | function _Browser_visibilityInfo()
4156 | {
4157 | 	return (typeof _VirtualDom_doc.hidden !== 'undefined')
4158 | 		? { hidden: 'hidden', change: 'visibilitychange' }
4159 | 		:
4160 | 	(typeof _VirtualDom_doc.mozHidden !== 'undefined')
4161 | 		? { hidden: 'mozHidden', change: 'mozvisibilitychange' }
4162 | 		:
4163 | 	(typeof _VirtualDom_doc.msHidden !== 'undefined')
4164 | 		? { hidden: 'msHidden', change: 'msvisibilitychange' }
4165 | 		:
4166 | 	(typeof _VirtualDom_doc.webkitHidden !== 'undefined')
4167 | 		? { hidden: 'webkitHidden', change: 'webkitvisibilitychange' }
4168 | 		: { hidden: 'hidden', change: 'visibilitychange' };
4169 | }
4170 | 
4171 | 
4172 | 
4173 | // ANIMATION FRAMES
4174 | 
4175 | 
4176 | function _Browser_rAF()
4177 | {
4178 | 	return _Scheduler_binding(function(callback)
4179 | 	{
4180 | 		var id = _Browser_requestAnimationFrame(function() {
4181 | 			callback(_Scheduler_succeed(Date.now()));
4182 | 		});
4183 | 
4184 | 		return function() {
4185 | 			_Browser_cancelAnimationFrame(id);
4186 | 		};
4187 | 	});
4188 | }
4189 | 
4190 | 
4191 | function _Browser_now()
4192 | {
4193 | 	return _Scheduler_binding(function(callback)
4194 | 	{
4195 | 		callback(_Scheduler_succeed(Date.now()));
4196 | 	});
4197 | }
4198 | 
4199 | 
4200 | 
4201 | // DOM STUFF
4202 | 
4203 | 
4204 | function _Browser_withNode(id, doStuff)
4205 | {
4206 | 	return _Scheduler_binding(function(callback)
4207 | 	{
4208 | 		_Browser_requestAnimationFrame(function() {
4209 | 			var node = document.getElementById(id);
4210 | 			callback(node
4211 | 				? _Scheduler_succeed(doStuff(node))
4212 | 				: _Scheduler_fail($elm$browser$Browser$Dom$NotFound(id))
4213 | 			);
4214 | 		});
4215 | 	});
4216 | }
4217 | 
4218 | 
4219 | function _Browser_withWindow(doStuff)
4220 | {
4221 | 	return _Scheduler_binding(function(callback)
4222 | 	{
4223 | 		_Browser_requestAnimationFrame(function() {
4224 | 			callback(_Scheduler_succeed(doStuff()));
4225 | 		});
4226 | 	});
4227 | }
4228 | 
4229 | 
4230 | // FOCUS and BLUR
4231 | 
4232 | 
4233 | var _Browser_call = F2(function(functionName, id)
4234 | {
4235 | 	return _Browser_withNode(id, function(node) {
4236 | 		node[functionName]();
4237 | 		return _Utils_Tuple0;
4238 | 	});
4239 | });
4240 | 
4241 | 
4242 | 
4243 | // WINDOW VIEWPORT
4244 | 
4245 | 
4246 | function _Browser_getViewport()
4247 | {
4248 | 	return {
4249 | 		scene: _Browser_getScene(),
4250 | 		viewport: {
4251 | 			x: _Browser_window.pageXOffset,
4252 | 			y: _Browser_window.pageYOffset,
4253 | 			width: _Browser_doc.documentElement.clientWidth,
4254 | 			height: _Browser_doc.documentElement.clientHeight
4255 | 		}
4256 | 	};
4257 | }
4258 | 
4259 | function _Browser_getScene()
4260 | {
4261 | 	var body = _Browser_doc.body;
4262 | 	var elem = _Browser_doc.documentElement;
4263 | 	return {
4264 | 		width: Math.max(body.scrollWidth, body.offsetWidth, elem.scrollWidth, elem.offsetWidth, elem.clientWidth),
4265 | 		height: Math.max(body.scrollHeight, body.offsetHeight, elem.scrollHeight, elem.offsetHeight, elem.clientHeight)
4266 | 	};
4267 | }
4268 | 
4269 | var _Browser_setViewport = F2(function(x, y)
4270 | {
4271 | 	return _Browser_withWindow(function()
4272 | 	{
4273 | 		_Browser_window.scroll(x, y);
4274 | 		return _Utils_Tuple0;
4275 | 	});
4276 | });
4277 | 
4278 | 
4279 | 
4280 | // ELEMENT VIEWPORT
4281 | 
4282 | 
4283 | function _Browser_getViewportOf(id)
4284 | {
4285 | 	return _Browser_withNode(id, function(node)
4286 | 	{
4287 | 		return {
4288 | 			scene: {
4289 | 				width: node.scrollWidth,
4290 | 				height: node.scrollHeight
4291 | 			},
4292 | 			viewport: {
4293 | 				x: node.scrollLeft,
4294 | 				y: node.scrollTop,
4295 | 				width: node.clientWidth,
4296 | 				height: node.clientHeight
4297 | 			}
4298 | 		};
4299 | 	});
4300 | }
4301 | 
4302 | 
4303 | var _Browser_setViewportOf = F3(function(id, x, y)
4304 | {
4305 | 	return _Browser_withNode(id, function(node)
4306 | 	{
4307 | 		node.scrollLeft = x;
4308 | 		node.scrollTop = y;
4309 | 		return _Utils_Tuple0;
4310 | 	});
4311 | });
4312 | 
4313 | 
4314 | 
4315 | // ELEMENT
4316 | 
4317 | 
4318 | function _Browser_getElement(id)
4319 | {
4320 | 	return _Browser_withNode(id, function(node)
4321 | 	{
4322 | 		var rect = node.getBoundingClientRect();
4323 | 		var x = _Browser_window.pageXOffset;
4324 | 		var y = _Browser_window.pageYOffset;
4325 | 		return {
4326 | 			scene: _Browser_getScene(),
4327 | 			viewport: {
4328 | 				x: x,
4329 | 				y: y,
4330 | 				width: _Browser_doc.documentElement.clientWidth,
4331 | 				height: _Browser_doc.documentElement.clientHeight
4332 | 			},
4333 | 			element: {
4334 | 				x: x + rect.left,
4335 | 				y: y + rect.top,
4336 | 				width: rect.width,
4337 | 				height: rect.height
4338 | 			}
4339 | 		};
4340 | 	});
4341 | }
4342 | 
4343 | 
4344 | 
4345 | // LOAD and RELOAD
4346 | 
4347 | 
4348 | function _Browser_reload(skipCache)
4349 | {
4350 | 	return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function(callback)
4351 | 	{
4352 | 		_VirtualDom_doc.location.reload(skipCache);
4353 | 	}));
4354 | }
4355 | 
4356 | function _Browser_load(url)
4357 | {
4358 | 	return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function(callback)
4359 | 	{
4360 | 		try
4361 | 		{
4362 | 			_Browser_window.location = url;
4363 | 		}
4364 | 		catch(err)
4365 | 		{
4366 | 			// Only Firefox can throw a NS_ERROR_MALFORMED_URI exception here.
4367 | 			// Other browsers reload the page, so let's be consistent about that.
4368 | 			_VirtualDom_doc.location.reload(false);
4369 | 		}
4370 | 	}));
4371 | }
4372 | var $author$project$Main$init = 0;
4373 | var $elm$core$Basics$EQ = {$: 'EQ'};
4374 | var $elm$core$Basics$GT = {$: 'GT'};
4375 | var $elm$core$Basics$LT = {$: 'LT'};
4376 | var $elm$core$List$cons = _List_cons;
4377 | var $elm$core$Dict$foldr = F3(
4378 | 	function (func, acc, t) {
4379 | 		foldr:
4380 | 		while (true) {
4381 | 			if (t.$ === 'RBEmpty_elm_builtin') {
4382 | 				return acc;
4383 | 			} else {
4384 | 				var key = t.b;
4385 | 				var value = t.c;
4386 | 				var left = t.d;
4387 | 				var right = t.e;
4388 | 				var $temp$func = func,
4389 | 					$temp$acc = A3(
4390 | 					func,
4391 | 					key,
4392 | 					value,
4393 | 					A3($elm$core$Dict$foldr, func, acc, right)),
4394 | 					$temp$t = left;
4395 | 				func = $temp$func;
4396 | 				acc = $temp$acc;
4397 | 				t = $temp$t;
4398 | 				continue foldr;
4399 | 			}
4400 | 		}
4401 | 	});
4402 | var $elm$core$Dict$toList = function (dict) {
4403 | 	return A3(
4404 | 		$elm$core$Dict$foldr,
4405 | 		F3(
4406 | 			function (key, value, list) {
4407 | 				return A2(
4408 | 					$elm$core$List$cons,
4409 | 					_Utils_Tuple2(key, value),
4410 | 					list);
4411 | 			}),
4412 | 		_List_Nil,
4413 | 		dict);
4414 | };
4415 | var $elm$core$Dict$keys = function (dict) {
4416 | 	return A3(
4417 | 		$elm$core$Dict$foldr,
4418 | 		F3(
4419 | 			function (key, value, keyList) {
4420 | 				return A2($elm$core$List$cons, key, keyList);
4421 | 			}),
4422 | 		_List_Nil,
4423 | 		dict);
4424 | };
4425 | var $elm$core$Set$toList = function (_v0) {
4426 | 	var dict = _v0.a;
4427 | 	return $elm$core$Dict$keys(dict);
4428 | };
4429 | var $elm$core$Elm$JsArray$foldr = _JsArray_foldr;
4430 | var $elm$core$Array$foldr = F3(
4431 | 	function (func, baseCase, _v0) {
4432 | 		var tree = _v0.c;
4433 | 		var tail = _v0.d;
4434 | 		var helper = F2(
4435 | 			function (node, acc) {
4436 | 				if (node.$ === 'SubTree') {
4437 | 					var subTree = node.a;
4438 | 					return A3($elm$core$Elm$JsArray$foldr, helper, acc, subTree);
4439 | 				} else {
4440 | 					var values = node.a;
4441 | 					return A3($elm$core$Elm$JsArray$foldr, func, acc, values);
4442 | 				}
4443 | 			});
4444 | 		return A3(
4445 | 			$elm$core$Elm$JsArray$foldr,
4446 | 			helper,
4447 | 			A3($elm$core$Elm$JsArray$foldr, func, baseCase, tail),
4448 | 			tree);
4449 | 	});
4450 | var $elm$core$Array$toList = function (array) {
4451 | 	return A3($elm$core$Array$foldr, $elm$core$List$cons, _List_Nil, array);
4452 | };
4453 | var $elm$core$Result$Err = function (a) {
4454 | 	return {$: 'Err', a: a};
4455 | };
4456 | var $elm$json$Json$Decode$Failure = F2(
4457 | 	function (a, b) {
4458 | 		return {$: 'Failure', a: a, b: b};
4459 | 	});
4460 | var $elm$json$Json$Decode$Field = F2(
4461 | 	function (a, b) {
4462 | 		return {$: 'Field', a: a, b: b};
4463 | 	});
4464 | var $elm$json$Json$Decode$Index = F2(
4465 | 	function (a, b) {
4466 | 		return {$: 'Index', a: a, b: b};
4467 | 	});
4468 | var $elm$core$Result$Ok = function (a) {
4469 | 	return {$: 'Ok', a: a};
4470 | };
4471 | var $elm$json$Json$Decode$OneOf = function (a) {
4472 | 	return {$: 'OneOf', a: a};
4473 | };
4474 | var $elm$core$Basics$False = {$: 'False'};
4475 | var $elm$core$Basics$add = _Basics_add;
4476 | var $elm$core$Maybe$Just = function (a) {
4477 | 	return {$: 'Just', a: a};
4478 | };
4479 | var $elm$core$Maybe$Nothing = {$: 'Nothing'};
4480 | var $elm$core$String$all = _String_all;
4481 | var $elm$core$Basics$and = _Basics_and;
4482 | var $elm$core$Basics$append = _Utils_append;
4483 | var $elm$json$Json$Encode$encode = _Json_encode;
4484 | var $elm$core$String$fromInt = _String_fromNumber;
4485 | var $elm$core$String$join = F2(
4486 | 	function (sep, chunks) {
4487 | 		return A2(
4488 | 			_String_join,
4489 | 			sep,
4490 | 			_List_toArray(chunks));
4491 | 	});
4492 | var $elm$core$String$split = F2(
4493 | 	function (sep, string) {
4494 | 		return _List_fromArray(
4495 | 			A2(_String_split, sep, string));
4496 | 	});
4497 | var $elm$json$Json$Decode$indent = function (str) {
4498 | 	return A2(
4499 | 		$elm$core$String$join,
4500 | 		'\n    ',
4501 | 		A2($elm$core$String$split, '\n', str));
4502 | };
4503 | var $elm$core$List$foldl = F3(
4504 | 	function (func, acc, list) {
4505 | 		foldl:
4506 | 		while (true) {
4507 | 			if (!list.b) {
4508 | 				return acc;
4509 | 			} else {
4510 | 				var x = list.a;
4511 | 				var xs = list.b;
4512 | 				var $temp$func = func,
4513 | 					$temp$acc = A2(func, x, acc),
4514 | 					$temp$list = xs;
4515 | 				func = $temp$func;
4516 | 				acc = $temp$acc;
4517 | 				list = $temp$list;
4518 | 				continue foldl;
4519 | 			}
4520 | 		}
4521 | 	});
4522 | var $elm$core$List$length = function (xs) {
4523 | 	return A3(
4524 | 		$elm$core$List$foldl,
4525 | 		F2(
4526 | 			function (_v0, i) {
4527 | 				return i + 1;
4528 | 			}),
4529 | 		0,
4530 | 		xs);
4531 | };
4532 | var $elm$core$List$map2 = _List_map2;
4533 | var $elm$core$Basics$le = _Utils_le;
4534 | var $elm$core$Basics$sub = _Basics_sub;
4535 | var $elm$core$List$rangeHelp = F3(
4536 | 	function (lo, hi, list) {
4537 | 		rangeHelp:
4538 | 		while (true) {
4539 | 			if (_Utils_cmp(lo, hi) < 1) {
4540 | 				var $temp$lo = lo,
4541 | 					$temp$hi = hi - 1,
4542 | 					$temp$list = A2($elm$core$List$cons, hi, list);
4543 | 				lo = $temp$lo;
4544 | 				hi = $temp$hi;
4545 | 				list = $temp$list;
4546 | 				continue rangeHelp;
4547 | 			} else {
4548 | 				return list;
4549 | 			}
4550 | 		}
4551 | 	});
4552 | var $elm$core$List$range = F2(
4553 | 	function (lo, hi) {
4554 | 		return A3($elm$core$List$rangeHelp, lo, hi, _List_Nil);
4555 | 	});
4556 | var $elm$core$List$indexedMap = F2(
4557 | 	function (f, xs) {
4558 | 		return A3(
4559 | 			$elm$core$List$map2,
4560 | 			f,
4561 | 			A2(
4562 | 				$elm$core$List$range,
4563 | 				0,
4564 | 				$elm$core$List$length(xs) - 1),
4565 | 			xs);
4566 | 	});
4567 | var $elm$core$Char$toCode = _Char_toCode;
4568 | var $elm$core$Char$isLower = function (_char) {
4569 | 	var code = $elm$core$Char$toCode(_char);
4570 | 	return (97 <= code) && (code <= 122);
4571 | };
4572 | var $elm$core$Char$isUpper = function (_char) {
4573 | 	var code = $elm$core$Char$toCode(_char);
4574 | 	return (code <= 90) && (65 <= code);
4575 | };
4576 | var $elm$core$Basics$or = _Basics_or;
4577 | var $elm$core$Char$isAlpha = function (_char) {
4578 | 	return $elm$core$Char$isLower(_char) || $elm$core$Char$isUpper(_char);
4579 | };
4580 | var $elm$core$Char$isDigit = function (_char) {
4581 | 	var code = $elm$core$Char$toCode(_char);
4582 | 	return (code <= 57) && (48 <= code);
4583 | };
4584 | var $elm$core$Char$isAlphaNum = function (_char) {
4585 | 	return $elm$core$Char$isLower(_char) || ($elm$core$Char$isUpper(_char) || $elm$core$Char$isDigit(_char));
4586 | };
4587 | var $elm$core$List$reverse = function (list) {
4588 | 	return A3($elm$core$List$foldl, $elm$core$List$cons, _List_Nil, list);
4589 | };
4590 | var $elm$core$String$uncons = _String_uncons;
4591 | var $elm$json$Json$Decode$errorOneOf = F2(
4592 | 	function (i, error) {
4593 | 		return '\n\n(' + ($elm$core$String$fromInt(i + 1) + (') ' + $elm$json$Json$Decode$indent(
4594 | 			$elm$json$Json$Decode$errorToString(error))));
4595 | 	});
4596 | var $elm$json$Json$Decode$errorToString = function (error) {
4597 | 	return A2($elm$json$Json$Decode$errorToStringHelp, error, _List_Nil);
4598 | };
4599 | var $elm$json$Json$Decode$errorToStringHelp = F2(
4600 | 	function (error, context) {
4601 | 		errorToStringHelp:
4602 | 		while (true) {
4603 | 			switch (error.$) {
4604 | 				case 'Field':
4605 | 					var f = error.a;
4606 | 					var err = error.b;
4607 | 					var isSimple = function () {
4608 | 						var _v1 = $elm$core$String$uncons(f);
4609 | 						if (_v1.$ === 'Nothing') {
4610 | 							return false;
4611 | 						} else {
4612 | 							var _v2 = _v1.a;
4613 | 							var _char = _v2.a;
4614 | 							var rest = _v2.b;
4615 | 							return $elm$core$Char$isAlpha(_char) && A2($elm$core$String$all, $elm$core$Char$isAlphaNum, rest);
4616 | 						}
4617 | 					}();
4618 | 					var fieldName = isSimple ? ('.' + f) : ('[\'' + (f + '\']'));
4619 | 					var $temp$error = err,
4620 | 						$temp$context = A2($elm$core$List$cons, fieldName, context);
4621 | 					error = $temp$error;
4622 | 					context = $temp$context;
4623 | 					continue errorToStringHelp;
4624 | 				case 'Index':
4625 | 					var i = error.a;
4626 | 					var err = error.b;
4627 | 					var indexName = '[' + ($elm$core$String$fromInt(i) + ']');
4628 | 					var $temp$error = err,
4629 | 						$temp$context = A2($elm$core$List$cons, indexName, context);
4630 | 					error = $temp$error;
4631 | 					context = $temp$context;
4632 | 					continue errorToStringHelp;
4633 | 				case 'OneOf':
4634 | 					var errors = error.a;
4635 | 					if (!errors.b) {
4636 | 						return 'Ran into a Json.Decode.oneOf with no possibilities' + function () {
4637 | 							if (!context.b) {
4638 | 								return '!';
4639 | 							} else {
4640 | 								return ' at json' + A2(
4641 | 									$elm$core$String$join,
4642 | 									'',
4643 | 									$elm$core$List$reverse(context));
4644 | 							}
4645 | 						}();
4646 | 					} else {
4647 | 						if (!errors.b.b) {
4648 | 							var err = errors.a;
4649 | 							var $temp$error = err,
4650 | 								$temp$context = context;
4651 | 							error = $temp$error;
4652 | 							context = $temp$context;
4653 | 							continue errorToStringHelp;
4654 | 						} else {
4655 | 							var starter = function () {
4656 | 								if (!context.b) {
4657 | 									return 'Json.Decode.oneOf';
4658 | 								} else {
4659 | 									return 'The Json.Decode.oneOf at json' + A2(
4660 | 										$elm$core$String$join,
4661 | 										'',
4662 | 										$elm$core$List$reverse(context));
4663 | 								}
4664 | 							}();
4665 | 							var introduction = starter + (' failed in the following ' + ($elm$core$String$fromInt(
4666 | 								$elm$core$List$length(errors)) + ' ways:'));
4667 | 							return A2(
4668 | 								$elm$core$String$join,
4669 | 								'\n\n',
4670 | 								A2(
4671 | 									$elm$core$List$cons,
4672 | 									introduction,
4673 | 									A2($elm$core$List$indexedMap, $elm$json$Json$Decode$errorOneOf, errors)));
4674 | 						}
4675 | 					}
4676 | 				default:
4677 | 					var msg = error.a;
4678 | 					var json = error.b;
4679 | 					var introduction = function () {
4680 | 						if (!context.b) {
4681 | 							return 'Problem with the given value:\n\n';
4682 | 						} else {
4683 | 							return 'Problem with the value at json' + (A2(
4684 | 								$elm$core$String$join,
4685 | 								'',
4686 | 								$elm$core$List$reverse(context)) + ':\n\n    ');
4687 | 						}
4688 | 					}();
4689 | 					return introduction + ($elm$json$Json$Decode$indent(
4690 | 						A2($elm$json$Json$Encode$encode, 4, json)) + ('\n\n' + msg));
4691 | 			}
4692 | 		}
4693 | 	});
4694 | var $elm$core$Array$branchFactor = 32;
4695 | var $elm$core$Array$Array_elm_builtin = F4(
4696 | 	function (a, b, c, d) {
4697 | 		return {$: 'Array_elm_builtin', a: a, b: b, c: c, d: d};
4698 | 	});
4699 | var $elm$core$Elm$JsArray$empty = _JsArray_empty;
4700 | var $elm$core$Basics$ceiling = _Basics_ceiling;
4701 | var $elm$core$Basics$fdiv = _Basics_fdiv;
4702 | var $elm$core$Basics$logBase = F2(
4703 | 	function (base, number) {
4704 | 		return _Basics_log(number) / _Basics_log(base);
4705 | 	});
4706 | var $elm$core$Basics$toFloat = _Basics_toFloat;
4707 | var $elm$core$Array$shiftStep = $elm$core$Basics$ceiling(
4708 | 	A2($elm$core$Basics$logBase, 2, $elm$core$Array$branchFactor));
4709 | var $elm$core$Array$empty = A4($elm$core$Array$Array_elm_builtin, 0, $elm$core$Array$shiftStep, $elm$core$Elm$JsArray$empty, $elm$core$Elm$JsArray$empty);
4710 | var $elm$core$Elm$JsArray$initialize = _JsArray_initialize;
4711 | var $elm$core$Array$Leaf = function (a) {
4712 | 	return {$: 'Leaf', a: a};
4713 | };
4714 | var $elm$core$Basics$apL = F2(
4715 | 	function (f, x) {
4716 | 		return f(x);
4717 | 	});
4718 | var $elm$core$Basics$apR = F2(
4719 | 	function (x, f) {
4720 | 		return f(x);
4721 | 	});
4722 | var $elm$core$Basics$eq = _Utils_equal;
4723 | var $elm$core$Basics$floor = _Basics_floor;
4724 | var $elm$core$Elm$JsArray$length = _JsArray_length;
4725 | var $elm$core$Basics$gt = _Utils_gt;
4726 | var $elm$core$Basics$max = F2(
4727 | 	function (x, y) {
4728 | 		return (_Utils_cmp(x, y) > 0) ? x : y;
4729 | 	});
4730 | var $elm$core$Basics$mul = _Basics_mul;
4731 | var $elm$core$Array$SubTree = function (a) {
4732 | 	return {$: 'SubTree', a: a};
4733 | };
4734 | var $elm$core$Elm$JsArray$initializeFromList = _JsArray_initializeFromList;
4735 | var $elm$core$Array$compressNodes = F2(
4736 | 	function (nodes, acc) {
4737 | 		compressNodes:
4738 | 		while (true) {
4739 | 			var _v0 = A2($elm$core$Elm$JsArray$initializeFromList, $elm$core$Array$branchFactor, nodes);
4740 | 			var node = _v0.a;
4741 | 			var remainingNodes = _v0.b;
4742 | 			var newAcc = A2(
4743 | 				$elm$core$List$cons,
4744 | 				$elm$core$Array$SubTree(node),
4745 | 				acc);
4746 | 			if (!remainingNodes.b) {
4747 | 				return $elm$core$List$reverse(newAcc);
4748 | 			} else {
4749 | 				var $temp$nodes = remainingNodes,
4750 | 					$temp$acc = newAcc;
4751 | 				nodes = $temp$nodes;
4752 | 				acc = $temp$acc;
4753 | 				continue compressNodes;
4754 | 			}
4755 | 		}
4756 | 	});
4757 | var $elm$core$Tuple$first = function (_v0) {
4758 | 	var x = _v0.a;
4759 | 	return x;
4760 | };
4761 | var $elm$core$Array$treeFromBuilder = F2(
4762 | 	function (nodeList, nodeListSize) {
4763 | 		treeFromBuilder:
4764 | 		while (true) {
4765 | 			var newNodeSize = $elm$core$Basics$ceiling(nodeListSize / $elm$core$Array$branchFactor);
4766 | 			if (newNodeSize === 1) {
4767 | 				return A2($elm$core$Elm$JsArray$initializeFromList, $elm$core$Array$branchFactor, nodeList).a;
4768 | 			} else {
4769 | 				var $temp$nodeList = A2($elm$core$Array$compressNodes, nodeList, _List_Nil),
4770 | 					$temp$nodeListSize = newNodeSize;
4771 | 				nodeList = $temp$nodeList;
4772 | 				nodeListSize = $temp$nodeListSize;
4773 | 				continue treeFromBuilder;
4774 | 			}
4775 | 		}
4776 | 	});
4777 | var $elm$core$Array$builderToArray = F2(
4778 | 	function (reverseNodeList, builder) {
4779 | 		if (!builder.nodeListSize) {
4780 | 			return A4(
4781 | 				$elm$core$Array$Array_elm_builtin,
4782 | 				$elm$core$Elm$JsArray$length(builder.tail),
4783 | 				$elm$core$Array$shiftStep,
4784 | 				$elm$core$Elm$JsArray$empty,
4785 | 				builder.tail);
4786 | 		} else {
4787 | 			var treeLen = builder.nodeListSize * $elm$core$Array$branchFactor;
4788 | 			var depth = $elm$core$Basics$floor(
4789 | 				A2($elm$core$Basics$logBase, $elm$core$Array$branchFactor, treeLen - 1));
4790 | 			var correctNodeList = reverseNodeList ? $elm$core$List$reverse(builder.nodeList) : builder.nodeList;
4791 | 			var tree = A2($elm$core$Array$treeFromBuilder, correctNodeList, builder.nodeListSize);
4792 | 			return A4(
4793 | 				$elm$core$Array$Array_elm_builtin,
4794 | 				$elm$core$Elm$JsArray$length(builder.tail) + treeLen,
4795 | 				A2($elm$core$Basics$max, 5, depth * $elm$core$Array$shiftStep),
4796 | 				tree,
4797 | 				builder.tail);
4798 | 		}
4799 | 	});
4800 | var $elm$core$Basics$idiv = _Basics_idiv;
4801 | var $elm$core$Basics$lt = _Utils_lt;
4802 | var $elm$core$Array$initializeHelp = F5(
4803 | 	function (fn, fromIndex, len, nodeList, tail) {
4804 | 		initializeHelp:
4805 | 		while (true) {
4806 | 			if (fromIndex < 0) {
4807 | 				return A2(
4808 | 					$elm$core$Array$builderToArray,
4809 | 					false,
4810 | 					{nodeList: nodeList, nodeListSize: (len / $elm$core$Array$branchFactor) | 0, tail: tail});
4811 | 			} else {
4812 | 				var leaf = $elm$core$Array$Leaf(
4813 | 					A3($elm$core$Elm$JsArray$initialize, $elm$core$Array$branchFactor, fromIndex, fn));
4814 | 				var $temp$fn = fn,
4815 | 					$temp$fromIndex = fromIndex - $elm$core$Array$branchFactor,
4816 | 					$temp$len = len,
4817 | 					$temp$nodeList = A2($elm$core$List$cons, leaf, nodeList),
4818 | 					$temp$tail = tail;
4819 | 				fn = $temp$fn;
4820 | 				fromIndex = $temp$fromIndex;
4821 | 				len = $temp$len;
4822 | 				nodeList = $temp$nodeList;
4823 | 				tail = $temp$tail;
4824 | 				continue initializeHelp;
4825 | 			}
4826 | 		}
4827 | 	});
4828 | var $elm$core$Basics$remainderBy = _Basics_remainderBy;
4829 | var $elm$core$Array$initialize = F2(
4830 | 	function (len, fn) {
4831 | 		if (len <= 0) {
4832 | 			return $elm$core$Array$empty;
4833 | 		} else {
4834 | 			var tailLen = len % $elm$core$Array$branchFactor;
4835 | 			var tail = A3($elm$core$Elm$JsArray$initialize, tailLen, len - tailLen, fn);
4836 | 			var initialFromIndex = (len - tailLen) - $elm$core$Array$branchFactor;
4837 | 			return A5($elm$core$Array$initializeHelp, fn, initialFromIndex, len, _List_Nil, tail);
4838 | 		}
4839 | 	});
4840 | var $elm$core$Basics$True = {$: 'True'};
4841 | var $elm$core$Result$isOk = function (result) {
4842 | 	if (result.$ === 'Ok') {
4843 | 		return true;
4844 | 	} else {
4845 | 		return false;
4846 | 	}
4847 | };
4848 | var $elm$json$Json$Decode$map = _Json_map1;
4849 | var $elm$json$Json$Decode$map2 = _Json_map2;
4850 | var $elm$json$Json$Decode$succeed = _Json_succeed;
4851 | var $elm$virtual_dom$VirtualDom$toHandlerInt = function (handler) {
4852 | 	switch (handler.$) {
4853 | 		case 'Normal':
4854 | 			return 0;
4855 | 		case 'MayStopPropagation':
4856 | 			return 1;
4857 | 		case 'MayPreventDefault':
4858 | 			return 2;
4859 | 		default:
4860 | 			return 3;
4861 | 	}
4862 | };
4863 | var $elm$browser$Browser$External = function (a) {
4864 | 	return {$: 'External', a: a};
4865 | };
4866 | var $elm$browser$Browser$Internal = function (a) {
4867 | 	return {$: 'Internal', a: a};
4868 | };
4869 | var $elm$core$Basics$identity = function (x) {
4870 | 	return x;
4871 | };
4872 | var $elm$browser$Browser$Dom$NotFound = function (a) {
4873 | 	return {$: 'NotFound', a: a};
4874 | };
4875 | var $elm$url$Url$Http = {$: 'Http'};
4876 | var $elm$url$Url$Https = {$: 'Https'};
4877 | var $elm$url$Url$Url = F6(
4878 | 	function (protocol, host, port_, path, query, fragment) {
4879 | 		return {fragment: fragment, host: host, path: path, port_: port_, protocol: protocol, query: query};
4880 | 	});
4881 | var $elm$core$String$contains = _String_contains;
4882 | var $elm$core$String$length = _String_length;
4883 | var $elm$core$String$slice = _String_slice;
4884 | var $elm$core$String$dropLeft = F2(
4885 | 	function (n, string) {
4886 | 		return (n < 1) ? string : A3(
4887 | 			$elm$core$String$slice,
4888 | 			n,
4889 | 			$elm$core$String$length(string),
4890 | 			string);
4891 | 	});
4892 | var $elm$core$String$indexes = _String_indexes;
4893 | var $elm$core$String$isEmpty = function (string) {
4894 | 	return string === '';
4895 | };
4896 | var $elm$core$String$left = F2(
4897 | 	function (n, string) {
4898 | 		return (n < 1) ? '' : A3($elm$core$String$slice, 0, n, string);
4899 | 	});
4900 | var $elm$core$String$toInt = _String_toInt;
4901 | var $elm$url$Url$chompBeforePath = F5(
4902 | 	function (protocol, path, params, frag, str) {
4903 | 		if ($elm$core$String$isEmpty(str) || A2($elm$core$String$contains, '@', str)) {
4904 | 			return $elm$core$Maybe$Nothing;
4905 | 		} else {
4906 | 			var _v0 = A2($elm$core$String$indexes, ':', str);
4907 | 			if (!_v0.b) {
4908 | 				return $elm$core$Maybe$Just(
4909 | 					A6($elm$url$Url$Url, protocol, str, $elm$core$Maybe$Nothing, path, params, frag));
4910 | 			} else {
4911 | 				if (!_v0.b.b) {
4912 | 					var i = _v0.a;
4913 | 					var _v1 = $elm$core$String$toInt(
4914 | 						A2($elm$core$String$dropLeft, i + 1, str));
4915 | 					if (_v1.$ === 'Nothing') {
4916 | 						return $elm$core$Maybe$Nothing;
4917 | 					} else {
4918 | 						var port_ = _v1;
4919 | 						return $elm$core$Maybe$Just(
4920 | 							A6(
4921 | 								$elm$url$Url$Url,
4922 | 								protocol,
4923 | 								A2($elm$core$String$left, i, str),
4924 | 								port_,
4925 | 								path,
4926 | 								params,
4927 | 								frag));
4928 | 					}
4929 | 				} else {
4930 | 					return $elm$core$Maybe$Nothing;
4931 | 				}
4932 | 			}
4933 | 		}
4934 | 	});
4935 | var $elm$url$Url$chompBeforeQuery = F4(
4936 | 	function (protocol, params, frag, str) {
4937 | 		if ($elm$core$String$isEmpty(str)) {
4938 | 			return $elm$core$Maybe$Nothing;
4939 | 		} else {
4940 | 			var _v0 = A2($elm$core$String$indexes, '/', str);
4941 | 			if (!_v0.b) {
4942 | 				return A5($elm$url$Url$chompBeforePath, protocol, '/', params, frag, str);
4943 | 			} else {
4944 | 				var i = _v0.a;
4945 | 				return A5(
4946 | 					$elm$url$Url$chompBeforePath,
4947 | 					protocol,
4948 | 					A2($elm$core$String$dropLeft, i, str),
4949 | 					params,
4950 | 					frag,
4951 | 					A2($elm$core$String$left, i, str));
4952 | 			}
4953 | 		}
4954 | 	});
4955 | var $elm$url$Url$chompBeforeFragment = F3(
4956 | 	function (protocol, frag, str) {
4957 | 		if ($elm$core$String$isEmpty(str)) {
4958 | 			return $elm$core$Maybe$Nothing;
4959 | 		} else {
4960 | 			var _v0 = A2($elm$core$String$indexes, '?', str);
4961 | 			if (!_v0.b) {
4962 | 				return A4($elm$url$Url$chompBeforeQuery, protocol, $elm$core$Maybe$Nothing, frag, str);
4963 | 			} else {
4964 | 				var i = _v0.a;
4965 | 				return A4(
4966 | 					$elm$url$Url$chompBeforeQuery,
4967 | 					protocol,
4968 | 					$elm$core$Maybe$Just(
4969 | 						A2($elm$core$String$dropLeft, i + 1, str)),
4970 | 					frag,
4971 | 					A2($elm$core$String$left, i, str));
4972 | 			}
4973 | 		}
4974 | 	});
4975 | var $elm$url$Url$chompAfterProtocol = F2(
4976 | 	function (protocol, str) {
4977 | 		if ($elm$core$String$isEmpty(str)) {
4978 | 			return $elm$core$Maybe$Nothing;
4979 | 		} else {
4980 | 			var _v0 = A2($elm$core$String$indexes, '#', str);
4981 | 			if (!_v0.b) {
4982 | 				return A3($elm$url$Url$chompBeforeFragment, protocol, $elm$core$Maybe$Nothing, str);
4983 | 			} else {
4984 | 				var i = _v0.a;
4985 | 				return A3(
4986 | 					$elm$url$Url$chompBeforeFragment,
4987 | 					protocol,
4988 | 					$elm$core$Maybe$Just(
4989 | 						A2($elm$core$String$dropLeft, i + 1, str)),
4990 | 					A2($elm$core$String$left, i, str));
4991 | 			}
4992 | 		}
4993 | 	});
4994 | var $elm$core$String$startsWith = _String_startsWith;
4995 | var $elm$url$Url$fromString = function (str) {
4996 | 	return A2($elm$core$String$startsWith, 'http://', str) ? A2(
4997 | 		$elm$url$Url$chompAfterProtocol,
4998 | 		$elm$url$Url$Http,
4999 | 		A2($elm$core$String$dropLeft, 7, str)) : (A2($elm$core$String$startsWith, 'https://', str) ? A2(
5000 | 		$elm$url$Url$chompAfterProtocol,
5001 | 		$elm$url$Url$Https,
5002 | 		A2($elm$core$String$dropLeft, 8, str)) : $elm$core$Maybe$Nothing);
5003 | };
5004 | var $elm$core$Basics$never = function (_v0) {
5005 | 	never:
5006 | 	while (true) {
5007 | 		var nvr = _v0.a;
5008 | 		var $temp$_v0 = nvr;
5009 | 		_v0 = $temp$_v0;
5010 | 		continue never;
5011 | 	}
5012 | };
5013 | var $elm$core$Task$Perform = function (a) {
5014 | 	return {$: 'Perform', a: a};
5015 | };
5016 | var $elm$core$Task$succeed = _Scheduler_succeed;
5017 | var $elm$core$Task$init = $elm$core$Task$succeed(_Utils_Tuple0);
5018 | var $elm$core$List$foldrHelper = F4(
5019 | 	function (fn, acc, ctr, ls) {
5020 | 		if (!ls.b) {
5021 | 			return acc;
5022 | 		} else {
5023 | 			var a = ls.a;
5024 | 			var r1 = ls.b;
5025 | 			if (!r1.b) {
5026 | 				return A2(fn, a, acc);
5027 | 			} else {
5028 | 				var b = r1.a;
5029 | 				var r2 = r1.b;
5030 | 				if (!r2.b) {
5031 | 					return A2(
5032 | 						fn,
5033 | 						a,
5034 | 						A2(fn, b, acc));
5035 | 				} else {
5036 | 					var c = r2.a;
5037 | 					var r3 = r2.b;
5038 | 					if (!r3.b) {
5039 | 						return A2(
5040 | 							fn,
5041 | 							a,
5042 | 							A2(
5043 | 								fn,
5044 | 								b,
5045 | 								A2(fn, c, acc)));
5046 | 					} else {
5047 | 						var d = r3.a;
5048 | 						var r4 = r3.b;
5049 | 						var res = (ctr > 500) ? A3(
5050 | 							$elm$core$List$foldl,
5051 | 							fn,
5052 | 							acc,
5053 | 							$elm$core$List$reverse(r4)) : A4($elm$core$List$foldrHelper, fn, acc, ctr + 1, r4);
5054 | 						return A2(
5055 | 							fn,
5056 | 							a,
5057 | 							A2(
5058 | 								fn,
5059 | 								b,
5060 | 								A2(
5061 | 									fn,
5062 | 									c,
5063 | 									A2(fn, d, res))));
5064 | 					}
5065 | 				}
5066 | 			}
5067 | 		}
5068 | 	});
5069 | var $elm$core$List$foldr = F3(
5070 | 	function (fn, acc, ls) {
5071 | 		return A4($elm$core$List$foldrHelper, fn, acc, 0, ls);
5072 | 	});
5073 | var $elm$core$List$map = F2(
5074 | 	function (f, xs) {
5075 | 		return A3(
5076 | 			$elm$core$List$foldr,
5077 | 			F2(
5078 | 				function (x, acc) {
5079 | 					return A2(
5080 | 						$elm$core$List$cons,
5081 | 						f(x),
5082 | 						acc);
5083 | 				}),
5084 | 			_List_Nil,
5085 | 			xs);
5086 | 	});
5087 | var $elm$core$Task$andThen = _Scheduler_andThen;
5088 | var $elm$core$Task$map = F2(
5089 | 	function (func, taskA) {
5090 | 		return A2(
5091 | 			$elm$core$Task$andThen,
5092 | 			function (a) {
5093 | 				return $elm$core$Task$succeed(
5094 | 					func(a));
5095 | 			},
5096 | 			taskA);
5097 | 	});
5098 | var $elm$core$Task$map2 = F3(
5099 | 	function (func, taskA, taskB) {
5100 | 		return A2(
5101 | 			$elm$core$Task$andThen,
5102 | 			function (a) {
5103 | 				return A2(
5104 | 					$elm$core$Task$andThen,
5105 | 					function (b) {
5106 | 						return $elm$core$Task$succeed(
5107 | 							A2(func, a, b));
5108 | 					},
5109 | 					taskB);
5110 | 			},
5111 | 			taskA);
5112 | 	});
5113 | var $elm$core$Task$sequence = function (tasks) {
5114 | 	return A3(
5115 | 		$elm$core$List$foldr,
5116 | 		$elm$core$Task$map2($elm$core$List$cons),
5117 | 		$elm$core$Task$succeed(_List_Nil),
5118 | 		tasks);
5119 | };
5120 | var $elm$core$Platform$sendToApp = _Platform_sendToApp;
5121 | var $elm$core$Task$spawnCmd = F2(
5122 | 	function (router, _v0) {
5123 | 		var task = _v0.a;
5124 | 		return _Scheduler_spawn(
5125 | 			A2(
5126 | 				$elm$core$Task$andThen,
5127 | 				$elm$core$Platform$sendToApp(router),
5128 | 				task));
5129 | 	});
5130 | var $elm$core$Task$onEffects = F3(
5131 | 	function (router, commands, state) {
5132 | 		return A2(
5133 | 			$elm$core$Task$map,
5134 | 			function (_v0) {
5135 | 				return _Utils_Tuple0;
5136 | 			},
5137 | 			$elm$core$Task$sequence(
5138 | 				A2(
5139 | 					$elm$core$List$map,
5140 | 					$elm$core$Task$spawnCmd(router),
5141 | 					commands)));
5142 | 	});
5143 | var $elm$core$Task$onSelfMsg = F3(
5144 | 	function (_v0, _v1, _v2) {
5145 | 		return $elm$core$Task$succeed(_Utils_Tuple0);
5146 | 	});
5147 | var $elm$core$Task$cmdMap = F2(
5148 | 	function (tagger, _v0) {
5149 | 		var task = _v0.a;
5150 | 		return $elm$core$Task$Perform(
5151 | 			A2($elm$core$Task$map, tagger, task));
5152 | 	});
5153 | _Platform_effectManagers['Task'] = _Platform_createManager($elm$core$Task$init, $elm$core$Task$onEffects, $elm$core$Task$onSelfMsg, $elm$core$Task$cmdMap);
5154 | var $elm$core$Task$command = _Platform_leaf('Task');
5155 | var $elm$core$Task$perform = F2(
5156 | 	function (toMessage, task) {
5157 | 		return $elm$core$Task$command(
5158 | 			$elm$core$Task$Perform(
5159 | 				A2($elm$core$Task$map, toMessage, task)));
5160 | 	});
5161 | var $elm$core$Platform$Cmd$batch = _Platform_batch;
5162 | var $elm$core$Platform$Cmd$none = $elm$core$Platform$Cmd$batch(_List_Nil);
5163 | var $elm$core$Platform$Sub$batch = _Platform_batch;
5164 | var $elm$core$Platform$Sub$none = $elm$core$Platform$Sub$batch(_List_Nil);
5165 | var $elm$browser$Browser$sandbox = function (impl) {
5166 | 	return _Browser_element(
5167 | 		{
5168 | 			init: function (_v0) {
5169 | 				return _Utils_Tuple2(impl.init, $elm$core$Platform$Cmd$none);
5170 | 			},
5171 | 			subscriptions: function (_v1) {
5172 | 				return $elm$core$Platform$Sub$none;
5173 | 			},
5174 | 			update: F2(
5175 | 				function (msg, model) {
5176 | 					return _Utils_Tuple2(
5177 | 						A2(impl.update, msg, model),
5178 | 						$elm$core$Platform$Cmd$none);
5179 | 				}),
5180 | 			view: impl.view
5181 | 		});
5182 | };
5183 | var $author$project$Main$update = F2(
5184 | 	function (msg, model) {
5185 | 		if (msg.$ === 'Increment') {
5186 | 			return model + 1;
5187 | 		} else {
5188 | 			return model - 1;
5189 | 		}
5190 | 	});
5191 | var $author$project$Main$Decrement = {$: 'Decrement'};
5192 | var $author$project$Main$Increment = {$: 'Increment'};
5193 | var $elm$html$Html$button = _VirtualDom_node('button');
5194 | var $elm$html$Html$div = _VirtualDom_node('div');
5195 | var $elm$virtual_dom$VirtualDom$Normal = function (a) {
5196 | 	return {$: 'Normal', a: a};
5197 | };
5198 | var $elm$virtual_dom$VirtualDom$on = _VirtualDom_on;
5199 | var $elm$html$Html$Events$on = F2(
5200 | 	function (event, decoder) {
5201 | 		return A2(
5202 | 			$elm$virtual_dom$VirtualDom$on,
5203 | 			event,
5204 | 			$elm$virtual_dom$VirtualDom$Normal(decoder));
5205 | 	});
5206 | var $elm$html$Html$Events$onClick = function (msg) {
5207 | 	return A2(
5208 | 		$elm$html$Html$Events$on,
5209 | 		'click',
5210 | 		$elm$json$Json$Decode$succeed(msg));
5211 | };
5212 | var $elm$virtual_dom$VirtualDom$text = _VirtualDom_text;
5213 | var $elm$html$Html$text = $elm$virtual_dom$VirtualDom$text;
5214 | var $author$project$Main$view = function (model) {
5215 | 	return A2(
5216 | 		$elm$html$Html$div,
5217 | 		_List_Nil,
5218 | 		_List_fromArray(
5219 | 			[
5220 | 				A2(
5221 | 				$elm$html$Html$button,
5222 | 				_List_fromArray(
5223 | 					[
5224 | 						$elm$html$Html$Events$onClick($author$project$Main$Decrement)
5225 | 					]),
5226 | 				_List_fromArray(
5227 | 					[
5228 | 						$elm$html$Html$text('-')
5229 | 					])),
5230 | 				A2(
5231 | 				$elm$html$Html$div,
5232 | 				_List_Nil,
5233 | 				_List_fromArray(
5234 | 					[
5235 | 						$elm$html$Html$text(
5236 | 						$elm$core$String$fromInt(model))
5237 | 					])),
5238 | 				A2(
5239 | 				$elm$html$Html$button,
5240 | 				_List_fromArray(
5241 | 					[
5242 | 						$elm$html$Html$Events$onClick($author$project$Main$Increment)
5243 | 					]),
5244 | 				_List_fromArray(
5245 | 					[
5246 | 						$elm$html$Html$text('+')
5247 | 					]))
5248 | 			]));
5249 | };
5250 | var $author$project$Main$main = $elm$browser$Browser$sandbox(
5251 | 	{init: $author$project$Main$init, update: $author$project$Main$update, view: $author$project$Main$view});
5252 | _Platform_export({'Main':{'init':$author$project$Main$main(
5253 | 	$elm$json$Json$Decode$succeed(_Utils_Tuple0))(0)}});}(this));
5254 | 
5255 |   var app = Elm.Main.init({ node: document.getElementById("elm") });
5256 | }
5257 | catch (e)
5258 | {
5259 |   // display initialization errors (e.g. bad flags, infinite recursion)
5260 |   var header = document.createElement("h1");
5261 |   header.style.fontFamily = "monospace";
5262 |   header.innerText = "Initialization Error";
5263 |   var pre = document.getElementById("elm");
5264 |   document.body.insertBefore(header, pre);
5265 |   pre.innerText = e;
5266 |   throw e;
5267 | }
5268 | </script>
5269 | 
5270 | </body>
5271 | </html>


--------------------------------------------------------------------------------
/examples/basic/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "elm-esbuild-example",
 3 |   "version": "1.0.0",
 4 |   "main": "src/index.js",
 5 |   "license": "MIT",
 6 |   "scripts": {
 7 |     "build": "node ./build.js",
 8 |     "watch": "node ./build.js --watch"
 9 |   },
10 |   "dependencies": {
11 |     "elm": "^0.19.1-5",
12 |     "esbuild": "0.12.24",
13 |     "esbuild-plugin-elm": "file:../../"
14 |   }
15 | }
16 | 


--------------------------------------------------------------------------------
/examples/basic/src/Main.elm:
--------------------------------------------------------------------------------
 1 | module Main exposing (..)
 2 | 
 3 | import Browser
 4 | import Html exposing (Html, button, div, text)
 5 | import Html.Events exposing (onClick)
 6 | 
 7 | 
 8 | main : Program () Model Msg
 9 | main =
10 |     Browser.sandbox { init = init, update = update, view = view }
11 | 
12 | 
13 | type alias Model =
14 |     Int
15 | 
16 | 
17 | init : Model
18 | init =
19 |     0
20 | 
21 | 
22 | type Msg
23 |     = Increment
24 |     | Decrement
25 | 
26 | 
27 | update : Msg -> Model -> Model
28 | update msg model =
29 |     case msg of
30 |         Increment ->
31 |             model + 1
32 | 
33 |         Decrement ->
34 |             model - 1
35 | 
36 | 
37 | view : Model -> Html Msg
38 | view model =
39 |     div []
40 |         [ button [ onClick Decrement ] [ text "-" ]
41 |         , div [] [ text (String.fromInt model) ]
42 |         , button [ onClick Increment ] [ text "+" ]
43 |         ]
44 | 


--------------------------------------------------------------------------------
/examples/basic/src/index.js:
--------------------------------------------------------------------------------
 1 | import { Elm } from './Main.elm';
 2 | 
 3 | const $root = document.createElement('div');
 4 | document.body.appendChild($root);
 5 | 
 6 | Elm.Main.init({
 7 |   node: $root
 8 | });
 9 | 
10 | 


--------------------------------------------------------------------------------
/examples/basic/yarn.lock:
--------------------------------------------------------------------------------
  1 | # THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
  2 | # yarn lockfile v1
  3 | 
  4 | 
  5 | ajv@^6.12.3:
  6 |   version "6.12.6"
  7 |   resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.12.6.tgz#baf5a62e802b07d977034586f8c3baf5adf26df4"
  8 |   integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==
  9 |   dependencies:
 10 |     fast-deep-equal "^3.1.1"
 11 |     fast-json-stable-stringify "^2.0.0"
 12 |     json-schema-traverse "^0.4.1"
 13 |     uri-js "^4.2.2"
 14 | 
 15 | asn1@~0.2.3:
 16 |   version "0.2.4"
 17 |   resolved "https://registry.yarnpkg.com/asn1/-/asn1-0.2.4.tgz#8d2475dfab553bb33e77b54e59e880bb8ce23136"
 18 |   integrity sha512-jxwzQpLQjSmWXgwaCZE9Nz+glAG01yF1QnWgbhGwHI5A6FRIEY6IVqtHhIepHqI7/kyEyQEagBC5mBEFlIYvdg==
 19 |   dependencies:
 20 |     safer-buffer "~2.1.0"
 21 | 
 22 | assert-plus@1.0.0, assert-plus@^1.0.0:
 23 |   version "1.0.0"
 24 |   resolved "https://registry.yarnpkg.com/assert-plus/-/assert-plus-1.0.0.tgz#f12e0f3c5d77b0b1cdd9146942e4e96c1e4dd525"
 25 |   integrity sha1-8S4PPF13sLHN2RRpQuTpbB5N1SU=
 26 | 
 27 | asynckit@^0.4.0:
 28 |   version "0.4.0"
 29 |   resolved "https://registry.yarnpkg.com/asynckit/-/asynckit-0.4.0.tgz#c79ed97f7f34cb8f2ba1bc9790bcc366474b4b79"
 30 |   integrity sha1-x57Zf380y48robyXkLzDZkdLS3k=
 31 | 
 32 | aws-sign2@~0.7.0:
 33 |   version "0.7.0"
 34 |   resolved "https://registry.yarnpkg.com/aws-sign2/-/aws-sign2-0.7.0.tgz#b46e890934a9591f2d2f6f86d7e6a9f1b3fe76a8"
 35 |   integrity sha1-tG6JCTSpWR8tL2+G1+ap8bP+dqg=
 36 | 
 37 | aws4@^1.8.0:
 38 |   version "1.11.0"
 39 |   resolved "https://registry.yarnpkg.com/aws4/-/aws4-1.11.0.tgz#d61f46d83b2519250e2784daf5b09479a8b41c59"
 40 |   integrity sha512-xh1Rl34h6Fi1DC2WWKfxUTVqRsNnr6LsKz2+hfwDxQJWmrx8+c7ylaqBMcHfl1U1r2dsifOvKX3LQuLNZ+XSvA==
 41 | 
 42 | balanced-match@^1.0.0:
 43 |   version "1.0.2"
 44 |   resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.2.tgz#e83e3a7e3f300b34cb9d87f615fa0cbf357690ee"
 45 |   integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==
 46 | 
 47 | bcrypt-pbkdf@^1.0.0:
 48 |   version "1.0.2"
 49 |   resolved "https://registry.yarnpkg.com/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.2.tgz#a4301d389b6a43f9b67ff3ca11a3f6637e360e9e"
 50 |   integrity sha1-pDAdOJtqQ/m2f/PKEaP2Y342Dp4=
 51 |   dependencies:
 52 |     tweetnacl "^0.14.3"
 53 | 
 54 | brace-expansion@^1.1.7:
 55 |   version "1.1.11"
 56 |   resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.11.tgz#3c7fcbf529d87226f3d2f52b966ff5271eb441dd"
 57 |   integrity sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==
 58 |   dependencies:
 59 |     balanced-match "^1.0.0"
 60 |     concat-map "0.0.1"
 61 | 
 62 | caseless@~0.12.0:
 63 |   version "0.12.0"
 64 |   resolved "https://registry.yarnpkg.com/caseless/-/caseless-0.12.0.tgz#1b681c21ff84033c826543090689420d187151dc"
 65 |   integrity sha1-G2gcIf+EAzyCZUMJBolCDRhxUdw=
 66 | 
 67 | combined-stream@^1.0.6, combined-stream@~1.0.6:
 68 |   version "1.0.8"
 69 |   resolved "https://registry.yarnpkg.com/combined-stream/-/combined-stream-1.0.8.tgz#c3d45a8b34fd730631a110a8a2520682b31d5a7f"
 70 |   integrity sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==
 71 |   dependencies:
 72 |     delayed-stream "~1.0.0"
 73 | 
 74 | command-exists@^1.2.9:
 75 |   version "1.2.9"
 76 |   resolved "https://registry.yarnpkg.com/command-exists/-/command-exists-1.2.9.tgz#c50725af3808c8ab0260fd60b01fbfa25b954f69"
 77 |   integrity sha512-LTQ/SGc+s0Xc0Fu5WaKnR0YiygZkm9eKFvyS+fRsU7/ZWFF8ykFM6Pc9aCVf1+xasOOZpO3BAVgVrKvsqKHV7w==
 78 | 
 79 | concat-map@0.0.1:
 80 |   version "0.0.1"
 81 |   resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b"
 82 |   integrity sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==
 83 | 
 84 | core-util-is@1.0.2:
 85 |   version "1.0.2"
 86 |   resolved "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.2.tgz#b5fd54220aa2bc5ab57aab7140c940754503c1a7"
 87 |   integrity sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=
 88 | 
 89 | cross-spawn@6.0.5:
 90 |   version "6.0.5"
 91 |   resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-6.0.5.tgz#4a5ec7c64dfae22c3a14124dbacdee846d80cbc4"
 92 |   integrity sha512-eTVLrBSt7fjbDygz805pMnstIs2VTBNkRm0qxZd+M7A5XDdxVRWO5MxGBXZhjY4cqLYLdtrGqRf8mBPmzwSpWQ==
 93 |   dependencies:
 94 |     nice-try "^1.0.4"
 95 |     path-key "^2.0.1"
 96 |     semver "^5.5.0"
 97 |     shebang-command "^1.2.0"
 98 |     which "^1.2.9"
 99 | 
100 | dashdash@^1.12.0:
101 |   version "1.14.1"
102 |   resolved "https://registry.yarnpkg.com/dashdash/-/dashdash-1.14.1.tgz#853cfa0f7cbe2fed5de20326b8dd581035f6e2f0"
103 |   integrity sha1-hTz6D3y+L+1d4gMmuN1YEDX24vA=
104 |   dependencies:
105 |     assert-plus "^1.0.0"
106 | 
107 | delayed-stream@~1.0.0:
108 |   version "1.0.0"
109 |   resolved "https://registry.yarnpkg.com/delayed-stream/-/delayed-stream-1.0.0.tgz#df3ae199acadfb7d440aaae0b29e2272b24ec619"
110 |   integrity sha1-3zrhmayt+31ECqrgsp4icrJOxhk=
111 | 
112 | ecc-jsbn@~0.1.1:
113 |   version "0.1.2"
114 |   resolved "https://registry.yarnpkg.com/ecc-jsbn/-/ecc-jsbn-0.1.2.tgz#3a83a904e54353287874c564b7549386849a98c9"
115 |   integrity sha1-OoOpBOVDUyh4dMVkt1SThoSamMk=
116 |   dependencies:
117 |     jsbn "~0.1.0"
118 |     safer-buffer "^2.1.0"
119 | 
120 | elm@^0.19.1-5:
121 |   version "0.19.1-5"
122 |   resolved "https://registry.yarnpkg.com/elm/-/elm-0.19.1-5.tgz#61f18437222972e20f316f9b2d2c76a781a9991b"
123 |   integrity sha512-dyBoPvFiNLvxOStQJdyq28gZEjS/enZXdZ5yyCtNtDEMbFJJVQq4pYNRKvhrKKdlxNot6d96iQe1uczoqO5yvA==
124 |   dependencies:
125 |     request "^2.88.0"
126 | 
127 | "esbuild-plugin-elm@file:../..":
128 |   version "0.0.12"
129 |   dependencies:
130 |     command-exists "^1.2.9"
131 |     node-elm-compiler "^5.0.6"
132 | 
133 | esbuild@0.12.24:
134 |   version "0.12.24"
135 |   resolved "https://registry.yarnpkg.com/esbuild/-/esbuild-0.12.24.tgz#21966fad25a80f368ed308101e88102bce0dc68f"
136 |   integrity sha512-C0ibY+HsXzYB6L/pLWEiWjMpghKsIc58Q5yumARwBQsHl9DXPakW+5NI/Y9w4YXiz0PEP6XTGTT/OV4Nnsmb4A==
137 | 
138 | extend@~3.0.2:
139 |   version "3.0.2"
140 |   resolved "https://registry.yarnpkg.com/extend/-/extend-3.0.2.tgz#f8b1136b4071fbd8eb140aff858b1019ec2915fa"
141 |   integrity sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==
142 | 
143 | extsprintf@1.3.0:
144 |   version "1.3.0"
145 |   resolved "https://registry.yarnpkg.com/extsprintf/-/extsprintf-1.3.0.tgz#96918440e3041a7a414f8c52e3c574eb3c3e1e05"
146 |   integrity sha1-lpGEQOMEGnpBT4xS48V06zw+HgU=
147 | 
148 | extsprintf@^1.2.0:
149 |   version "1.4.0"
150 |   resolved "https://registry.yarnpkg.com/extsprintf/-/extsprintf-1.4.0.tgz#e2689f8f356fad62cca65a3a91c5df5f9551692f"
151 |   integrity sha1-4mifjzVvrWLMplo6kcXfX5VRaS8=
152 | 
153 | fast-deep-equal@^3.1.1:
154 |   version "3.1.3"
155 |   resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz#3a7d56b559d6cbc3eb512325244e619a65c6c525"
156 |   integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==
157 | 
158 | fast-json-stable-stringify@^2.0.0:
159 |   version "2.1.0"
160 |   resolved "https://registry.yarnpkg.com/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz#874bf69c6f404c2b5d99c481341399fd55892633"
161 |   integrity sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==
162 | 
163 | find-elm-dependencies@^2.0.4:
164 |   version "2.0.4"
165 |   resolved "https://registry.yarnpkg.com/find-elm-dependencies/-/find-elm-dependencies-2.0.4.tgz#0a327fc8c0c0297b54115efbf0a9d6de474cfc89"
166 |   integrity sha512-x/4w4fVmlD2X4PD9oQ+yh9EyaQef6OtEULdMGBTuWx0Nkppvo2Z/bAiQioW2n+GdRYKypME2b9OmYTw5tw5qDg==
167 |   dependencies:
168 |     firstline "^1.2.0"
169 |     lodash "^4.17.19"
170 | 
171 | firstline@^1.2.0:
172 |   version "1.3.1"
173 |   resolved "https://registry.yarnpkg.com/firstline/-/firstline-1.3.1.tgz#59e84af0fd858fbc6dac0a0ff97fd22a47e58084"
174 |   integrity sha512-ycwgqtoxujz1dm0kjkBFOPQMESxB9uKc/PlD951dQDIG+tBXRpYZC2UmJb0gDxopQ1ZX6oyRQN3goRczYu7Deg==
175 | 
176 | forever-agent@~0.6.1:
177 |   version "0.6.1"
178 |   resolved "https://registry.yarnpkg.com/forever-agent/-/forever-agent-0.6.1.tgz#fbc71f0c41adeb37f96c577ad1ed42d8fdacca91"
179 |   integrity sha1-+8cfDEGt6zf5bFd60e1C2P2sypE=
180 | 
181 | form-data@~2.3.2:
182 |   version "2.3.3"
183 |   resolved "https://registry.yarnpkg.com/form-data/-/form-data-2.3.3.tgz#dcce52c05f644f298c6a7ab936bd724ceffbf3a6"
184 |   integrity sha512-1lLKB2Mu3aGP1Q/2eCOx0fNbRMe7XdwktwOruhfqqd0rIJWwN4Dh+E3hrPSlDCXnSR7UtZ1N38rVXm+6+MEhJQ==
185 |   dependencies:
186 |     asynckit "^0.4.0"
187 |     combined-stream "^1.0.6"
188 |     mime-types "^2.1.12"
189 | 
190 | fs.realpath@^1.0.0:
191 |   version "1.0.0"
192 |   resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f"
193 |   integrity sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==
194 | 
195 | getpass@^0.1.1:
196 |   version "0.1.7"
197 |   resolved "https://registry.yarnpkg.com/getpass/-/getpass-0.1.7.tgz#5eff8e3e684d569ae4cb2b1282604e8ba62149fa"
198 |   integrity sha1-Xv+OPmhNVprkyysSgmBOi6YhSfo=
199 |   dependencies:
200 |     assert-plus "^1.0.0"
201 | 
202 | glob@^7.1.3:
203 |   version "7.2.3"
204 |   resolved "https://registry.yarnpkg.com/glob/-/glob-7.2.3.tgz#b8df0fb802bbfa8e89bd1d938b4e16578ed44f2b"
205 |   integrity sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==
206 |   dependencies:
207 |     fs.realpath "^1.0.0"
208 |     inflight "^1.0.4"
209 |     inherits "2"
210 |     minimatch "^3.1.1"
211 |     once "^1.3.0"
212 |     path-is-absolute "^1.0.0"
213 | 
214 | har-schema@^2.0.0:
215 |   version "2.0.0"
216 |   resolved "https://registry.yarnpkg.com/har-schema/-/har-schema-2.0.0.tgz#a94c2224ebcac04782a0d9035521f24735b7ec92"
217 |   integrity sha1-qUwiJOvKwEeCoNkDVSHyRzW37JI=
218 | 
219 | har-validator@~5.1.3:
220 |   version "5.1.5"
221 |   resolved "https://registry.yarnpkg.com/har-validator/-/har-validator-5.1.5.tgz#1f0803b9f8cb20c0fa13822df1ecddb36bde1efd"
222 |   integrity sha512-nmT2T0lljbxdQZfspsno9hgrG3Uir6Ks5afism62poxqBM6sDnMEuPmzTq8XN0OEwqKLLdh1jQI3qyE66Nzb3w==
223 |   dependencies:
224 |     ajv "^6.12.3"
225 |     har-schema "^2.0.0"
226 | 
227 | http-signature@~1.2.0:
228 |   version "1.2.0"
229 |   resolved "https://registry.yarnpkg.com/http-signature/-/http-signature-1.2.0.tgz#9aecd925114772f3d95b65a60abb8f7c18fbace1"
230 |   integrity sha1-muzZJRFHcvPZW2WmCruPfBj7rOE=
231 |   dependencies:
232 |     assert-plus "^1.0.0"
233 |     jsprim "^1.2.2"
234 |     sshpk "^1.7.0"
235 | 
236 | inflight@^1.0.4:
237 |   version "1.0.6"
238 |   resolved "https://registry.yarnpkg.com/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9"
239 |   integrity sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==
240 |   dependencies:
241 |     once "^1.3.0"
242 |     wrappy "1"
243 | 
244 | inherits@2:
245 |   version "2.0.4"
246 |   resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c"
247 |   integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
248 | 
249 | is-typedarray@~1.0.0:
250 |   version "1.0.0"
251 |   resolved "https://registry.yarnpkg.com/is-typedarray/-/is-typedarray-1.0.0.tgz#e479c80858df0c1b11ddda6940f96011fcda4a9a"
252 |   integrity sha1-5HnICFjfDBsR3dppQPlgEfzaSpo=
253 | 
254 | isexe@^2.0.0:
255 |   version "2.0.0"
256 |   resolved "https://registry.yarnpkg.com/isexe/-/isexe-2.0.0.tgz#e8fbf374dc556ff8947a10dcb0572d633f2cfa10"
257 |   integrity sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==
258 | 
259 | isstream@~0.1.2:
260 |   version "0.1.2"
261 |   resolved "https://registry.yarnpkg.com/isstream/-/isstream-0.1.2.tgz#47e63f7af55afa6f92e1500e690eb8b8529c099a"
262 |   integrity sha1-R+Y/evVa+m+S4VAOaQ64uFKcCZo=
263 | 
264 | jsbn@~0.1.0:
265 |   version "0.1.1"
266 |   resolved "https://registry.yarnpkg.com/jsbn/-/jsbn-0.1.1.tgz#a5e654c2e5a2deb5f201d96cefbca80c0ef2f513"
267 |   integrity sha1-peZUwuWi3rXyAdls77yoDA7y9RM=
268 | 
269 | json-schema-traverse@^0.4.1:
270 |   version "0.4.1"
271 |   resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz#69f6a87d9513ab8bb8fe63bdb0979c448e684660"
272 |   integrity sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==
273 | 
274 | json-schema@0.2.3:
275 |   version "0.2.3"
276 |   resolved "https://registry.yarnpkg.com/json-schema/-/json-schema-0.2.3.tgz#b480c892e59a2f05954ce727bd3f2a4e882f9e13"
277 |   integrity sha1-tIDIkuWaLwWVTOcnvT8qTogvnhM=
278 | 
279 | json-stringify-safe@~5.0.1:
280 |   version "5.0.1"
281 |   resolved "https://registry.yarnpkg.com/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz#1296a2d58fd45f19a0f6ce01d65701e2c735b6eb"
282 |   integrity sha1-Epai1Y/UXxmg9s4B1lcB4sc1tus=
283 | 
284 | jsprim@^1.2.2:
285 |   version "1.4.1"
286 |   resolved "https://registry.yarnpkg.com/jsprim/-/jsprim-1.4.1.tgz#313e66bc1e5cc06e438bc1b7499c2e5c56acb6a2"
287 |   integrity sha1-MT5mvB5cwG5Di8G3SZwuXFastqI=
288 |   dependencies:
289 |     assert-plus "1.0.0"
290 |     extsprintf "1.3.0"
291 |     json-schema "0.2.3"
292 |     verror "1.10.0"
293 | 
294 | lodash@^4.17.19:
295 |   version "4.17.21"
296 |   resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c"
297 |   integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==
298 | 
299 | mime-db@1.46.0:
300 |   version "1.46.0"
301 |   resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.46.0.tgz#6267748a7f799594de3cbc8cde91def349661cee"
302 |   integrity sha512-svXaP8UQRZ5K7or+ZmfNhg2xX3yKDMUzqadsSqi4NCH/KomcH75MAMYAGVlvXn4+b/xOPhS3I2uHKRUzvjY7BQ==
303 | 
304 | mime-types@^2.1.12, mime-types@~2.1.19:
305 |   version "2.1.29"
306 |   resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.29.tgz#1d4ab77da64b91f5f72489df29236563754bb1b2"
307 |   integrity sha512-Y/jMt/S5sR9OaqteJtslsFZKWOIIqMACsJSiHghlCAyhf7jfVYjKBmLiX8OgpWeW+fjJ2b+Az69aPFPkUOY6xQ==
308 |   dependencies:
309 |     mime-db "1.46.0"
310 | 
311 | minimatch@^3.1.1:
312 |   version "3.1.2"
313 |   resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.1.2.tgz#19cd194bfd3e428f049a70817c038d89ab4be35b"
314 |   integrity sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==
315 |   dependencies:
316 |     brace-expansion "^1.1.7"
317 | 
318 | minimist@^1.2.6:
319 |   version "1.2.8"
320 |   resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.8.tgz#c1a464e7693302e082a075cee0c057741ac4772c"
321 |   integrity sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==
322 | 
323 | mkdirp@^0.5.1:
324 |   version "0.5.6"
325 |   resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.6.tgz#7def03d2432dcae4ba1d611445c48396062255f6"
326 |   integrity sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==
327 |   dependencies:
328 |     minimist "^1.2.6"
329 | 
330 | nice-try@^1.0.4:
331 |   version "1.0.5"
332 |   resolved "https://registry.yarnpkg.com/nice-try/-/nice-try-1.0.5.tgz#a3378a7696ce7d223e88fc9b764bd7ef1089e366"
333 |   integrity sha512-1nh45deeb5olNY7eX82BkPO7SSxR5SSYJiPTrTdFUVYwAl8CKMA5N9PjTYkHiRjisVcxcQ1HXdLhx2qxxJzLNQ==
334 | 
335 | node-elm-compiler@^5.0.6:
336 |   version "5.0.6"
337 |   resolved "https://registry.yarnpkg.com/node-elm-compiler/-/node-elm-compiler-5.0.6.tgz#d4a6e6c9d9a26dba4211ccd2aeae7d5e34057f0c"
338 |   integrity sha512-DWTRQR8b54rvschcZRREdsz7K84lnS8A6YJu8du3QLQ8f204SJbyTaA6NzYYbfUG97OTRKRv/0KZl82cTfpLhA==
339 |   dependencies:
340 |     cross-spawn "6.0.5"
341 |     find-elm-dependencies "^2.0.4"
342 |     lodash "^4.17.19"
343 |     temp "^0.9.0"
344 | 
345 | oauth-sign@~0.9.0:
346 |   version "0.9.0"
347 |   resolved "https://registry.yarnpkg.com/oauth-sign/-/oauth-sign-0.9.0.tgz#47a7b016baa68b5fa0ecf3dee08a85c679ac6455"
348 |   integrity sha512-fexhUFFPTGV8ybAtSIGbV6gOkSv8UtRbDBnAyLQw4QPKkgNlsH2ByPGtMUqdWkos6YCRmAqViwgZrJc/mRDzZQ==
349 | 
350 | once@^1.3.0:
351 |   version "1.4.0"
352 |   resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1"
353 |   integrity sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==
354 |   dependencies:
355 |     wrappy "1"
356 | 
357 | path-is-absolute@^1.0.0:
358 |   version "1.0.1"
359 |   resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f"
360 |   integrity sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==
361 | 
362 | path-key@^2.0.1:
363 |   version "2.0.1"
364 |   resolved "https://registry.yarnpkg.com/path-key/-/path-key-2.0.1.tgz#411cadb574c5a140d3a4b1910d40d80cc9f40b40"
365 |   integrity sha512-fEHGKCSmUSDPv4uoj8AlD+joPlq3peND+HRYyxFz4KPw4z926S/b8rIuFs2FYJg3BwsxJf6A9/3eIdLaYC+9Dw==
366 | 
367 | performance-now@^2.1.0:
368 |   version "2.1.0"
369 |   resolved "https://registry.yarnpkg.com/performance-now/-/performance-now-2.1.0.tgz#6309f4e0e5fa913ec1c69307ae364b4b377c9e7b"
370 |   integrity sha1-Ywn04OX6kT7BxpMHrjZLSzd8nns=
371 | 
372 | psl@^1.1.28:
373 |   version "1.8.0"
374 |   resolved "https://registry.yarnpkg.com/psl/-/psl-1.8.0.tgz#9326f8bcfb013adcc005fdff056acce020e51c24"
375 |   integrity sha512-RIdOzyoavK+hA18OGGWDqUTsCLhtA7IcZ/6NCs4fFJaHBDab+pDDmDIByWFRQJq2Cd7r1OoQxBGKOaztq+hjIQ==
376 | 
377 | punycode@^2.1.0, punycode@^2.1.1:
378 |   version "2.1.1"
379 |   resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.1.1.tgz#b58b010ac40c22c5657616c8d2c2c02c7bf479ec"
380 |   integrity sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==
381 | 
382 | qs@~6.5.2:
383 |   version "6.5.2"
384 |   resolved "https://registry.yarnpkg.com/qs/-/qs-6.5.2.tgz#cb3ae806e8740444584ef154ce8ee98d403f3e36"
385 |   integrity sha512-N5ZAX4/LxJmF+7wN74pUD6qAh9/wnvdQcjq9TZjevvXzSUo7bfmw91saqMjzGS2xq91/odN2dW/WOl7qQHNDGA==
386 | 
387 | request@^2.88.0:
388 |   version "2.88.2"
389 |   resolved "https://registry.yarnpkg.com/request/-/request-2.88.2.tgz#d73c918731cb5a87da047e207234146f664d12b3"
390 |   integrity sha512-MsvtOrfG9ZcrOwAW+Qi+F6HbD0CWXEh9ou77uOb7FM2WPhwT7smM833PzanhJLsgXjN89Ir6V2PczXNnMpwKhw==
391 |   dependencies:
392 |     aws-sign2 "~0.7.0"
393 |     aws4 "^1.8.0"
394 |     caseless "~0.12.0"
395 |     combined-stream "~1.0.6"
396 |     extend "~3.0.2"
397 |     forever-agent "~0.6.1"
398 |     form-data "~2.3.2"
399 |     har-validator "~5.1.3"
400 |     http-signature "~1.2.0"
401 |     is-typedarray "~1.0.0"
402 |     isstream "~0.1.2"
403 |     json-stringify-safe "~5.0.1"
404 |     mime-types "~2.1.19"
405 |     oauth-sign "~0.9.0"
406 |     performance-now "^2.1.0"
407 |     qs "~6.5.2"
408 |     safe-buffer "^5.1.2"
409 |     tough-cookie "~2.5.0"
410 |     tunnel-agent "^0.6.0"
411 |     uuid "^3.3.2"
412 | 
413 | rimraf@~2.6.2:
414 |   version "2.6.3"
415 |   resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-2.6.3.tgz#b2d104fe0d8fb27cf9e0a1cda8262dd3833c6cab"
416 |   integrity sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA==
417 |   dependencies:
418 |     glob "^7.1.3"
419 | 
420 | safe-buffer@^5.0.1, safe-buffer@^5.1.2:
421 |   version "5.2.1"
422 |   resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.2.1.tgz#1eaf9fa9bdb1fdd4ec75f58f9cdb4e6b7827eec6"
423 |   integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==
424 | 
425 | safer-buffer@^2.0.2, safer-buffer@^2.1.0, safer-buffer@~2.1.0:
426 |   version "2.1.2"
427 |   resolved "https://registry.yarnpkg.com/safer-buffer/-/safer-buffer-2.1.2.tgz#44fa161b0187b9549dd84bb91802f9bd8385cd6a"
428 |   integrity sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==
429 | 
430 | semver@^5.5.0:
431 |   version "5.7.2"
432 |   resolved "https://registry.yarnpkg.com/semver/-/semver-5.7.2.tgz#48d55db737c3287cd4835e17fa13feace1c41ef8"
433 |   integrity sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==
434 | 
435 | shebang-command@^1.2.0:
436 |   version "1.2.0"
437 |   resolved "https://registry.yarnpkg.com/shebang-command/-/shebang-command-1.2.0.tgz#44aac65b695b03398968c39f363fee5deafdf1ea"
438 |   integrity sha512-EV3L1+UQWGor21OmnvojK36mhg+TyIKDh3iFBKBohr5xeXIhNBcx8oWdgkTEEQ+BEFFYdLRuqMfd5L84N1V5Vg==
439 |   dependencies:
440 |     shebang-regex "^1.0.0"
441 | 
442 | shebang-regex@^1.0.0:
443 |   version "1.0.0"
444 |   resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-1.0.0.tgz#da42f49740c0b42db2ca9728571cb190c98efea3"
445 |   integrity sha512-wpoSFAxys6b2a2wHZ1XpDSgD7N9iVjg29Ph9uV/uaP9Ex/KXlkTZTeddxDPSYQpgvzKLGJke2UU0AzoGCjNIvQ==
446 | 
447 | sshpk@^1.7.0:
448 |   version "1.16.1"
449 |   resolved "https://registry.yarnpkg.com/sshpk/-/sshpk-1.16.1.tgz#fb661c0bef29b39db40769ee39fa70093d6f6877"
450 |   integrity sha512-HXXqVUq7+pcKeLqqZj6mHFUMvXtOJt1uoUx09pFW6011inTMxqI8BA8PM95myrIyyKwdnzjdFjLiE6KBPVtJIg==
451 |   dependencies:
452 |     asn1 "~0.2.3"
453 |     assert-plus "^1.0.0"
454 |     bcrypt-pbkdf "^1.0.0"
455 |     dashdash "^1.12.0"
456 |     ecc-jsbn "~0.1.1"
457 |     getpass "^0.1.1"
458 |     jsbn "~0.1.0"
459 |     safer-buffer "^2.0.2"
460 |     tweetnacl "~0.14.0"
461 | 
462 | temp@^0.9.0:
463 |   version "0.9.4"
464 |   resolved "https://registry.yarnpkg.com/temp/-/temp-0.9.4.tgz#cd20a8580cb63635d0e4e9d4bd989d44286e7620"
465 |   integrity sha512-yYrrsWnrXMcdsnu/7YMYAofM1ktpL5By7vZhf15CrXijWWrEYZks5AXBudalfSWJLlnen/QUJUB5aoB0kqZUGA==
466 |   dependencies:
467 |     mkdirp "^0.5.1"
468 |     rimraf "~2.6.2"
469 | 
470 | tough-cookie@~2.5.0:
471 |   version "2.5.0"
472 |   resolved "https://registry.yarnpkg.com/tough-cookie/-/tough-cookie-2.5.0.tgz#cd9fb2a0aa1d5a12b473bd9fb96fa3dcff65ade2"
473 |   integrity sha512-nlLsUzgm1kfLXSXfRZMc1KLAugd4hqJHDTvc2hDIwS3mZAfMEuMbc03SujMF+GEcpaX/qboeycw6iO8JwVv2+g==
474 |   dependencies:
475 |     psl "^1.1.28"
476 |     punycode "^2.1.1"
477 | 
478 | tunnel-agent@^0.6.0:
479 |   version "0.6.0"
480 |   resolved "https://registry.yarnpkg.com/tunnel-agent/-/tunnel-agent-0.6.0.tgz#27a5dea06b36b04a0a9966774b290868f0fc40fd"
481 |   integrity sha1-J6XeoGs2sEoKmWZ3SykIaPD8QP0=
482 |   dependencies:
483 |     safe-buffer "^5.0.1"
484 | 
485 | tweetnacl@^0.14.3, tweetnacl@~0.14.0:
486 |   version "0.14.5"
487 |   resolved "https://registry.yarnpkg.com/tweetnacl/-/tweetnacl-0.14.5.tgz#5ae68177f192d4456269d108afa93ff8743f4f64"
488 |   integrity sha1-WuaBd/GS1EViadEIr6k/+HQ/T2Q=
489 | 
490 | uri-js@^4.2.2:
491 |   version "4.4.1"
492 |   resolved "https://registry.yarnpkg.com/uri-js/-/uri-js-4.4.1.tgz#9b1a52595225859e55f669d928f88c6c57f2a77e"
493 |   integrity sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==
494 |   dependencies:
495 |     punycode "^2.1.0"
496 | 
497 | uuid@^3.3.2:
498 |   version "3.4.0"
499 |   resolved "https://registry.yarnpkg.com/uuid/-/uuid-3.4.0.tgz#b23e4358afa8a202fe7a100af1f5f883f02007ee"
500 |   integrity sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A==
501 | 
502 | verror@1.10.0:
503 |   version "1.10.0"
504 |   resolved "https://registry.yarnpkg.com/verror/-/verror-1.10.0.tgz#3a105ca17053af55d6e270c1f8288682e18da400"
505 |   integrity sha1-OhBcoXBTr1XW4nDB+CiGguGNpAA=
506 |   dependencies:
507 |     assert-plus "^1.0.0"
508 |     core-util-is "1.0.2"
509 |     extsprintf "^1.2.0"
510 | 
511 | which@^1.2.9:
512 |   version "1.3.1"
513 |   resolved "https://registry.yarnpkg.com/which/-/which-1.3.1.tgz#a45043d54f5805316da8d62f9f50918d3da70b0a"
514 |   integrity sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==
515 |   dependencies:
516 |     isexe "^2.0.0"
517 | 
518 | wrappy@1:
519 |   version "1.0.2"
520 |   resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f"
521 |   integrity sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==
522 | 


--------------------------------------------------------------------------------
/examples/with-cwd/.gitignore:
--------------------------------------------------------------------------------
1 | dist/
2 | 


--------------------------------------------------------------------------------
/examples/with-cwd/build.js:
--------------------------------------------------------------------------------
 1 | const esbuild = require('esbuild');
 2 | const ElmPlugin = require('esbuild-plugin-elm');
 3 | 
 4 | const watch = process.argv.includes('--watch')
 5 | const isProd = process.env.NODE_ENV === 'production'
 6 | 
 7 | esbuild.build({
 8 |   entryPoints: ['index.js'],
 9 |   bundle: true,
10 |   outdir: 'dist',
11 |   minify: isProd,
12 |   watch,
13 |   plugins: [
14 |     ElmPlugin({
15 |       optimize: isProd,
16 |       cwd: 'elm',
17 |       clearOnWatch: watch,
18 |       verbose: true,
19 |     }),
20 |   ],
21 | }).catch(_e => process.exit(1))
22 | 


--------------------------------------------------------------------------------
/examples/with-cwd/elm/elm.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "type": "application",
 3 |     "source-directories": [
 4 |         "src"
 5 |     ],
 6 |     "elm-version": "0.19.1",
 7 |     "dependencies": {
 8 |         "direct": {
 9 |             "elm/browser": "1.0.2",
10 |             "elm/core": "1.0.5",
11 |             "elm/html": "1.0.0"
12 |         },
13 |         "indirect": {
14 |             "elm/json": "1.1.3",
15 |             "elm/time": "1.0.0",
16 |             "elm/url": "1.0.0",
17 |             "elm/virtual-dom": "1.0.2"
18 |         }
19 |     },
20 |     "test-dependencies": {
21 |         "direct": {},
22 |         "indirect": {}
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/examples/with-cwd/elm/src/Main.elm:
--------------------------------------------------------------------------------
 1 | module Main exposing (..)
 2 | 
 3 | import Browser
 4 | import Html exposing (Html, button, div, text)
 5 | import Html.Events exposing (onClick)
 6 | import SomeModule exposing (increment, decrement)
 7 | 
 8 | 
 9 | main : Program () Model Msg
10 | main =
11 |     Browser.sandbox { init = init, update = update, view = view }
12 | 
13 | 
14 | type alias Model =
15 |     Int
16 | 
17 | 
18 | init : Model
19 | init =
20 |     0
21 | 
22 | 
23 | type Msg
24 |     = Increment
25 |     | Decrement
26 | 
27 | 
28 | update : Msg -> Model -> Model
29 | update msg model =
30 |     case msg of
31 |         Increment -> increment model
32 |         Decrement -> decrement model
33 | 
34 | 
35 | view : Model -> Html Msg
36 | view model =
37 |     div []
38 |         [ button [ onClick Decrement ] [ text "-" ]
39 |         , div [] [ text (String.fromInt model) ]
40 |         , button [ onClick Increment ] [ text "+" ]
41 |         ]
42 | 


--------------------------------------------------------------------------------
/examples/with-cwd/elm/src/SomeModule.elm:
--------------------------------------------------------------------------------
1 | module SomeModule exposing (..)
2 | 
3 | increment : Int -> Int
4 | increment n = n + 1
5 | 
6 | decrement : Int -> Int
7 | decrement n = n - 1
8 | 


--------------------------------------------------------------------------------
/examples/with-cwd/index.js:
--------------------------------------------------------------------------------
 1 | import { Elm } from './elm/src/Main.elm';
 2 | 
 3 | const $root = document.createElement('div');
 4 | document.body.appendChild($root);
 5 | 
 6 | Elm.Main.init({
 7 |   node: $root
 8 | });
 9 | 
10 | 


--------------------------------------------------------------------------------
/examples/with-cwd/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "elm-esbuild-example-with-cwd",
 3 |   "version": "1.0.0",
 4 |   "main": "index.js",
 5 |   "license": "MIT",
 6 |   "scripts": {
 7 |     "build": "node ./build.js",
 8 |     "watch": "node ./build.js --watch"
 9 |   },
10 |   "dependencies": {
11 |     "elm": "^0.19.1-5",
12 |     "esbuild": "0.12.24",
13 |     "esbuild-plugin-elm": "file:../../"
14 |   }
15 | }
16 | 


--------------------------------------------------------------------------------
/examples/with-cwd/yarn.lock:
--------------------------------------------------------------------------------
  1 | # THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
  2 | # yarn lockfile v1
  3 | 
  4 | 
  5 | ajv@^6.12.3:
  6 |   version "6.12.6"
  7 |   resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.12.6.tgz#baf5a62e802b07d977034586f8c3baf5adf26df4"
  8 |   integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==
  9 |   dependencies:
 10 |     fast-deep-equal "^3.1.1"
 11 |     fast-json-stable-stringify "^2.0.0"
 12 |     json-schema-traverse "^0.4.1"
 13 |     uri-js "^4.2.2"
 14 | 
 15 | asn1@~0.2.3:
 16 |   version "0.2.4"
 17 |   resolved "https://registry.yarnpkg.com/asn1/-/asn1-0.2.4.tgz#8d2475dfab553bb33e77b54e59e880bb8ce23136"
 18 |   integrity sha512-jxwzQpLQjSmWXgwaCZE9Nz+glAG01yF1QnWgbhGwHI5A6FRIEY6IVqtHhIepHqI7/kyEyQEagBC5mBEFlIYvdg==
 19 |   dependencies:
 20 |     safer-buffer "~2.1.0"
 21 | 
 22 | assert-plus@1.0.0, assert-plus@^1.0.0:
 23 |   version "1.0.0"
 24 |   resolved "https://registry.yarnpkg.com/assert-plus/-/assert-plus-1.0.0.tgz#f12e0f3c5d77b0b1cdd9146942e4e96c1e4dd525"
 25 |   integrity sha1-8S4PPF13sLHN2RRpQuTpbB5N1SU=
 26 | 
 27 | asynckit@^0.4.0:
 28 |   version "0.4.0"
 29 |   resolved "https://registry.yarnpkg.com/asynckit/-/asynckit-0.4.0.tgz#c79ed97f7f34cb8f2ba1bc9790bcc366474b4b79"
 30 |   integrity sha1-x57Zf380y48robyXkLzDZkdLS3k=
 31 | 
 32 | aws-sign2@~0.7.0:
 33 |   version "0.7.0"
 34 |   resolved "https://registry.yarnpkg.com/aws-sign2/-/aws-sign2-0.7.0.tgz#b46e890934a9591f2d2f6f86d7e6a9f1b3fe76a8"
 35 |   integrity sha1-tG6JCTSpWR8tL2+G1+ap8bP+dqg=
 36 | 
 37 | aws4@^1.8.0:
 38 |   version "1.11.0"
 39 |   resolved "https://registry.yarnpkg.com/aws4/-/aws4-1.11.0.tgz#d61f46d83b2519250e2784daf5b09479a8b41c59"
 40 |   integrity sha512-xh1Rl34h6Fi1DC2WWKfxUTVqRsNnr6LsKz2+hfwDxQJWmrx8+c7ylaqBMcHfl1U1r2dsifOvKX3LQuLNZ+XSvA==
 41 | 
 42 | balanced-match@^1.0.0:
 43 |   version "1.0.2"
 44 |   resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.2.tgz#e83e3a7e3f300b34cb9d87f615fa0cbf357690ee"
 45 |   integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==
 46 | 
 47 | bcrypt-pbkdf@^1.0.0:
 48 |   version "1.0.2"
 49 |   resolved "https://registry.yarnpkg.com/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.2.tgz#a4301d389b6a43f9b67ff3ca11a3f6637e360e9e"
 50 |   integrity sha1-pDAdOJtqQ/m2f/PKEaP2Y342Dp4=
 51 |   dependencies:
 52 |     tweetnacl "^0.14.3"
 53 | 
 54 | brace-expansion@^1.1.7:
 55 |   version "1.1.11"
 56 |   resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.11.tgz#3c7fcbf529d87226f3d2f52b966ff5271eb441dd"
 57 |   integrity sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==
 58 |   dependencies:
 59 |     balanced-match "^1.0.0"
 60 |     concat-map "0.0.1"
 61 | 
 62 | caseless@~0.12.0:
 63 |   version "0.12.0"
 64 |   resolved "https://registry.yarnpkg.com/caseless/-/caseless-0.12.0.tgz#1b681c21ff84033c826543090689420d187151dc"
 65 |   integrity sha1-G2gcIf+EAzyCZUMJBolCDRhxUdw=
 66 | 
 67 | combined-stream@^1.0.6, combined-stream@~1.0.6:
 68 |   version "1.0.8"
 69 |   resolved "https://registry.yarnpkg.com/combined-stream/-/combined-stream-1.0.8.tgz#c3d45a8b34fd730631a110a8a2520682b31d5a7f"
 70 |   integrity sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==
 71 |   dependencies:
 72 |     delayed-stream "~1.0.0"
 73 | 
 74 | command-exists@^1.2.9:
 75 |   version "1.2.9"
 76 |   resolved "https://registry.yarnpkg.com/command-exists/-/command-exists-1.2.9.tgz#c50725af3808c8ab0260fd60b01fbfa25b954f69"
 77 |   integrity sha512-LTQ/SGc+s0Xc0Fu5WaKnR0YiygZkm9eKFvyS+fRsU7/ZWFF8ykFM6Pc9aCVf1+xasOOZpO3BAVgVrKvsqKHV7w==
 78 | 
 79 | concat-map@0.0.1:
 80 |   version "0.0.1"
 81 |   resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b"
 82 |   integrity sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==
 83 | 
 84 | core-util-is@1.0.2:
 85 |   version "1.0.2"
 86 |   resolved "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.2.tgz#b5fd54220aa2bc5ab57aab7140c940754503c1a7"
 87 |   integrity sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=
 88 | 
 89 | cross-spawn@6.0.5:
 90 |   version "6.0.5"
 91 |   resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-6.0.5.tgz#4a5ec7c64dfae22c3a14124dbacdee846d80cbc4"
 92 |   integrity sha512-eTVLrBSt7fjbDygz805pMnstIs2VTBNkRm0qxZd+M7A5XDdxVRWO5MxGBXZhjY4cqLYLdtrGqRf8mBPmzwSpWQ==
 93 |   dependencies:
 94 |     nice-try "^1.0.4"
 95 |     path-key "^2.0.1"
 96 |     semver "^5.5.0"
 97 |     shebang-command "^1.2.0"
 98 |     which "^1.2.9"
 99 | 
100 | dashdash@^1.12.0:
101 |   version "1.14.1"
102 |   resolved "https://registry.yarnpkg.com/dashdash/-/dashdash-1.14.1.tgz#853cfa0f7cbe2fed5de20326b8dd581035f6e2f0"
103 |   integrity sha1-hTz6D3y+L+1d4gMmuN1YEDX24vA=
104 |   dependencies:
105 |     assert-plus "^1.0.0"
106 | 
107 | delayed-stream@~1.0.0:
108 |   version "1.0.0"
109 |   resolved "https://registry.yarnpkg.com/delayed-stream/-/delayed-stream-1.0.0.tgz#df3ae199acadfb7d440aaae0b29e2272b24ec619"
110 |   integrity sha1-3zrhmayt+31ECqrgsp4icrJOxhk=
111 | 
112 | ecc-jsbn@~0.1.1:
113 |   version "0.1.2"
114 |   resolved "https://registry.yarnpkg.com/ecc-jsbn/-/ecc-jsbn-0.1.2.tgz#3a83a904e54353287874c564b7549386849a98c9"
115 |   integrity sha1-OoOpBOVDUyh4dMVkt1SThoSamMk=
116 |   dependencies:
117 |     jsbn "~0.1.0"
118 |     safer-buffer "^2.1.0"
119 | 
120 | elm@^0.19.1-5:
121 |   version "0.19.1-5"
122 |   resolved "https://registry.yarnpkg.com/elm/-/elm-0.19.1-5.tgz#61f18437222972e20f316f9b2d2c76a781a9991b"
123 |   integrity sha512-dyBoPvFiNLvxOStQJdyq28gZEjS/enZXdZ5yyCtNtDEMbFJJVQq4pYNRKvhrKKdlxNot6d96iQe1uczoqO5yvA==
124 |   dependencies:
125 |     request "^2.88.0"
126 | 
127 | "esbuild-plugin-elm@file:../..":
128 |   version "0.0.12"
129 |   dependencies:
130 |     command-exists "^1.2.9"
131 |     node-elm-compiler "^5.0.6"
132 | 
133 | esbuild@0.12.24:
134 |   version "0.12.24"
135 |   resolved "https://registry.yarnpkg.com/esbuild/-/esbuild-0.12.24.tgz#21966fad25a80f368ed308101e88102bce0dc68f"
136 |   integrity sha512-C0ibY+HsXzYB6L/pLWEiWjMpghKsIc58Q5yumARwBQsHl9DXPakW+5NI/Y9w4YXiz0PEP6XTGTT/OV4Nnsmb4A==
137 | 
138 | extend@~3.0.2:
139 |   version "3.0.2"
140 |   resolved "https://registry.yarnpkg.com/extend/-/extend-3.0.2.tgz#f8b1136b4071fbd8eb140aff858b1019ec2915fa"
141 |   integrity sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==
142 | 
143 | extsprintf@1.3.0:
144 |   version "1.3.0"
145 |   resolved "https://registry.yarnpkg.com/extsprintf/-/extsprintf-1.3.0.tgz#96918440e3041a7a414f8c52e3c574eb3c3e1e05"
146 |   integrity sha1-lpGEQOMEGnpBT4xS48V06zw+HgU=
147 | 
148 | extsprintf@^1.2.0:
149 |   version "1.4.0"
150 |   resolved "https://registry.yarnpkg.com/extsprintf/-/extsprintf-1.4.0.tgz#e2689f8f356fad62cca65a3a91c5df5f9551692f"
151 |   integrity sha1-4mifjzVvrWLMplo6kcXfX5VRaS8=
152 | 
153 | fast-deep-equal@^3.1.1:
154 |   version "3.1.3"
155 |   resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz#3a7d56b559d6cbc3eb512325244e619a65c6c525"
156 |   integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==
157 | 
158 | fast-json-stable-stringify@^2.0.0:
159 |   version "2.1.0"
160 |   resolved "https://registry.yarnpkg.com/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz#874bf69c6f404c2b5d99c481341399fd55892633"
161 |   integrity sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==
162 | 
163 | find-elm-dependencies@^2.0.4:
164 |   version "2.0.4"
165 |   resolved "https://registry.yarnpkg.com/find-elm-dependencies/-/find-elm-dependencies-2.0.4.tgz#0a327fc8c0c0297b54115efbf0a9d6de474cfc89"
166 |   integrity sha512-x/4w4fVmlD2X4PD9oQ+yh9EyaQef6OtEULdMGBTuWx0Nkppvo2Z/bAiQioW2n+GdRYKypME2b9OmYTw5tw5qDg==
167 |   dependencies:
168 |     firstline "^1.2.0"
169 |     lodash "^4.17.19"
170 | 
171 | firstline@^1.2.0:
172 |   version "1.3.1"
173 |   resolved "https://registry.yarnpkg.com/firstline/-/firstline-1.3.1.tgz#59e84af0fd858fbc6dac0a0ff97fd22a47e58084"
174 |   integrity sha512-ycwgqtoxujz1dm0kjkBFOPQMESxB9uKc/PlD951dQDIG+tBXRpYZC2UmJb0gDxopQ1ZX6oyRQN3goRczYu7Deg==
175 | 
176 | forever-agent@~0.6.1:
177 |   version "0.6.1"
178 |   resolved "https://registry.yarnpkg.com/forever-agent/-/forever-agent-0.6.1.tgz#fbc71f0c41adeb37f96c577ad1ed42d8fdacca91"
179 |   integrity sha1-+8cfDEGt6zf5bFd60e1C2P2sypE=
180 | 
181 | form-data@~2.3.2:
182 |   version "2.3.3"
183 |   resolved "https://registry.yarnpkg.com/form-data/-/form-data-2.3.3.tgz#dcce52c05f644f298c6a7ab936bd724ceffbf3a6"
184 |   integrity sha512-1lLKB2Mu3aGP1Q/2eCOx0fNbRMe7XdwktwOruhfqqd0rIJWwN4Dh+E3hrPSlDCXnSR7UtZ1N38rVXm+6+MEhJQ==
185 |   dependencies:
186 |     asynckit "^0.4.0"
187 |     combined-stream "^1.0.6"
188 |     mime-types "^2.1.12"
189 | 
190 | fs.realpath@^1.0.0:
191 |   version "1.0.0"
192 |   resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f"
193 |   integrity sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==
194 | 
195 | getpass@^0.1.1:
196 |   version "0.1.7"
197 |   resolved "https://registry.yarnpkg.com/getpass/-/getpass-0.1.7.tgz#5eff8e3e684d569ae4cb2b1282604e8ba62149fa"
198 |   integrity sha1-Xv+OPmhNVprkyysSgmBOi6YhSfo=
199 |   dependencies:
200 |     assert-plus "^1.0.0"
201 | 
202 | glob@^7.1.3:
203 |   version "7.2.3"
204 |   resolved "https://registry.yarnpkg.com/glob/-/glob-7.2.3.tgz#b8df0fb802bbfa8e89bd1d938b4e16578ed44f2b"
205 |   integrity sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==
206 |   dependencies:
207 |     fs.realpath "^1.0.0"
208 |     inflight "^1.0.4"
209 |     inherits "2"
210 |     minimatch "^3.1.1"
211 |     once "^1.3.0"
212 |     path-is-absolute "^1.0.0"
213 | 
214 | har-schema@^2.0.0:
215 |   version "2.0.0"
216 |   resolved "https://registry.yarnpkg.com/har-schema/-/har-schema-2.0.0.tgz#a94c2224ebcac04782a0d9035521f24735b7ec92"
217 |   integrity sha1-qUwiJOvKwEeCoNkDVSHyRzW37JI=
218 | 
219 | har-validator@~5.1.3:
220 |   version "5.1.5"
221 |   resolved "https://registry.yarnpkg.com/har-validator/-/har-validator-5.1.5.tgz#1f0803b9f8cb20c0fa13822df1ecddb36bde1efd"
222 |   integrity sha512-nmT2T0lljbxdQZfspsno9hgrG3Uir6Ks5afism62poxqBM6sDnMEuPmzTq8XN0OEwqKLLdh1jQI3qyE66Nzb3w==
223 |   dependencies:
224 |     ajv "^6.12.3"
225 |     har-schema "^2.0.0"
226 | 
227 | http-signature@~1.2.0:
228 |   version "1.2.0"
229 |   resolved "https://registry.yarnpkg.com/http-signature/-/http-signature-1.2.0.tgz#9aecd925114772f3d95b65a60abb8f7c18fbace1"
230 |   integrity sha1-muzZJRFHcvPZW2WmCruPfBj7rOE=
231 |   dependencies:
232 |     assert-plus "^1.0.0"
233 |     jsprim "^1.2.2"
234 |     sshpk "^1.7.0"
235 | 
236 | inflight@^1.0.4:
237 |   version "1.0.6"
238 |   resolved "https://registry.yarnpkg.com/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9"
239 |   integrity sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==
240 |   dependencies:
241 |     once "^1.3.0"
242 |     wrappy "1"
243 | 
244 | inherits@2:
245 |   version "2.0.4"
246 |   resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c"
247 |   integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
248 | 
249 | is-typedarray@~1.0.0:
250 |   version "1.0.0"
251 |   resolved "https://registry.yarnpkg.com/is-typedarray/-/is-typedarray-1.0.0.tgz#e479c80858df0c1b11ddda6940f96011fcda4a9a"
252 |   integrity sha1-5HnICFjfDBsR3dppQPlgEfzaSpo=
253 | 
254 | isexe@^2.0.0:
255 |   version "2.0.0"
256 |   resolved "https://registry.yarnpkg.com/isexe/-/isexe-2.0.0.tgz#e8fbf374dc556ff8947a10dcb0572d633f2cfa10"
257 |   integrity sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==
258 | 
259 | isstream@~0.1.2:
260 |   version "0.1.2"
261 |   resolved "https://registry.yarnpkg.com/isstream/-/isstream-0.1.2.tgz#47e63f7af55afa6f92e1500e690eb8b8529c099a"
262 |   integrity sha1-R+Y/evVa+m+S4VAOaQ64uFKcCZo=
263 | 
264 | jsbn@~0.1.0:
265 |   version "0.1.1"
266 |   resolved "https://registry.yarnpkg.com/jsbn/-/jsbn-0.1.1.tgz#a5e654c2e5a2deb5f201d96cefbca80c0ef2f513"
267 |   integrity sha1-peZUwuWi3rXyAdls77yoDA7y9RM=
268 | 
269 | json-schema-traverse@^0.4.1:
270 |   version "0.4.1"
271 |   resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz#69f6a87d9513ab8bb8fe63bdb0979c448e684660"
272 |   integrity sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==
273 | 
274 | json-schema@0.2.3:
275 |   version "0.2.3"
276 |   resolved "https://registry.yarnpkg.com/json-schema/-/json-schema-0.2.3.tgz#b480c892e59a2f05954ce727bd3f2a4e882f9e13"
277 |   integrity sha1-tIDIkuWaLwWVTOcnvT8qTogvnhM=
278 | 
279 | json-stringify-safe@~5.0.1:
280 |   version "5.0.1"
281 |   resolved "https://registry.yarnpkg.com/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz#1296a2d58fd45f19a0f6ce01d65701e2c735b6eb"
282 |   integrity sha1-Epai1Y/UXxmg9s4B1lcB4sc1tus=
283 | 
284 | jsprim@^1.2.2:
285 |   version "1.4.1"
286 |   resolved "https://registry.yarnpkg.com/jsprim/-/jsprim-1.4.1.tgz#313e66bc1e5cc06e438bc1b7499c2e5c56acb6a2"
287 |   integrity sha1-MT5mvB5cwG5Di8G3SZwuXFastqI=
288 |   dependencies:
289 |     assert-plus "1.0.0"
290 |     extsprintf "1.3.0"
291 |     json-schema "0.2.3"
292 |     verror "1.10.0"
293 | 
294 | lodash@^4.17.19:
295 |   version "4.17.21"
296 |   resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c"
297 |   integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==
298 | 
299 | mime-db@1.46.0:
300 |   version "1.46.0"
301 |   resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.46.0.tgz#6267748a7f799594de3cbc8cde91def349661cee"
302 |   integrity sha512-svXaP8UQRZ5K7or+ZmfNhg2xX3yKDMUzqadsSqi4NCH/KomcH75MAMYAGVlvXn4+b/xOPhS3I2uHKRUzvjY7BQ==
303 | 
304 | mime-types@^2.1.12, mime-types@~2.1.19:
305 |   version "2.1.29"
306 |   resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.29.tgz#1d4ab77da64b91f5f72489df29236563754bb1b2"
307 |   integrity sha512-Y/jMt/S5sR9OaqteJtslsFZKWOIIqMACsJSiHghlCAyhf7jfVYjKBmLiX8OgpWeW+fjJ2b+Az69aPFPkUOY6xQ==
308 |   dependencies:
309 |     mime-db "1.46.0"
310 | 
311 | minimatch@^3.1.1:
312 |   version "3.1.2"
313 |   resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.1.2.tgz#19cd194bfd3e428f049a70817c038d89ab4be35b"
314 |   integrity sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==
315 |   dependencies:
316 |     brace-expansion "^1.1.7"
317 | 
318 | minimist@^1.2.6:
319 |   version "1.2.8"
320 |   resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.8.tgz#c1a464e7693302e082a075cee0c057741ac4772c"
321 |   integrity sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==
322 | 
323 | mkdirp@^0.5.1:
324 |   version "0.5.6"
325 |   resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.6.tgz#7def03d2432dcae4ba1d611445c48396062255f6"
326 |   integrity sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==
327 |   dependencies:
328 |     minimist "^1.2.6"
329 | 
330 | nice-try@^1.0.4:
331 |   version "1.0.5"
332 |   resolved "https://registry.yarnpkg.com/nice-try/-/nice-try-1.0.5.tgz#a3378a7696ce7d223e88fc9b764bd7ef1089e366"
333 |   integrity sha512-1nh45deeb5olNY7eX82BkPO7SSxR5SSYJiPTrTdFUVYwAl8CKMA5N9PjTYkHiRjisVcxcQ1HXdLhx2qxxJzLNQ==
334 | 
335 | node-elm-compiler@^5.0.6:
336 |   version "5.0.6"
337 |   resolved "https://registry.yarnpkg.com/node-elm-compiler/-/node-elm-compiler-5.0.6.tgz#d4a6e6c9d9a26dba4211ccd2aeae7d5e34057f0c"
338 |   integrity sha512-DWTRQR8b54rvschcZRREdsz7K84lnS8A6YJu8du3QLQ8f204SJbyTaA6NzYYbfUG97OTRKRv/0KZl82cTfpLhA==
339 |   dependencies:
340 |     cross-spawn "6.0.5"
341 |     find-elm-dependencies "^2.0.4"
342 |     lodash "^4.17.19"
343 |     temp "^0.9.0"
344 | 
345 | oauth-sign@~0.9.0:
346 |   version "0.9.0"
347 |   resolved "https://registry.yarnpkg.com/oauth-sign/-/oauth-sign-0.9.0.tgz#47a7b016baa68b5fa0ecf3dee08a85c679ac6455"
348 |   integrity sha512-fexhUFFPTGV8ybAtSIGbV6gOkSv8UtRbDBnAyLQw4QPKkgNlsH2ByPGtMUqdWkos6YCRmAqViwgZrJc/mRDzZQ==
349 | 
350 | once@^1.3.0:
351 |   version "1.4.0"
352 |   resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1"
353 |   integrity sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==
354 |   dependencies:
355 |     wrappy "1"
356 | 
357 | path-is-absolute@^1.0.0:
358 |   version "1.0.1"
359 |   resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f"
360 |   integrity sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==
361 | 
362 | path-key@^2.0.1:
363 |   version "2.0.1"
364 |   resolved "https://registry.yarnpkg.com/path-key/-/path-key-2.0.1.tgz#411cadb574c5a140d3a4b1910d40d80cc9f40b40"
365 |   integrity sha512-fEHGKCSmUSDPv4uoj8AlD+joPlq3peND+HRYyxFz4KPw4z926S/b8rIuFs2FYJg3BwsxJf6A9/3eIdLaYC+9Dw==
366 | 
367 | performance-now@^2.1.0:
368 |   version "2.1.0"
369 |   resolved "https://registry.yarnpkg.com/performance-now/-/performance-now-2.1.0.tgz#6309f4e0e5fa913ec1c69307ae364b4b377c9e7b"
370 |   integrity sha1-Ywn04OX6kT7BxpMHrjZLSzd8nns=
371 | 
372 | psl@^1.1.28:
373 |   version "1.8.0"
374 |   resolved "https://registry.yarnpkg.com/psl/-/psl-1.8.0.tgz#9326f8bcfb013adcc005fdff056acce020e51c24"
375 |   integrity sha512-RIdOzyoavK+hA18OGGWDqUTsCLhtA7IcZ/6NCs4fFJaHBDab+pDDmDIByWFRQJq2Cd7r1OoQxBGKOaztq+hjIQ==
376 | 
377 | punycode@^2.1.0, punycode@^2.1.1:
378 |   version "2.1.1"
379 |   resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.1.1.tgz#b58b010ac40c22c5657616c8d2c2c02c7bf479ec"
380 |   integrity sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==
381 | 
382 | qs@~6.5.2:
383 |   version "6.5.2"
384 |   resolved "https://registry.yarnpkg.com/qs/-/qs-6.5.2.tgz#cb3ae806e8740444584ef154ce8ee98d403f3e36"
385 |   integrity sha512-N5ZAX4/LxJmF+7wN74pUD6qAh9/wnvdQcjq9TZjevvXzSUo7bfmw91saqMjzGS2xq91/odN2dW/WOl7qQHNDGA==
386 | 
387 | request@^2.88.0:
388 |   version "2.88.2"
389 |   resolved "https://registry.yarnpkg.com/request/-/request-2.88.2.tgz#d73c918731cb5a87da047e207234146f664d12b3"
390 |   integrity sha512-MsvtOrfG9ZcrOwAW+Qi+F6HbD0CWXEh9ou77uOb7FM2WPhwT7smM833PzanhJLsgXjN89Ir6V2PczXNnMpwKhw==
391 |   dependencies:
392 |     aws-sign2 "~0.7.0"
393 |     aws4 "^1.8.0"
394 |     caseless "~0.12.0"
395 |     combined-stream "~1.0.6"
396 |     extend "~3.0.2"
397 |     forever-agent "~0.6.1"
398 |     form-data "~2.3.2"
399 |     har-validator "~5.1.3"
400 |     http-signature "~1.2.0"
401 |     is-typedarray "~1.0.0"
402 |     isstream "~0.1.2"
403 |     json-stringify-safe "~5.0.1"
404 |     mime-types "~2.1.19"
405 |     oauth-sign "~0.9.0"
406 |     performance-now "^2.1.0"
407 |     qs "~6.5.2"
408 |     safe-buffer "^5.1.2"
409 |     tough-cookie "~2.5.0"
410 |     tunnel-agent "^0.6.0"
411 |     uuid "^3.3.2"
412 | 
413 | rimraf@~2.6.2:
414 |   version "2.6.3"
415 |   resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-2.6.3.tgz#b2d104fe0d8fb27cf9e0a1cda8262dd3833c6cab"
416 |   integrity sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA==
417 |   dependencies:
418 |     glob "^7.1.3"
419 | 
420 | safe-buffer@^5.0.1, safe-buffer@^5.1.2:
421 |   version "5.2.1"
422 |   resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.2.1.tgz#1eaf9fa9bdb1fdd4ec75f58f9cdb4e6b7827eec6"
423 |   integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==
424 | 
425 | safer-buffer@^2.0.2, safer-buffer@^2.1.0, safer-buffer@~2.1.0:
426 |   version "2.1.2"
427 |   resolved "https://registry.yarnpkg.com/safer-buffer/-/safer-buffer-2.1.2.tgz#44fa161b0187b9549dd84bb91802f9bd8385cd6a"
428 |   integrity sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==
429 | 
430 | semver@^5.5.0:
431 |   version "5.7.2"
432 |   resolved "https://registry.yarnpkg.com/semver/-/semver-5.7.2.tgz#48d55db737c3287cd4835e17fa13feace1c41ef8"
433 |   integrity sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==
434 | 
435 | shebang-command@^1.2.0:
436 |   version "1.2.0"
437 |   resolved "https://registry.yarnpkg.com/shebang-command/-/shebang-command-1.2.0.tgz#44aac65b695b03398968c39f363fee5deafdf1ea"
438 |   integrity sha512-EV3L1+UQWGor21OmnvojK36mhg+TyIKDh3iFBKBohr5xeXIhNBcx8oWdgkTEEQ+BEFFYdLRuqMfd5L84N1V5Vg==
439 |   dependencies:
440 |     shebang-regex "^1.0.0"
441 | 
442 | shebang-regex@^1.0.0:
443 |   version "1.0.0"
444 |   resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-1.0.0.tgz#da42f49740c0b42db2ca9728571cb190c98efea3"
445 |   integrity sha512-wpoSFAxys6b2a2wHZ1XpDSgD7N9iVjg29Ph9uV/uaP9Ex/KXlkTZTeddxDPSYQpgvzKLGJke2UU0AzoGCjNIvQ==
446 | 
447 | sshpk@^1.7.0:
448 |   version "1.16.1"
449 |   resolved "https://registry.yarnpkg.com/sshpk/-/sshpk-1.16.1.tgz#fb661c0bef29b39db40769ee39fa70093d6f6877"
450 |   integrity sha512-HXXqVUq7+pcKeLqqZj6mHFUMvXtOJt1uoUx09pFW6011inTMxqI8BA8PM95myrIyyKwdnzjdFjLiE6KBPVtJIg==
451 |   dependencies:
452 |     asn1 "~0.2.3"
453 |     assert-plus "^1.0.0"
454 |     bcrypt-pbkdf "^1.0.0"
455 |     dashdash "^1.12.0"
456 |     ecc-jsbn "~0.1.1"
457 |     getpass "^0.1.1"
458 |     jsbn "~0.1.0"
459 |     safer-buffer "^2.0.2"
460 |     tweetnacl "~0.14.0"
461 | 
462 | temp@^0.9.0:
463 |   version "0.9.4"
464 |   resolved "https://registry.yarnpkg.com/temp/-/temp-0.9.4.tgz#cd20a8580cb63635d0e4e9d4bd989d44286e7620"
465 |   integrity sha512-yYrrsWnrXMcdsnu/7YMYAofM1ktpL5By7vZhf15CrXijWWrEYZks5AXBudalfSWJLlnen/QUJUB5aoB0kqZUGA==
466 |   dependencies:
467 |     mkdirp "^0.5.1"
468 |     rimraf "~2.6.2"
469 | 
470 | tough-cookie@~2.5.0:
471 |   version "2.5.0"
472 |   resolved "https://registry.yarnpkg.com/tough-cookie/-/tough-cookie-2.5.0.tgz#cd9fb2a0aa1d5a12b473bd9fb96fa3dcff65ade2"
473 |   integrity sha512-nlLsUzgm1kfLXSXfRZMc1KLAugd4hqJHDTvc2hDIwS3mZAfMEuMbc03SujMF+GEcpaX/qboeycw6iO8JwVv2+g==
474 |   dependencies:
475 |     psl "^1.1.28"
476 |     punycode "^2.1.1"
477 | 
478 | tunnel-agent@^0.6.0:
479 |   version "0.6.0"
480 |   resolved "https://registry.yarnpkg.com/tunnel-agent/-/tunnel-agent-0.6.0.tgz#27a5dea06b36b04a0a9966774b290868f0fc40fd"
481 |   integrity sha1-J6XeoGs2sEoKmWZ3SykIaPD8QP0=
482 |   dependencies:
483 |     safe-buffer "^5.0.1"
484 | 
485 | tweetnacl@^0.14.3, tweetnacl@~0.14.0:
486 |   version "0.14.5"
487 |   resolved "https://registry.yarnpkg.com/tweetnacl/-/tweetnacl-0.14.5.tgz#5ae68177f192d4456269d108afa93ff8743f4f64"
488 |   integrity sha1-WuaBd/GS1EViadEIr6k/+HQ/T2Q=
489 | 
490 | uri-js@^4.2.2:
491 |   version "4.4.1"
492 |   resolved "https://registry.yarnpkg.com/uri-js/-/uri-js-4.4.1.tgz#9b1a52595225859e55f669d928f88c6c57f2a77e"
493 |   integrity sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==
494 |   dependencies:
495 |     punycode "^2.1.0"
496 | 
497 | uuid@^3.3.2:
498 |   version "3.4.0"
499 |   resolved "https://registry.yarnpkg.com/uuid/-/uuid-3.4.0.tgz#b23e4358afa8a202fe7a100af1f5f883f02007ee"
500 |   integrity sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A==
501 | 
502 | verror@1.10.0:
503 |   version "1.10.0"
504 |   resolved "https://registry.yarnpkg.com/verror/-/verror-1.10.0.tgz#3a105ca17053af55d6e270c1f8288682e18da400"
505 |   integrity sha1-OhBcoXBTr1XW4nDB+CiGguGNpAA=
506 |   dependencies:
507 |     assert-plus "^1.0.0"
508 |     core-util-is "1.0.2"
509 |     extsprintf "^1.2.0"
510 | 
511 | which@^1.2.9:
512 |   version "1.3.1"
513 |   resolved "https://registry.yarnpkg.com/which/-/which-1.3.1.tgz#a45043d54f5805316da8d62f9f50918d3da70b0a"
514 |   integrity sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==
515 |   dependencies:
516 |     isexe "^2.0.0"
517 | 
518 | wrappy@1:
519 |   version "1.0.2"
520 |   resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f"
521 |   integrity sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==
522 | 


--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
  1 | const path = require('path');
  2 | const fs = require('fs').promises;
  3 | const elmCompiler = require('node-elm-compiler');
  4 | const commandExists_ = require('command-exists');
  5 | 
  6 | const namespace = 'elm';
  7 | const fileFilter = /\.elm$/;
  8 | 
  9 | const PURE_FUNCS = [ 'F2', 'F3', 'F4', 'F5', 'F6', 'F7', 'F8', 'F9', 'A2', 'A3', 'A4', 'A5', 'A6', 'A7', 'A8', 'A9']
 10 | 
 11 | // Like command-exists' function but returns undefined when the command is missing,
 12 | // instead of throwing an error.
 13 | const commandExists = path =>
 14 |   commandExists_(path).catch(_ => undefined);
 15 | 
 16 | const getPathToElm = async () => {
 17 |   const commands = [path.resolve('./node_modules/.bin/elm'), 'elm'];
 18 |   const CMD_NOT_FOUND_ERR = 'Could not find `elm` executable. You can install it with `yarn add elm` or `npm install elm`';
 19 | 
 20 |   const foundCommands = await Promise.all(commands.map(commandExists));
 21 | 
 22 |   const elmCommand = foundCommands.find(cmd => cmd !== undefined);
 23 | 
 24 |   if (elmCommand) {
 25 |     return elmCommand;
 26 |   } else {
 27 |     throw new Error(CMD_NOT_FOUND_ERR);
 28 |   }
 29 | }
 30 | 
 31 | 
 32 | // Cached version of `fs.stat`.
 33 | // Cache is cleared on each build.
 34 | const readFileModificationTime = async (fileCache, filePath) => {
 35 |   const cached = fileCache.get(filePath);
 36 | 
 37 |   if (cached !== undefined) {
 38 |     return cached;
 39 |   }
 40 |   const stat = await fs.stat(filePath);
 41 |   const fileContents = stat.mtimeMs;
 42 | 
 43 |   fileCache.set(filePath, fileContents);
 44 | 
 45 |   return fileContents;
 46 | };
 47 | 
 48 | const toBuildError = error => ({ text: error.message });
 49 | 
 50 | // Checks whether all deps for a "main" elm file are unchanged.
 51 | // These only include source deps (might need to reset the dev server if you add an extra dep).
 52 | // If not, we need to recompile the file importing them.
 53 | const validateDependencies = async (fileCache, depsMap) => {
 54 |   const depStatus = await Promise.all([...depsMap].map(async ([depPath, cachedDep]) => {
 55 |     const newInput = await readFileModificationTime(fileCache, depPath);
 56 | 
 57 |     if (cachedDep.input === newInput) {
 58 |       return true;
 59 |     }
 60 |     cachedDep.input = newInput;
 61 |     return false;
 62 |   }));
 63 | 
 64 |   return depStatus.every(isReady => isReady);
 65 | };
 66 | 
 67 | // Cached version of `elmCompiler.compileToStringSync`
 68 | // Cache is persisted across builds
 69 | const checkCache = async (fileCache, cache, mainFilePath, compileOptions) => {
 70 |   const cached = cache.get(mainFilePath);
 71 |   const newInput = await readFileModificationTime(fileCache, mainFilePath);
 72 | 
 73 |   const depsUnchanged = await validateDependencies(fileCache, cached.dependencies);
 74 | 
 75 |   if (depsUnchanged && cached.input === newInput) {
 76 |     return cached.output;
 77 |   }
 78 |   // Can't use the async version:
 79 |   // https://github.com/phenax/esbuild-plugin-elm/issues/2
 80 |   const contents = elmCompiler.compileToStringSync([mainFilePath], compileOptions);
 81 |   const output = { contents };
 82 | 
 83 |   cache.set(mainFilePath, {
 84 |     input: newInput,
 85 |     output,
 86 |     dependencies: cached.dependencies,
 87 |   });
 88 | 
 89 |   return output;
 90 | };
 91 | 
 92 | // Recompute dependencies but keep cached artifacts if we had them
 93 | const updateDependencies = (cache, resolvedPath, dependencyPaths) => {
 94 |   let cached = cache.get(resolvedPath)
 95 |     || { input: undefined, output: undefined, dependencies: new Map() };
 96 | 
 97 |   const newValue = depPath => cached.dependencies.get(depPath) || { input: undefined };
 98 |   const dependencies = new Map(dependencyPaths.map(depPath => [depPath, newValue(depPath)]));
 99 | 
100 |   cache.set(resolvedPath, {
101 |     ...cached,
102 |     dependencies,
103 |   });
104 | };
105 | 
106 | const cachedElmCompiler = () => {
107 |   const cache = new Map();
108 | 
109 |   const compileToStringSync = async (fileCache, inputPath, compileOptions) => {
110 |     try {
111 |       const output = await checkCache(fileCache, cache, inputPath, compileOptions);
112 | 
113 |       return output;
114 |     } catch (e) {
115 |       return { errors: [toBuildError(e)] };
116 |     }
117 |   };
118 | 
119 |   return { cache, compileToStringSync };
120 | };
121 | 
122 | const fileExists = (file) => {
123 |   return fs.stat(file).then(stat => stat.isFile()).catch(_ => false);
124 | };
125 | 
126 | // Attempts to resolve a file path by joining to each load path, and returns the
127 | // resolved path if that file exists.
128 | // If no load paths are provided, or none resolve, the file path is assumed to
129 | // be relative to `resolveDir`.
130 | const resolvePath = async (resolveDir, filePath, loadPaths = []) => {
131 |   for (const loadPath of loadPaths) {
132 |     const joinedPath = path.join(loadPath, filePath);
133 | 
134 |     if (await fileExists(joinedPath)) {
135 |       return joinedPath;
136 |     }
137 |   }
138 | 
139 |   return path.join(resolveDir, filePath);
140 | };
141 | 
142 | const getLoadPaths = async (cwd = '.') => {
143 |   const readFile = await fs.readFile(path.join(cwd, 'elm.json'), 'utf8');
144 |   const elmPackage = JSON.parse(readFile);
145 | 
146 |   const paths = elmPackage['source-directories'].map((dir) => {
147 |       return path.join(cwd, dir);
148 |   });
149 | 
150 |   return paths;
151 | }
152 | 
153 | module.exports = (config = {}) => ({
154 |   name: 'elm',
155 |   async setup(build) {
156 |     const isProd = process.env.NODE_ENV === 'production';
157 | 
158 |     const { optimize = isProd, cwd, debug, verbose, clearOnWatch } = config
159 |     const pathToElm = config.pathToElm || await getPathToElm();
160 | 
161 |     const options = build.initialOptions
162 |     if (options.minify) {
163 |       Object.assign(options, {
164 |         pure: [ ...(options.pure || []), ...PURE_FUNCS ],
165 |       })
166 |     }
167 | 
168 |     const compileOptions = {
169 |       pathToElm,
170 |       optimize,
171 |       processOpts: { stdout: 'pipe' },
172 |       cwd,
173 |       debug,
174 |       verbose,
175 |     };
176 | 
177 |     const { cache, compileToStringSync } = cachedElmCompiler();
178 | 
179 |     const fileCache = new Map();
180 |     build.onStart(() => {
181 |       fileCache.clear();
182 |     });
183 | 
184 |     const loadPaths = await getLoadPaths(cwd);
185 | 
186 |     build.onResolve({ filter: fileFilter }, async (args) => {
187 |       const resolvedPath = await resolvePath(args.resolveDir, args.path, loadPaths);
188 |       const resolvedDependencies = await elmCompiler.findAllDependencies(resolvedPath);
189 | 
190 |       // I think we need to update deps on each resolve because you might
191 |       // change your imports on every build
192 |       updateDependencies(cache, resolvedPath, resolvedDependencies);
193 | 
194 |       return ({
195 |         path: resolvedPath,
196 |         namespace,
197 |         watchFiles: [resolvedPath, ...resolvedDependencies],
198 |       });
199 |     });
200 | 
201 |     build.onLoad({ filter: /.*/, namespace }, async (args) => {
202 |       if (clearOnWatch) {
203 |         // eslint-disable-next-line no-console
204 |         console.clear();
205 |       }
206 | 
207 |       return compileToStringSync(fileCache, args.path, compileOptions);
208 |     });
209 |   },
210 | });
211 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "esbuild-plugin-elm",
 3 |   "version": "0.0.12",
 4 |   "description": "Esbuild plugin for loading elm",
 5 |   "main": "index.js",
 6 |   "repository": "https://github.com/phenax/esbuild-plugin-elm",
 7 |   "homepage": "https://github.com/phenax/esbuild-plugin-elm",
 8 |   "author": "Akshay Nair <phenax5@gmail.com>",
 9 |   "license": "MIT",
10 |   "dependencies": {
11 |     "command-exists": "^1.2.9",
12 |     "node-elm-compiler": "^5.0.6"
13 |   },
14 |   "peerDependencies": {
15 |     "esbuild": ">=0.8.1"
16 |   },
17 |   "devDependencies": {
18 |     "esbuild": ">=0.8.1"
19 |   }
20 | }
21 | 


--------------------------------------------------------------------------------
/yarn.lock:
--------------------------------------------------------------------------------
  1 | # THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
  2 | # yarn lockfile v1
  3 | 
  4 | 
  5 | balanced-match@^1.0.0:
  6 |   version "1.0.0"
  7 |   resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.0.tgz#89b4d199ab2bee49de164ea02b89ce462d71b767"
  8 |   integrity sha1-ibTRmasr7kneFk6gK4nORi1xt2c=
  9 | 
 10 | brace-expansion@^1.1.7:
 11 |   version "1.1.11"
 12 |   resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.11.tgz#3c7fcbf529d87226f3d2f52b966ff5271eb441dd"
 13 |   integrity sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==
 14 |   dependencies:
 15 |     balanced-match "^1.0.0"
 16 |     concat-map "0.0.1"
 17 | 
 18 | command-exists@^1.2.9:
 19 |   version "1.2.9"
 20 |   resolved "https://registry.yarnpkg.com/command-exists/-/command-exists-1.2.9.tgz#c50725af3808c8ab0260fd60b01fbfa25b954f69"
 21 |   integrity sha512-LTQ/SGc+s0Xc0Fu5WaKnR0YiygZkm9eKFvyS+fRsU7/ZWFF8ykFM6Pc9aCVf1+xasOOZpO3BAVgVrKvsqKHV7w==
 22 | 
 23 | concat-map@0.0.1:
 24 |   version "0.0.1"
 25 |   resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b"
 26 |   integrity sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=
 27 | 
 28 | cross-spawn@6.0.5:
 29 |   version "6.0.5"
 30 |   resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-6.0.5.tgz#4a5ec7c64dfae22c3a14124dbacdee846d80cbc4"
 31 |   integrity sha512-eTVLrBSt7fjbDygz805pMnstIs2VTBNkRm0qxZd+M7A5XDdxVRWO5MxGBXZhjY4cqLYLdtrGqRf8mBPmzwSpWQ==
 32 |   dependencies:
 33 |     nice-try "^1.0.4"
 34 |     path-key "^2.0.1"
 35 |     semver "^5.5.0"
 36 |     shebang-command "^1.2.0"
 37 |     which "^1.2.9"
 38 | 
 39 | esbuild-android-arm64@0.13.14:
 40 |   version "0.13.14"
 41 |   resolved "https://registry.yarnpkg.com/esbuild-android-arm64/-/esbuild-android-arm64-0.13.14.tgz#c85083ece26be3d67e6c720e088968a98409e023"
 42 |   integrity sha512-Q+Xhfp827r+ma8/DJgpMRUbDZfefsk13oePFEXEIJ4gxFbNv5+vyiYXYuKm43/+++EJXpnaYmEnu4hAKbAWYbA==
 43 | 
 44 | esbuild-darwin-64@0.13.14:
 45 |   version "0.13.14"
 46 |   resolved "https://registry.yarnpkg.com/esbuild-darwin-64/-/esbuild-darwin-64-0.13.14.tgz#8e4e237ad847cc54a1d3a5caee26a746b9f0b81f"
 47 |   integrity sha512-YmOhRns6QBNSjpVdTahi/yZ8dscx9ai7a6OY6z5ACgOuQuaQ2Qk2qgJ0/siZ6LgD0gJFMV8UINFV5oky5TFNQQ==
 48 | 
 49 | esbuild-darwin-arm64@0.13.14:
 50 |   version "0.13.14"
 51 |   resolved "https://registry.yarnpkg.com/esbuild-darwin-arm64/-/esbuild-darwin-arm64-0.13.14.tgz#b3b5ebd40b2cb06ee0f6fb342dd4bdcca54ad273"
 52 |   integrity sha512-Lp00VTli2jqZghSa68fx3fEFCPsO1hK59RMo1PRap5RUjhf55OmaZTZYnCDI0FVlCtt+gBwX5qwFt4lc6tI1xg==
 53 | 
 54 | esbuild-freebsd-64@0.13.14:
 55 |   version "0.13.14"
 56 |   resolved "https://registry.yarnpkg.com/esbuild-freebsd-64/-/esbuild-freebsd-64-0.13.14.tgz#175ecb2fa8141428cf70ea2d5f4c27534bad53e0"
 57 |   integrity sha512-BKosI3jtvTfnmsCW37B1TyxMUjkRWKqopR0CE9AF2ratdpkxdR24Vpe3gLKNyWiZ7BE96/SO5/YfhbPUzY8wKw==
 58 | 
 59 | esbuild-freebsd-arm64@0.13.14:
 60 |   version "0.13.14"
 61 |   resolved "https://registry.yarnpkg.com/esbuild-freebsd-arm64/-/esbuild-freebsd-arm64-0.13.14.tgz#a7d64e41d1fa581f8db7775e5200f18e67d70c4d"
 62 |   integrity sha512-yd2uh0yf+fWv5114+SYTl4/1oDWtr4nN5Op+PGxAkMqHfYfLjFKpcxwCo/QOS/0NWqPVE8O41IYZlFhbEN2B8Q==
 63 | 
 64 | esbuild-linux-32@0.13.14:
 65 |   version "0.13.14"
 66 |   resolved "https://registry.yarnpkg.com/esbuild-linux-32/-/esbuild-linux-32-0.13.14.tgz#14bdd4f6b6cfd35c65c835894651ba335c2117da"
 67 |   integrity sha512-a8rOnS1oWSfkkYWXoD2yXNV4BdbDKA7PNVQ1klqkY9SoSApL7io66w5H44mTLsfyw7G6Z2vLlaLI2nz9MMAowA==
 68 | 
 69 | esbuild-linux-64@0.13.14:
 70 |   version "0.13.14"
 71 |   resolved "https://registry.yarnpkg.com/esbuild-linux-64/-/esbuild-linux-64-0.13.14.tgz#7fd56851b2982fdd0cd8447ee9858c2c5711708a"
 72 |   integrity sha512-yPZSoMs9W2MC3Dw+6kflKt5FfQm6Dicex9dGIr1OlHRsn3Hm7yGMUTctlkW53KknnZdOdcdd5upxvbxqymczVQ==
 73 | 
 74 | esbuild-linux-arm64@0.13.14:
 75 |   version "0.13.14"
 76 |   resolved "https://registry.yarnpkg.com/esbuild-linux-arm64/-/esbuild-linux-arm64-0.13.14.tgz#a55634d70679ba509adeafd68eebb9fd1ec5af6c"
 77 |   integrity sha512-Lvo391ln9PzC334e+jJ2S0Rt0cxP47eoH5gFyv/E8HhOnEJTvm7A+RRnMjjHnejELacTTfYgFGQYPjLsi/jObQ==
 78 | 
 79 | esbuild-linux-arm@0.13.14:
 80 |   version "0.13.14"
 81 |   resolved "https://registry.yarnpkg.com/esbuild-linux-arm/-/esbuild-linux-arm-0.13.14.tgz#bb96a99677e608b31ff61f37564326d38e846ca2"
 82 |   integrity sha512-8chZE4pkKRvJ/M/iwsNQ1KqsRg2RyU5eT/x2flNt/f8F2TVrDreR7I0HEeCR50wLla3B1C3wTIOzQBmjuc6uWg==
 83 | 
 84 | esbuild-linux-mips64le@0.13.14:
 85 |   version "0.13.14"
 86 |   resolved "https://registry.yarnpkg.com/esbuild-linux-mips64le/-/esbuild-linux-mips64le-0.13.14.tgz#6a55362a8fd1e593dea2ecc41877beed8b8184b9"
 87 |   integrity sha512-MZhgxbmrWbpY3TOE029O6l5tokG9+Yoj2hW7vdit/d/VnmneqeGrSHADuDL6qXM8L5jaCiaivb4VhsyVCpdAbQ==
 88 | 
 89 | esbuild-linux-ppc64le@0.13.14:
 90 |   version "0.13.14"
 91 |   resolved "https://registry.yarnpkg.com/esbuild-linux-ppc64le/-/esbuild-linux-ppc64le-0.13.14.tgz#9e0048587ece0a7f184ab147f20d077098045e7f"
 92 |   integrity sha512-un7KMwS7fX1Un6BjfSZxTT8L5cV/8Uf4SAhM7WYy2XF8o8TI+uRxxD03svZnRNIPsN2J5cl6qV4n7Iwz+yhhVw==
 93 | 
 94 | esbuild-netbsd-64@0.13.14:
 95 |   version "0.13.14"
 96 |   resolved "https://registry.yarnpkg.com/esbuild-netbsd-64/-/esbuild-netbsd-64-0.13.14.tgz#dcab16a4bbcfa16e2e8535dadc5f64fdc891c63b"
 97 |   integrity sha512-5ekKx/YbOmmlTeNxBjh38Uh5TGn5C4uyqN17i67k18pS3J+U2hTVD7rCxcFcRS1AjNWumkVL3jWqYXadFwMS0Q==
 98 | 
 99 | esbuild-openbsd-64@0.13.14:
100 |   version "0.13.14"
101 |   resolved "https://registry.yarnpkg.com/esbuild-openbsd-64/-/esbuild-openbsd-64-0.13.14.tgz#3c7453b155ebb68dc34d5aec3bd6505337bdda08"
102 |   integrity sha512-9bzvwewHjct2Cv5XcVoE1yW5YTW12Sk838EYfA46abgnhxGoFSD1mFcaztp5HHC43AsF+hQxbSFG/RilONARUA==
103 | 
104 | esbuild-sunos-64@0.13.14:
105 |   version "0.13.14"
106 |   resolved "https://registry.yarnpkg.com/esbuild-sunos-64/-/esbuild-sunos-64-0.13.14.tgz#85addf5fef6b5db154a955d4f2e88953359d75ce"
107 |   integrity sha512-mjMrZB76M6FmoiTvj/RGWilrioR7gVwtFBRVugr9qLarXMIU1W/pQx+ieEOtflrW61xo8w1fcxyHsVVGRvoQ0w==
108 | 
109 | esbuild-windows-32@0.13.14:
110 |   version "0.13.14"
111 |   resolved "https://registry.yarnpkg.com/esbuild-windows-32/-/esbuild-windows-32-0.13.14.tgz#f77f98f30a5c636c44db2428ecdf9bcbbaedb1a7"
112 |   integrity sha512-GZa6mrx2rgfbH/5uHg0Rdw50TuOKbdoKCpEBitzmG5tsXBdce+cOL+iFO5joZc6fDVCLW3Y6tjxmSXRk/v20Hg==
113 | 
114 | esbuild-windows-64@0.13.14:
115 |   version "0.13.14"
116 |   resolved "https://registry.yarnpkg.com/esbuild-windows-64/-/esbuild-windows-64-0.13.14.tgz#bc778674c40d65150d12385e0f23eb3a0badbd0d"
117 |   integrity sha512-Lsgqah24bT7ClHjLp/Pj3A9wxjhIAJyWQcrOV4jqXAFikmrp2CspA8IkJgw7HFjx6QrJuhpcKVbCAe/xw0i2yw==
118 | 
119 | esbuild-windows-arm64@0.13.14:
120 |   version "0.13.14"
121 |   resolved "https://registry.yarnpkg.com/esbuild-windows-arm64/-/esbuild-windows-arm64-0.13.14.tgz#91a8dad35ab2c4dd27cd83860742955b25a354d7"
122 |   integrity sha512-KP8FHVlWGhM7nzYtURsGnskXb/cBCPTfj0gOKfjKq2tHtYnhDZywsUG57nk7TKhhK0fL11LcejHG3LRW9RF/9A==
123 | 
124 | esbuild@>=0.8.1:
125 |   version "0.13.14"
126 |   resolved "https://registry.yarnpkg.com/esbuild/-/esbuild-0.13.14.tgz#98a3f7f42809abdc2b57c84565d0f713382dc1a5"
127 |   integrity sha512-xu4D+1ji9x53ocuomcY+KOrwAnWzhBu/wTEjpdgZ8I1c8i5vboYIeigMdzgY1UowYBKa2vZgVgUB32bu7gkxeg==
128 |   optionalDependencies:
129 |     esbuild-android-arm64 "0.13.14"
130 |     esbuild-darwin-64 "0.13.14"
131 |     esbuild-darwin-arm64 "0.13.14"
132 |     esbuild-freebsd-64 "0.13.14"
133 |     esbuild-freebsd-arm64 "0.13.14"
134 |     esbuild-linux-32 "0.13.14"
135 |     esbuild-linux-64 "0.13.14"
136 |     esbuild-linux-arm "0.13.14"
137 |     esbuild-linux-arm64 "0.13.14"
138 |     esbuild-linux-mips64le "0.13.14"
139 |     esbuild-linux-ppc64le "0.13.14"
140 |     esbuild-netbsd-64 "0.13.14"
141 |     esbuild-openbsd-64 "0.13.14"
142 |     esbuild-sunos-64 "0.13.14"
143 |     esbuild-windows-32 "0.13.14"
144 |     esbuild-windows-64 "0.13.14"
145 |     esbuild-windows-arm64 "0.13.14"
146 | 
147 | find-elm-dependencies@^2.0.4:
148 |   version "2.0.4"
149 |   resolved "https://registry.yarnpkg.com/find-elm-dependencies/-/find-elm-dependencies-2.0.4.tgz#0a327fc8c0c0297b54115efbf0a9d6de474cfc89"
150 |   integrity sha512-x/4w4fVmlD2X4PD9oQ+yh9EyaQef6OtEULdMGBTuWx0Nkppvo2Z/bAiQioW2n+GdRYKypME2b9OmYTw5tw5qDg==
151 |   dependencies:
152 |     firstline "^1.2.0"
153 |     lodash "^4.17.19"
154 | 
155 | firstline@^1.2.0:
156 |   version "1.3.1"
157 |   resolved "https://registry.yarnpkg.com/firstline/-/firstline-1.3.1.tgz#59e84af0fd858fbc6dac0a0ff97fd22a47e58084"
158 |   integrity sha512-ycwgqtoxujz1dm0kjkBFOPQMESxB9uKc/PlD951dQDIG+tBXRpYZC2UmJb0gDxopQ1ZX6oyRQN3goRczYu7Deg==
159 | 
160 | fs.realpath@^1.0.0:
161 |   version "1.0.0"
162 |   resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f"
163 |   integrity sha1-FQStJSMVjKpA20onh8sBQRmU6k8=
164 | 
165 | glob@^7.1.3:
166 |   version "7.1.6"
167 |   resolved "https://registry.yarnpkg.com/glob/-/glob-7.1.6.tgz#141f33b81a7c2492e125594307480c46679278a6"
168 |   integrity sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==
169 |   dependencies:
170 |     fs.realpath "^1.0.0"
171 |     inflight "^1.0.4"
172 |     inherits "2"
173 |     minimatch "^3.0.4"
174 |     once "^1.3.0"
175 |     path-is-absolute "^1.0.0"
176 | 
177 | inflight@^1.0.4:
178 |   version "1.0.6"
179 |   resolved "https://registry.yarnpkg.com/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9"
180 |   integrity sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=
181 |   dependencies:
182 |     once "^1.3.0"
183 |     wrappy "1"
184 | 
185 | inherits@2:
186 |   version "2.0.4"
187 |   resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c"
188 |   integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
189 | 
190 | isexe@^2.0.0:
191 |   version "2.0.0"
192 |   resolved "https://registry.yarnpkg.com/isexe/-/isexe-2.0.0.tgz#e8fbf374dc556ff8947a10dcb0572d633f2cfa10"
193 |   integrity sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=
194 | 
195 | lodash@^4.17.19:
196 |   version "4.17.21"
197 |   resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c"
198 |   integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==
199 | 
200 | minimatch@^3.0.4:
201 |   version "3.0.4"
202 |   resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.0.4.tgz#5166e286457f03306064be5497e8dbb0c3d32083"
203 |   integrity sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==
204 |   dependencies:
205 |     brace-expansion "^1.1.7"
206 | 
207 | minimist@^1.2.5:
208 |   version "1.2.5"
209 |   resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.5.tgz#67d66014b66a6a8aaa0c083c5fd58df4e4e97602"
210 |   integrity sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==
211 | 
212 | mkdirp@^0.5.1:
213 |   version "0.5.5"
214 |   resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.5.tgz#d91cefd62d1436ca0f41620e251288d420099def"
215 |   integrity sha512-NKmAlESf6jMGym1++R0Ra7wvhV+wFW63FaSOFPwRahvea0gMUcGUhVeAg/0BC0wiv9ih5NYPB1Wn1UEI1/L+xQ==
216 |   dependencies:
217 |     minimist "^1.2.5"
218 | 
219 | nice-try@^1.0.4:
220 |   version "1.0.5"
221 |   resolved "https://registry.yarnpkg.com/nice-try/-/nice-try-1.0.5.tgz#a3378a7696ce7d223e88fc9b764bd7ef1089e366"
222 |   integrity sha512-1nh45deeb5olNY7eX82BkPO7SSxR5SSYJiPTrTdFUVYwAl8CKMA5N9PjTYkHiRjisVcxcQ1HXdLhx2qxxJzLNQ==
223 | 
224 | node-elm-compiler@^5.0.6:
225 |   version "5.0.6"
226 |   resolved "https://registry.yarnpkg.com/node-elm-compiler/-/node-elm-compiler-5.0.6.tgz#d4a6e6c9d9a26dba4211ccd2aeae7d5e34057f0c"
227 |   integrity sha512-DWTRQR8b54rvschcZRREdsz7K84lnS8A6YJu8du3QLQ8f204SJbyTaA6NzYYbfUG97OTRKRv/0KZl82cTfpLhA==
228 |   dependencies:
229 |     cross-spawn "6.0.5"
230 |     find-elm-dependencies "^2.0.4"
231 |     lodash "^4.17.19"
232 |     temp "^0.9.0"
233 | 
234 | once@^1.3.0:
235 |   version "1.4.0"
236 |   resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1"
237 |   integrity sha1-WDsap3WWHUsROsF9nFC6753Xa9E=
238 |   dependencies:
239 |     wrappy "1"
240 | 
241 | path-is-absolute@^1.0.0:
242 |   version "1.0.1"
243 |   resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f"
244 |   integrity sha1-F0uSaHNVNP+8es5r9TpanhtcX18=
245 | 
246 | path-key@^2.0.1:
247 |   version "2.0.1"
248 |   resolved "https://registry.yarnpkg.com/path-key/-/path-key-2.0.1.tgz#411cadb574c5a140d3a4b1910d40d80cc9f40b40"
249 |   integrity sha1-QRyttXTFoUDTpLGRDUDYDMn0C0A=
250 | 
251 | rimraf@~2.6.2:
252 |   version "2.6.3"
253 |   resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-2.6.3.tgz#b2d104fe0d8fb27cf9e0a1cda8262dd3833c6cab"
254 |   integrity sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA==
255 |   dependencies:
256 |     glob "^7.1.3"
257 | 
258 | semver@^5.5.0:
259 |   version "5.7.1"
260 |   resolved "https://registry.yarnpkg.com/semver/-/semver-5.7.1.tgz#a954f931aeba508d307bbf069eff0c01c96116f7"
261 |   integrity sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==
262 | 
263 | shebang-command@^1.2.0:
264 |   version "1.2.0"
265 |   resolved "https://registry.yarnpkg.com/shebang-command/-/shebang-command-1.2.0.tgz#44aac65b695b03398968c39f363fee5deafdf1ea"
266 |   integrity sha1-RKrGW2lbAzmJaMOfNj/uXer98eo=
267 |   dependencies:
268 |     shebang-regex "^1.0.0"
269 | 
270 | shebang-regex@^1.0.0:
271 |   version "1.0.0"
272 |   resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-1.0.0.tgz#da42f49740c0b42db2ca9728571cb190c98efea3"
273 |   integrity sha1-2kL0l0DAtC2yypcoVxyxkMmO/qM=
274 | 
275 | temp@^0.9.0:
276 |   version "0.9.4"
277 |   resolved "https://registry.yarnpkg.com/temp/-/temp-0.9.4.tgz#cd20a8580cb63635d0e4e9d4bd989d44286e7620"
278 |   integrity sha512-yYrrsWnrXMcdsnu/7YMYAofM1ktpL5By7vZhf15CrXijWWrEYZks5AXBudalfSWJLlnen/QUJUB5aoB0kqZUGA==
279 |   dependencies:
280 |     mkdirp "^0.5.1"
281 |     rimraf "~2.6.2"
282 | 
283 | which@^1.2.9:
284 |   version "1.3.1"
285 |   resolved "https://registry.yarnpkg.com/which/-/which-1.3.1.tgz#a45043d54f5805316da8d62f9f50918d3da70b0a"
286 |   integrity sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==
287 |   dependencies:
288 |     isexe "^2.0.0"
289 | 
290 | wrappy@1:
291 |   version "1.0.2"
292 |   resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f"
293 |   integrity sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=
294 | 


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