elm-pages 3.0.0-beta.20 → 3.0.0-beta.21

package/generator/dead-code-review/node_modules/elm-solve-deps-wasm/elm_solve_deps_wasm.js

@@ -0,0 +1,419 @@
+let imports = {};
+imports['__wbindgen_placeholder__'] = module.exports;
+let wasm;
+const { TextDecoder, TextEncoder } = require(`util`);
+
+const heap = new Array(32).fill(undefined);
+
+heap.push(undefined, null, true, false);
+
+function getObject(idx) { return heap[idx]; }
+
+let heap_next = heap.length;
+
+function dropObject(idx) {
+    if (idx < 36) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+let cachegetUint8Memory0 = null;
+function getUint8Memory0() {
+    if (cachegetUint8Memory0 === null || cachegetUint8Memory0.buffer !== wasm.memory.buffer) {
+        cachegetUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachegetUint8Memory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
+}
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let cachedTextEncoder = new TextEncoder('utf-8');
+
+const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
+    ? function (arg, view) {
+    return cachedTextEncoder.encodeInto(arg, view);
+}
+    : function (arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+        read: arg.length,
+        written: buf.length
+    };
+});
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length);
+        getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len);
+
+    const mem = getUint8Memory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3);
+        const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+
+        offset += ret.written;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+let cachegetInt32Memory0 = null;
+function getInt32Memory0() {
+    if (cachegetInt32Memory0 === null || cachegetInt32Memory0.buffer !== wasm.memory.buffer) {
+        cachegetInt32Memory0 = new Int32Array(wasm.memory.buffer);
+    }
+    return cachegetInt32Memory0;
+}
+
+let cachegetFloat64Memory0 = null;
+function getFloat64Memory0() {
+    if (cachegetFloat64Memory0 === null || cachegetFloat64Memory0.buffer !== wasm.memory.buffer) {
+        cachegetFloat64Memory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachegetFloat64Memory0;
+}
+
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+/**
+* Initialize the panic hook for more meaningful errors in case of panics,
+* and also initialize the logger for the wasm code.
+*/
+module.exports.init = function() {
+    wasm.init();
+};
+
+/**
+* Solve dependencies for the provided `elm.json`.
+*
+* Include also test dependencies if `use_test` is `true`.
+* It is possible to add additional constraints.
+* The caller is responsible to provide implementations to be able to fetch the `elm.json` of
+* dependencies, as well as to list existing versions (in prefered order) for a given package.
+* @param {string} project_elm_json_str
+* @param {boolean} use_test
+* @param {any} additional_constraints_str
+* @param {Function} js_fetch_elm_json
+* @param {Function} js_list_available_versions
+* @returns {any}
+*/
+module.exports.solve_deps = function(project_elm_json_str, use_test, additional_constraints_str, js_fetch_elm_json, js_list_available_versions) {
+    var ptr0 = passStringToWasm0(project_elm_json_str, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    var ret = wasm.solve_deps(ptr0, len0, use_test, addHeapObject(additional_constraints_str), addHeapObject(js_fetch_elm_json), addHeapObject(js_list_available_versions));
+    return takeObject(ret);
+};
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        wasm.__wbindgen_exn_store(addHeapObject(e));
+    }
+}
+
+module.exports.__wbindgen_object_drop_ref = function(arg0) {
+    takeObject(arg0);
+};
+
+module.exports.__wbindgen_string_new = function(arg0, arg1) {
+    var ret = getStringFromWasm0(arg0, arg1);
+    return addHeapObject(ret);
+};
+
+module.exports.__wbindgen_string_get = function(arg0, arg1) {
+    const obj = getObject(arg1);
+    var ret = typeof(obj) === 'string' ? obj : undefined;
+    var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    getInt32Memory0()[arg0 / 4 + 1] = len0;
+    getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+};
+
+module.exports.__wbindgen_is_object = function(arg0) {
+    const val = getObject(arg0);
+    var ret = typeof(val) === 'object' && val !== null;
+    return ret;
+};
+
+module.exports.__wbindgen_is_null = function(arg0) {
+    var ret = getObject(arg0) === null;
+    return ret;
+};
+
+module.exports.__wbindgen_is_undefined = function(arg0) {
+    var ret = getObject(arg0) === undefined;
+    return ret;
+};
+
+module.exports.__wbindgen_boolean_get = function(arg0) {
+    const v = getObject(arg0);
+    var ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
+    return ret;
+};
+
+module.exports.__wbindgen_number_get = function(arg0, arg1) {
+    const obj = getObject(arg1);
+    var ret = typeof(obj) === 'number' ? obj : undefined;
+    getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret;
+    getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
+};
+
+module.exports.__wbg_String_c8baaa0740def8c6 = function(arg0, arg1) {
+    var ret = String(getObject(arg1));
+    var ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    getInt32Memory0()[arg0 / 4 + 1] = len0;
+    getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+};
+
+module.exports.__wbg_next_c4151d46d5fa7097 = function(arg0) {
+    var ret = getObject(arg0).next;
+    return addHeapObject(ret);
+};
+
+module.exports.__wbindgen_is_function = function(arg0) {
+    var ret = typeof(getObject(arg0)) === 'function';
+    return ret;
+};
+
+module.exports.__wbg_value_e74a542443d92451 = function(arg0) {
+    var ret = getObject(arg0).value;
+    return addHeapObject(ret);
+};
+
+module.exports.__wbg_iterator_4fc4ce93e6b92958 = function() {
+    var ret = Symbol.iterator;
+    return addHeapObject(ret);
+};
+
+module.exports.__wbg_get_67189fe0b323d288 = function(arg0, arg1) {
+    var ret = getObject(arg0)[arg1 >>> 0];
+    return addHeapObject(ret);
+};
+
+module.exports.__wbg_isArray_eb7ad55f2da67dde = function(arg0) {
+    var ret = Array.isArray(getObject(arg0));
+    return ret;
+};
+
+module.exports.__wbg_instanceof_ArrayBuffer_764b6d4119231cb3 = function(arg0) {
+    var ret = getObject(arg0) instanceof ArrayBuffer;
+    return ret;
+};
+
+module.exports.__wbg_values_364ae56c608e6824 = function(arg0) {
+    var ret = getObject(arg0).values();
+    return addHeapObject(ret);
+};
+
+module.exports.__wbg_new_342a24ca698edd87 = function(arg0, arg1) {
+    var ret = new Error(getStringFromWasm0(arg0, arg1));
+    return addHeapObject(ret);
+};
+
+module.exports.__wbg_call_888d259a5fefc347 = function() { return handleError(function (arg0, arg1) {
+    var ret = getObject(arg0).call(getObject(arg1));
+    return addHeapObject(ret);
+}, arguments) };
+
+module.exports.__wbg_call_346669c262382ad7 = function() { return handleError(function (arg0, arg1, arg2) {
+    var ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
+    return addHeapObject(ret);
+}, arguments) };
+
+module.exports.__wbg_call_8a893cac80deeb51 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+    var ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3));
+    return addHeapObject(ret);
+}, arguments) };
+
+module.exports.__wbg_next_7720502039b96d00 = function() { return handleError(function (arg0) {
+    var ret = getObject(arg0).next();
+    return addHeapObject(ret);
+}, arguments) };
+
+module.exports.__wbg_done_b06cf0578e89ff68 = function(arg0) {
+    var ret = getObject(arg0).done;
+    return ret;
+};
+
+module.exports.__wbg_entries_aadf9c3f38203a12 = function(arg0) {
+    var ret = Object.entries(getObject(arg0));
+    return addHeapObject(ret);
+};
+
+module.exports.__wbg_buffer_397eaa4d72ee94dd = function(arg0) {
+    var ret = getObject(arg0).buffer;
+    return addHeapObject(ret);
+};
+
+module.exports.__wbg_new_a7ce447f15ff496f = function(arg0) {
+    var ret = new Uint8Array(getObject(arg0));
+    return addHeapObject(ret);
+};
+
+module.exports.__wbg_instanceof_Uint8Array_08a1f3a179095e76 = function(arg0) {
+    var ret = getObject(arg0) instanceof Uint8Array;
+    return ret;
+};
+
+module.exports.__wbg_length_1eb8fc608a0d4cdb = function(arg0) {
+    var ret = getObject(arg0).length;
+    return ret;
+};
+
+module.exports.__wbg_set_969ad0a60e51d320 = function(arg0, arg1, arg2) {
+    getObject(arg0).set(getObject(arg1), arg2 >>> 0);
+};
+
+module.exports.__wbg_get_4d0f21c2f823742e = function() { return handleError(function (arg0, arg1) {
+    var ret = Reflect.get(getObject(arg0), getObject(arg1));
+    return addHeapObject(ret);
+}, arguments) };
+
+module.exports.__wbg_stringify_d4507a59932eed0c = function() { return handleError(function (arg0) {
+    var ret = JSON.stringify(getObject(arg0));
+    return addHeapObject(ret);
+}, arguments) };
+
+module.exports.__wbindgen_debug_string = function(arg0, arg1) {
+    var ret = debugString(getObject(arg1));
+    var ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    getInt32Memory0()[arg0 / 4 + 1] = len0;
+    getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+};
+
+module.exports.__wbindgen_throw = function(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+};
+
+module.exports.__wbindgen_rethrow = function(arg0) {
+    throw takeObject(arg0);
+};
+
+module.exports.__wbindgen_memory = function() {
+    var ret = wasm.memory;
+    return addHeapObject(ret);
+};
+
+const path = require('path').join(__dirname, 'elm_solve_deps_wasm_bg.wasm');
+const bytes = require('fs').readFileSync(path);
+
+const wasmModule = new WebAssembly.Module(bytes);
+const wasmInstance = new WebAssembly.Instance(wasmModule, imports);
+wasm = wasmInstance.exports;
+module.exports.__wasm = wasm;
+

package/generator/dead-code-review/node_modules/elm-solve-deps-wasm/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "elm-solve-deps-wasm",
+  "collaborators": [
+    "Matthieu Pizenberg <matthieu.pizenberg@gmail.com>"
+  ],
+  "description": "A dependency solver for the elm ecosystem",
+  "version": "1.0.2",
+  "license": "MPL-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mpizenberg/elm-solve-deps-wasm"
+  },
+  "files": [
+    "elm_solve_deps_wasm_bg.wasm",
+    "elm_solve_deps_wasm.js",
+    "elm_solve_deps_wasm.d.ts"
+  ],
+  "main": "elm_solve_deps_wasm.js",
+  "types": "elm_solve_deps_wasm.d.ts",
+  "keywords": [
+    "dependency",
+    "pubgrub",
+    "solver",
+    "version",
+    "elm"
+  ]
+}

package/generator/dead-code-review/node_modules/elm-test/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2015, Richard Feldman
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of node-test-runner nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/generator/dead-code-review/node_modules/elm-test/README.md

@@ -0,0 +1,192 @@
+# node-test-runner [![Version](https://img.shields.io/npm/v/elm-test.svg)](https://www.npmjs.com/package/elm-test)
+
+Runs [elm-explorations/test] suites in Node.js.
+
+When people say “elm-test” they usually refer to either:
+
+- This CLI tool for running tests.
+- [elm-explorations/test] – an Elm package for defining tests that this CLI tool can run.
+
+[elm-explorations/test]: https://package.elm-lang.org/packages/elm-explorations/test/latest
+
+## Installation
+
+```
+npm install --save-dev elm-test
+```
+
+## Quick start
+
+Install [elm-explorations/test] and create `tests/Example.elm`:
+
+    npx elm-test init
+
+Run tests in the `tests/` folder:
+
+    npx elm-test
+
+Run tests in one particular file:
+
+    npx elm-test tests/Example.elm
+
+Run tests in files matching a [glob](https://github.com/isaacs/node-glob#glob-primer):
+
+    npx elm-test "src/**/*Tests.elm"
+
+> Note: The double quotes are important! Without quotes, your shell might expand the globs for you. With quotes, elm-test expands the globs. This way the watcher can pick up new tests matching the globs, and it will work cross-platform.
+
+Run in watch mode:
+
+    npx elm-test --watch
+
+## Where to put tests
+
+### Locating files containing tests
+
+There are 3 places you could put your tests:
+
+1.  In the `tests/` folder.
+
+    This is the default and requires no extra setup.
+
+2.  In any source directory (`"source-directories"` in `elm.json` for applications, `src/` for packages) as separate files.
+
+    A convention is to put test files next to the file it tests with a `Tests` suffix. For example, you could have `src/LoginForm.elm` and `src/LoginFormTests.elm`.
+
+    This requires telling elm-test which folders/files to run. Examples:
+
+        npx elm-test "src/**/*Tests.elm"
+        npx elm-test test/frontend/elm
+
+    You might also need to configure your editor to understand that the `"test-dependencies"` in your `elm.json` are available in these files.
+
+3.  In already existing source files.
+
+    This allows testing internal functions without exposing them. (Be aware that testing implementation details can sometimes be counter-productive.)
+
+    This requires moving everything in `"test-dependencies"` in your `elm.json` into regular `"dependencies"`, so your project still compiles. This also helps your editor. Note that this approach isn’t suitable for packages, since you don’t want your package to unnecessarily depend on [elm-explorations/test].
+
+You can mix all three variants if you want:
+
+    npx elm-test tests "src/**/*Tests.elm" app
+
+> In this example, `"src"` and `"app"` need to be in `"source-directories"` in `elm.json`.
+
+### Locating tests within files
+
+For elm-test to find tests in your files you need to:
+
+1. Create top-level values of the type [Test](https://package.elm-lang.org/packages/elm-explorations/test/latest/Test#Test). You can name the values anything – the only thing that matters is that their type is `Test`.
+2. Expose them.
+
+Example:
+
+```elm
+module LoginForm exposing (alreadyLoggedInTests, tests)
+
+import Test exposing (Test)
+
+
+tests : Test
+tests =
+    -- ...
+
+
+alreadyLoggedInTests : Test
+alreadyLoggedInTests =
+    -- ...
+```
+
+Some prefer to expose a single `Test` value and group everything using [describe](https://package.elm-lang.org/packages/elm-explorations/test/latest/Test#describe). Some prefer to expose several `Test` values.
+
+**Also check out the [elm-explorations/test quick-start](https://github.com/elm-explorations/test#quick-start) guide!**
+
+## Command Line Arguments
+
+These are the most common commands and flags. Run `elm-test --help` for an exhaustive list.
+
+**Note:** Throughout this section, the `npx` prefix is omitted for brevity.
+
+### install
+
+Like `elm install`, except elm-test will install to `"test-dependencies"` in your `elm.json` instead of to `"dependencies"`.
+
+    elm-test install elm/regex
+
+### init
+
+Runs `elm-test install elm-explorations/test` and then creates a `tests/Example.elm` example test to get you started.
+
+`elm-test init` requires an `elm.json` file up the directory tree, so you will need to run `elm init` first if you don’t already have one.
+
+After initializing elm-test in your project, try out the example by running `elm-test` with no arguments.
+
+    elm init
+    elm-test init
+    elm-test
+
+### --watch
+
+Start the runner in watch mode. Your tests will automatically rerun whenever your project changes.
+
+    elm-test --watch
+
+### --seed
+
+Run with a specific fuzzer seed, rather than a randomly generated seed. This allows reproducing a failing fuzz-test. The command needed to reproduce (including the `--seed` flag) is printed after each test run. Copy, paste and run it!
+
+    elm-test --seed 336948560956134
+
+### --fuzz
+
+Define how many times each fuzz-test should run. Defaults to `100`.
+
+    elm-test --fuzz 500
+
+### --report
+
+Specify which format to use for reporting test results. Valid options are:
+
+- `console` (default): pretty, human readable formatted output.
+- `json`: newline-delimited json with an object for each event.
+- `junit`: junit-compatible xml.
+
+```
+elm-test --report json
+```
+
+### --no-color
+
+Disable colored console output.
+
+Colors are also disabled when you pipe the output of `elm-test` to another program. You can use `--color` to force the colors back.
+
+Alternatively, you can set the environment variable `FORCE_COLOR` to `0` to disable colors, or to any other value to force them.
+
+See [chalk.supportsColor](https://github.com/chalk/chalk#chalksupportscolor) for more information.
+
+### --compiler
+
+If `elm` is _not_ in your `$PATH` when elm-test runs, or the Elm executable is called something other than `elm`, you can use this flag to point to your installation.
+
+    elm-test --compiler /path/to/elm
+
+To run a tool installed locally using `npm` you can use `npx`:
+
+    npx elm-test
+
+`npx` adds the local `node_modules/.bin/` folder to `$PATH` when it executes the command passed to it. This means that if you have installed `elm` locally, `elm-test` will automatically find that local installation.
+
+As mentioned in [Installation](#installation) we recommend installing elm-test locally in every project. This ensures all contributors and CI use the same version, to avoid nasty “works on my computer” issues.
+
+## Travis CI
+
+If you want to run your tests on Travis CI, [here's a good starter `.travis.yml`](https://docs.travis-ci.com/user/languages/elm/):
+
+```yml
+language: elm
+elm:
+  - 0.19.1
+```
+
+Here is an example [`travis.yml`](https://github.com/rtfeldman/elm-css/blob/master/.travis.yml) configuration file for running tests in CI.

package/generator/dead-code-review/node_modules/elm-test/bin/elm-test

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require("../lib/elm-test.js");

package/generator/dead-code-review/node_modules/elm-test/elm/elm.json

@@ -0,0 +1,25 @@
+{
+    "type": "application",
+    "source-directories": [
+        "src"
+    ],
+    "elm-version": "0.19.1",
+    "dependencies": {
+        "direct": {
+            "elm/core": "1.0.5",
+            "elm/json": "1.1.3",
+            "elm/random": "1.0.0",
+            "elm/time": "1.0.0"
+        },
+        "indirect": {}
+    },
+    "test-dependencies": {
+        "direct": {
+            "elm-explorations/test": "1.2.0"
+        },
+        "indirect": {
+            "elm/html": "1.0.0",
+            "elm/virtual-dom": "1.0.2"
+        }
+    }
+}