"+(escaped?code:escape(code,true))+"\n'+(escaped?code:escape(code,true))+"\n\n"+quote+"\n"};Renderer.prototype.html=function(html){return html};Renderer.prototype.heading=function(text,level,raw){return"
\n":"
\n"};Renderer.prototype.list=function(body,ordered){var type=ordered?"ol":"ul";return"<"+type+">\n"+body+"\n"};Renderer.prototype.listitem=function(text){return"
"+text+"
\n"};Renderer.prototype.table=function(header,body){return""+text+""};Renderer.prototype.br=function(){return this.options.xhtml?"":"
"};Renderer.prototype.del=function(text){return"
"+escape(e.message+"",true)+""}throw e}}marked.options=marked.setOptions=function(opt){merge(marked.defaults,opt);return marked};marked.defaults={gfm:true,tables:true,breaks:false,pedantic:false,sanitize:false,smartLists:false,silent:false,highlight:null,langPrefix:"lang-",smartypants:false,headerPrefix:"",renderer:new Renderer,xhtml:false};marked.Parser=Parser;marked.parser=Parser.parse;marked.Renderer=Renderer;marked.Lexer=Lexer;marked.lexer=Lexer.lex;marked.InlineLexer=InlineLexer;marked.inlineLexer=InlineLexer.output;marked.parse=marked;if(typeof module!=="undefined"&&typeof exports==="object"){module.exports=marked}else if(typeof define==="function"&&define.amd){define(function(){return marked})}else{this.marked=marked}}).call(function(){return this||(typeof window!=="undefined"?window:global)}()); + + marked.setOptions({ + highlight: function (code, lang) { + if (typeof hljs !== 'undefined' + && lang + && hljs.listLanguages().indexOf(lang) >= 0) { + return hljs.highlight(lang, code, true).value; + } + return code; + } + }); + + function formatOptions(options) { + var gfm = options.githubFlavored; + if (gfm.ctor === 'Just') { + return { + gfm: true, + tables: gfm.tables, + breaks: gfm.breaks, + sanitize: options.sanitize, + smartypants: options.smartypants + } + } + else { + return { + gfm: false, + tables: false, + breaks: false, + sanitize: options.sanitize, + smartypants: options.smartypants + } + } + } + + function toHtmlWith(options, rawMarkdown) { + var widget = { + type: "Widget", + + init: function () { + var html = marked(rawMarkdown, formatOptions(options)); + var div = document.createElement('div'); + div.innerHTML = html; + return div; + }, + + update: function (previous, node) { + var html = marked(rawMarkdown, formatOptions(options)); + node.innerHTML = html; + return node; + } + }; + return widget; + } + + function toElementWith(options, rawMarkdown) { + return Text.markdown(marked(rawMarkdown, formatOptions(options))); + } + + return Elm.Native.Markdown.values = { + toHtmlWith: F2(toHtmlWith), + toElementWith: F2(toElementWith) + }; +}; +Elm.Native.Ports = {}; +Elm.Native.Ports.make = function(localRuntime) { + localRuntime.Native = localRuntime.Native || {}; + localRuntime.Native.Ports = localRuntime.Native.Ports || {}; + if (localRuntime.Native.Ports.values) { + return localRuntime.Native.Ports.values; + } + + var Signal; + + function incomingSignal(converter) { + converter.isSignal = true; + return converter; + } + + function outgoingSignal(converter) { + if (!Signal) { + Signal = Elm.Signal.make(localRuntime); + } + return function(signal) { + var subscribers = [] + function subscribe(handler) { + subscribers.push(handler); + } + function unsubscribe(handler) { + subscribers.pop(subscribers.indexOf(handler)); + } + A2( Signal.map, function(value) { + var val = converter(value); + var len = subscribers.length; + for (var i = 0; i < len; ++i) { + subscribers[i](val); + } + }, signal); + return { subscribe:subscribe, unsubscribe:unsubscribe }; + } + } + + function portIn(name, converter) { + var jsValue = localRuntime.ports.incoming[name]; + if (jsValue === undefined) { + throw new Error("Initialization Error: port '" + name + + "' was not given an input!"); + } + localRuntime.ports.uses[name] += 1; + try { + var elmValue = converter(jsValue); + } catch(e) { + throw new Error("Initialization Error on port '" + name + "': \n" + e.message); + } + + // just return a static value if it is not a signal + if (!converter.isSignal) { + return elmValue; + } + + // create a signal if necessary + if (!Signal) { + Signal = Elm.Signal.make(localRuntime); + } + var signal = Signal.constant(elmValue); + function send(jsValue) { + try { + var elmValue = converter(jsValue); + } catch(e) { + throw new Error("Error sending to port '" + name + "': \n" + e.message); + } + setTimeout(function() { + localRuntime.notify(signal.id, elmValue); + }, 0); + } + localRuntime.ports.outgoing[name] = { send:send }; + return signal; + } + + function portOut(name, converter, value) { + try { + localRuntime.ports.outgoing[name] = converter(value); + } catch(e) { + throw new Error("Initialization Error on port '" + name + "': \n" + e.message); + } + return value; + } + + return localRuntime.Native.Ports.values = { + incomingSignal: incomingSignal, + outgoingSignal: outgoingSignal, + portOut: portOut, + portIn: portIn + }; +}; + + + +if (!Elm.fullscreen) { + + (function() { + 'use strict'; + + var Display = { FULLSCREEN: 0, COMPONENT: 1, NONE: 2 }; + + Elm.fullscreen = function(module, ports) { + var container = document.createElement('div'); + document.body.appendChild(container); + return init(Display.FULLSCREEN, container, module, ports || {}); + }; + + Elm.embed = function(module, container, ports) { + var tag = container.tagName; + if (tag !== 'DIV') { + throw new Error('Elm.node must be given a DIV, not a ' + tag + '.'); + } + return init(Display.COMPONENT, container, module, ports || {}); + }; + + Elm.worker = function(module, ports) { + return init(Display.NONE, {}, module, ports || {}); + }; + + function init(display, container, module, ports, moduleToReplace) { + // defining state needed for an instance of the Elm RTS + var inputs = []; + + /* OFFSET + * Elm's time traveling debugger lets you pause time. This means + * "now" may be shifted a bit into the past. By wrapping Date.now() + * we can manage this. + */ + var timer = { + now: function() { + return Date.now(); + } + }; + + var updateInProgress = false; + function notify(id, v) { + if (updateInProgress) { + throw new Error( + 'The notify function has been called synchronously!\n' + + 'This can lead to frames being dropped.\n' + + 'Definitely report this to
"); + var arr = str.split('
'); + for (var i = arr.length; i--; ) { + arr[i] = makeSpaces(arr[i]); + } + return arr.join('
'); + } + + function fromString(str) { + return Utils.txt(properEscape(str)); + } + + function append(xs, ys) { + return Utils.txt(Utils.makeText(xs) + Utils.makeText(ys)); + } + + // conversions from Elm values to CSS + function toTypefaces(list) { + var typefaces = List.toArray(list); + for (var i = typefaces.length; i--; ) { + var typeface = typefaces[i]; + if (typeface.indexOf(' ') > -1) { + typefaces[i] = "'" + typeface + "'"; + } + } + return typefaces.join(','); + } + function toLine(line) { + var ctor = line.ctor; + return ctor === 'Under' ? 'underline' : + ctor === 'Over' ? 'overline' : 'line-through'; + } + + // setting styles of Text + function style(style, text) { + var newText = '' + return Utils.txt(newText); + } + function height(px, text) { + return { style: 'font-size:' + px + 'px;', text:text } + } + function typeface(names, text) { + return { style: 'font-family:' + toTypefaces(names) + ';', text:text } + } + function monospace(text) { + return { style: 'font-family:monospace;', text:text } + } + function italic(text) { + return { style: 'font-style:italic;', text:text } + } + function bold(text) { + return { style: 'font-weight:bold;', text:text } + } + function link(href, text) { + return { href: fromString(href), text:text }; + } + function line(line, text) { + return { style: 'text-decoration:' + toLine(line) + ';', text:text }; + } + + function color(color, text) { + return { style: 'color:' + toCss(color) + ';', text:text }; + } + + function block(align) { + return function(text) { + var raw = { + ctor :'RawHtml', + html : Utils.makeText(text), + align: align + }; + var pos = A2(NativeElement.htmlHeight, 0, raw); + return A3(Element.newElement, pos._0, pos._1, raw); + } + } + + function markdown(text) { + var raw = { + ctor:'RawHtml', + html: text, + align: null + }; + var pos = A2(NativeElement.htmlHeight, 0, raw); + return A3(Element.newElement, pos._0, pos._1, raw); + } + + return elm.Native.Text.values = { + fromString: fromString, + append: F2(append), + + height : F2(height), + italic : italic, + bold : bold, + line : F2(line), + monospace : monospace, + typeface : F2(typeface), + color : F2(color), + link : F2(link), + style : F2(style), + + leftAligned : block('left'), + rightAligned : block('right'), + centered : block('center'), + justified : block('justify'), + markdown : markdown, + + toTypefaces:toTypefaces, + toLine:toLine + }; +}; + +Elm.Native.Transform2D = {}; +Elm.Native.Transform2D.make = function(elm) { + + elm.Native = elm.Native || {}; + elm.Native.Transform2D = elm.Native.Transform2D || {}; + if (elm.Native.Transform2D.values) return elm.Native.Transform2D.values; + + var A; + if (typeof Float32Array === 'undefined') { + A = function(arr) { + this.length = arr.length; + this[0] = arr[0]; + this[1] = arr[1]; + this[2] = arr[2]; + this[3] = arr[3]; + this[4] = arr[4]; + this[5] = arr[5]; + }; + } else { + A = Float32Array; + } + + // layout of matrix in an array is + // + // | m11 m12 dx | + // | m21 m22 dy | + // | 0 0 1 | + // + // new A([ m11, m12, dx, m21, m22, dy ]) + + var identity = new A([1,0,0,0,1,0]); + function matrix(m11, m12, m21, m22, dx, dy) { + return new A([m11, m12, dx, m21, m22, dy]); + } + function rotation(t) { + var c = Math.cos(t); + var s = Math.sin(t); + return new A([c, -s, 0, s, c, 0]); + } + function rotate(t,m) { + var c = Math.cos(t); + var s = Math.sin(t); + var m11 = m[0], m12 = m[1], m21 = m[3], m22 = m[4]; + return new A([m11*c + m12*s, -m11*s + m12*c, m[2], + m21*c + m22*s, -m21*s + m22*c, m[5]]); + } + /* + function move(xy,m) { + var x = xy._0; + var y = xy._1; + var m11 = m[0], m12 = m[1], m21 = m[3], m22 = m[4]; + return new A([m11, m12, m11*x + m12*y + m[2], + m21, m22, m21*x + m22*y + m[5]]); + } + function scale(s,m) { return new A([m[0]*s, m[1]*s, m[2], m[3]*s, m[4]*s, m[5]]); } + function scaleX(x,m) { return new A([m[0]*x, m[1], m[2], m[3]*x, m[4], m[5]]); } + function scaleY(y,m) { return new A([m[0], m[1]*y, m[2], m[3], m[4]*y, m[5]]); } + function reflectX(m) { return new A([-m[0], m[1], m[2], -m[3], m[4], m[5]]); } + function reflectY(m) { return new A([m[0], -m[1], m[2], m[3], -m[4], m[5]]); } + + function transform(m11, m21, m12, m22, mdx, mdy, n) { + var n11 = n[0], n12 = n[1], n21 = n[3], n22 = n[4], ndx = n[2], ndy = n[5]; + return new A([m11*n11 + m12*n21, + m11*n12 + m12*n22, + m11*ndx + m12*ndy + mdx, + m21*n11 + m22*n21, + m21*n12 + m22*n22, + m21*ndx + m22*ndy + mdy]); + } + */ + function multiply(m, n) { + var m11 = m[0], m12 = m[1], m21 = m[3], m22 = m[4], mdx = m[2], mdy = m[5]; + var n11 = n[0], n12 = n[1], n21 = n[3], n22 = n[4], ndx = n[2], ndy = n[5]; + return new A([m11*n11 + m12*n21, + m11*n12 + m12*n22, + m11*ndx + m12*ndy + mdx, + m21*n11 + m22*n21, + m21*n12 + m22*n22, + m21*ndx + m22*ndy + mdy]); + } + + return elm.Native.Transform2D.values = { + identity:identity, + matrix:F6(matrix), + rotation:rotation, + multiply:F2(multiply) + /* + transform:F7(transform), + rotate:F2(rotate), + move:F2(move), + scale:F2(scale), + scaleX:F2(scaleX), + scaleY:F2(scaleY), + reflectX:reflectX, + reflectY:reflectY + */ + }; + +}; + +Elm.Native = Elm.Native || {}; +Elm.Native.Utils = {}; +Elm.Native.Utils.make = function(localRuntime) { + + localRuntime.Native = localRuntime.Native || {}; + localRuntime.Native.Utils = localRuntime.Native.Utils || {}; + if (localRuntime.Native.Utils.values) { + return localRuntime.Native.Utils.values; + } + + function eq(l,r) { + var stack = [{'x': l, 'y': r}] + while (stack.length > 0) { + var front = stack.pop(); + var x = front.x; + var y = front.y; + if (x === y) continue; + if (typeof x === "object") { + var c = 0; + for (var i in x) { + ++c; + if (i in y) { + if (i !== 'ctor') { + stack.push({ 'x': x[i], 'y': y[i] }); + } + } else { + return false; + } + } + if ('ctor' in x) { + stack.push({'x': x.ctor, 'y': y.ctor}); + } + if (c !== Object.keys(y).length) { + return false; + }; + } else if (typeof x === 'function') { + throw new Error('Equality error: general function equality is ' + + 'undecidable, and therefore, unsupported'); + } else { + return false; + } + } + return true; + } + + // code in Generate/JavaScript.hs depends on the particular + // integer values assigned to LT, EQ, and GT + var LT = -1, EQ = 0, GT = 1, ord = ['LT','EQ','GT']; + function compare(x,y) { return { ctor: ord[cmp(x,y)+1] } } + function cmp(x,y) { + var ord; + if (typeof x !== 'object'){ + return x === y ? EQ : x < y ? LT : GT; + } + else if (x.isChar){ + var a = x.toString(); + var b = y.toString(); + return a === b ? EQ : a < b ? LT : GT; + } + else if (x.ctor === "::" || x.ctor === "[]") { + while (true) { + if (x.ctor === "[]" && y.ctor === "[]") return EQ; + if (x.ctor !== y.ctor) return x.ctor === '[]' ? LT : GT; + ord = cmp(x._0, y._0); + if (ord !== EQ) return ord; + x = x._1; + y = y._1; + } + } + else if (x.ctor.slice(0,6) === '_Tuple') { + var n = x.ctor.slice(6) - 0; + var err = 'cannot compare tuples with more than 6 elements.'; + if (n === 0) return EQ; + if (n >= 1) { ord = cmp(x._0, y._0); if (ord !== EQ) return ord; + if (n >= 2) { ord = cmp(x._1, y._1); if (ord !== EQ) return ord; + if (n >= 3) { ord = cmp(x._2, y._2); if (ord !== EQ) return ord; + if (n >= 4) { ord = cmp(x._3, y._3); if (ord !== EQ) return ord; + if (n >= 5) { ord = cmp(x._4, y._4); if (ord !== EQ) return ord; + if (n >= 6) { ord = cmp(x._5, y._5); if (ord !== EQ) return ord; + if (n >= 7) throw new Error('Comparison error: ' + err); } } } } } } + return EQ; + } + else { + throw new Error('Comparison error: comparison is only defined on ints, ' + + 'floats, times, chars, strings, lists of comparable values, ' + + 'and tuples of comparable values.'); + } + } + + + var Tuple0 = { ctor: "_Tuple0" }; + function Tuple2(x,y) { + return { + ctor: "_Tuple2", + _0: x, + _1: y + }; + } + + function chr(c) { + var x = new String(c); + x.isChar = true; + return x; + } + + function txt(str) { + var t = new String(str); + t.text = true; + return t; + } + + function makeText(text) { + var style = ''; + var href = ''; + while (true) { + if (text.style) { + style += text.style; + text = text.text; + continue; + } + if (text.href) { + href = text.href; + text = text.text; + continue; + } + if (href) { + text = '' + text + ''; + } + if (style) { + text = '' + text + ''; + } + return text; + } + } + + var count = 0; + function guid(_) { + return count++ + } + + function copy(oldRecord) { + var newRecord = {}; + for (var key in oldRecord) { + var value = key === '_' + ? copy(oldRecord._) + : oldRecord[key] + ; + newRecord[key] = value; + } + return newRecord; + } + + function remove(key, oldRecord) { + var record = copy(oldRecord); + if (key in record._) { + record[key] = record._[key][0]; + record._[key] = record._[key].slice(1); + if (record._[key].length === 0) { + delete record._[key]; + } + } else { + delete record[key]; + } + return record; + } + + function replace(keyValuePairs, oldRecord) { + var record = copy(oldRecord); + for (var i = keyValuePairs.length; i--; ) { + var pair = keyValuePairs[i]; + record[pair[0]] = pair[1]; + } + return record; + } + + function insert(key, value, oldRecord) { + var newRecord = copy(oldRecord); + if (key in newRecord) { + var values = newRecord._[key]; + var copiedValues = values ? values.slice(0) : []; + newRecord._[key] = [newRecord[key]].concat(copiedValues); + } + newRecord[key] = value; + return newRecord; + } + + function getXY(e) { + var posx = 0; + var posy = 0; + if (e.pageX || e.pageY) { + posx = e.pageX; + posy = e.pageY; + } else if (e.clientX || e.clientY) { + posx = e.clientX + document.body.scrollLeft + document.documentElement.scrollLeft; + posy = e.clientY + document.body.scrollTop + document.documentElement.scrollTop; + } + + if (localRuntime.isEmbed()) { + var rect = localRuntime.node.getBoundingClientRect(); + var relx = rect.left + document.body.scrollLeft + document.documentElement.scrollLeft; + var rely = rect.top + document.body.scrollTop + document.documentElement.scrollTop; + // TODO: figure out if there is a way to avoid rounding here + posx = posx - Math.round(relx) - localRuntime.node.clientLeft; + posy = posy - Math.round(rely) - localRuntime.node.clientTop; + } + return Tuple2(posx, posy); + } + + + //// LIST STUFF //// + + var Nil = { ctor:'[]' }; + + function Cons(hd,tl) { + return { + ctor: "::", + _0: hd, + _1: tl + }; + } + + function append(xs,ys) { + // append Text + if (xs.text || ys.text) { + return txt(makeText(xs) + makeText(ys)); + } + + // append Strings + if (typeof xs === "string") { + return xs + ys; + } + + // append Lists + if (xs.ctor === '[]') { + return ys; + } + var root = Cons(xs._0, Nil); + var curr = root; + xs = xs._1; + while (xs.ctor !== '[]') { + curr._1 = Cons(xs._0, Nil); + xs = xs._1; + curr = curr._1; + } + curr._1 = ys; + return root; + } + + //// RUNTIME ERRORS //// + + function indent(lines) { + return '\n' + lines.join('\n'); + } + + function badCase(moduleName, span) { + var msg = indent([ + 'Non-exhaustive pattern match in case-expression.', + 'Make sure your patterns cover every case!' + ]); + throw new Error('Runtime error in module ' + moduleName + ' (' + span + ')' + msg); + } + + function badIf(moduleName, span) { + var msg = indent([ + 'Non-exhaustive pattern match in multi-way-if expression.', + 'It is best to use \'otherwise\' as the last branch of multi-way-if.' + ]); + throw new Error('Runtime error in module ' + moduleName + ' (' + span + ')' + msg); + } + + + function badPort(expected, received) { + var msg = indent([ + 'Expecting ' + expected + ' but was given ', + JSON.stringify(received) + ]); + throw new Error('Runtime error when sending values through a port.' + msg); + } + + + return localRuntime.Native.Utils.values = { + eq:eq, + cmp:cmp, + compare:F2(compare), + Tuple0:Tuple0, + Tuple2:Tuple2, + chr:chr, + txt:txt, + makeText:makeText, + copy: copy, + remove: remove, + replace: replace, + insert: insert, + guid: guid, + getXY: getXY, + + Nil: Nil, + Cons: Cons, + append: F2(append), + + badCase: badCase, + badIf: badIf, + badPort: badPort + }; +}; + +(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o
\n`watch : String -> a -> a`\n\n\nUse [Debug.watchSummary](http://library.elm-lang.org/catalog/elm-lang-Elm/latest/Debug#watchSummary) to show a
\nsummary or subvalue of any value.
\n\n"); + var valueAttributes = _L.fromArray([$Html$Attributes.style(_L.fromArray([{ctor: "_Tuple2" + ,_0: "margin" + ,_1: "0 0 0 10px"}]))]); + var viewValue = function (value) { + return A2($Html.pre, + valueAttributes, + _L.fromArray([$Html.text(value)])); + }; + var nameAttributes = _L.fromArray([$Html$Attributes.style(_L.fromArray([{ctor: "_Tuple2" + ,_0: "margin" + ,_1: "20px 0 10px"} + ,{ctor: "_Tuple2" + ,_0: "font-weight" + ,_1: "bold"} + ,{ctor: "_Tuple2" + ,_0: "font-family" + ,_1: "Gotham, Futura, \'Lucida Grande\', sans-serif"}]))]); + var viewName = function (name) { + return A2($Html.div, + nameAttributes, + _L.fromArray([$Html.text(name)])); + }; + var watchAttributes = _L.fromArray([$Html$Attributes.style(_L.fromArray([{ctor: "_Tuple2" + ,_0: "color" + ,_1: "rgb(228, 228, 228)"}]))]); + var viewWatch = function (_v0) { + return function () { + switch (_v0.ctor) + {case "_Tuple2": + return A2($Html.div, + watchAttributes, + _L.fromArray([viewName(_v0._0) + ,viewValue(_v0._1)]));} + _U.badCase($moduleName, + "on line 34, column 3 to 55"); + }(); + }; + var viewAttributes = _L.fromArray([$Html$Attributes.style(_L.fromArray([{ctor: "_Tuple2" + ,_0: "overflow-y" + ,_1: "auto"} + ,{ctor: "_Tuple2" + ,_0: "overflow-x" + ,_1: "hidden"} + ,{ctor: "_Tuple2" + ,_0: "height" + ,_1: "100%"} + ,{ctor: "_Tuple2" + ,_0: "padding" + ,_1: "0 20px"}]))]); + var view = function (watches) { + return $Html.div(viewAttributes)(function () { + switch (watches.ctor) + {case "[]": + return _L.fromArray([noWatches]);} + return A2($List.map, + viewWatch, + watches); + }()); + }; + _elm.SideBar.Watches.values = {_op: _op + ,view: view + ,viewAttributes: viewAttributes + ,viewWatch: viewWatch + ,watchAttributes: watchAttributes + ,viewName: viewName + ,nameAttributes: nameAttributes + ,viewValue: viewValue + ,valueAttributes: valueAttributes + ,noWatches: noWatches}; + return _elm.SideBar.Watches.values; +}; +Elm.Signal = Elm.Signal || {}; +Elm.Signal.make = function (_elm) { + "use strict"; + _elm.Signal = _elm.Signal || {}; + if (_elm.Signal.values) + return _elm.Signal.values; + var _op = {}, + _N = Elm.Native, + _U = _N.Utils.make(_elm), + _L = _N.List.make(_elm), + _P = _N.Ports.make(_elm), + $moduleName = "Signal", + $Basics = Elm.Basics.make(_elm), + $List = Elm.List.make(_elm), + $Native$Signal = Elm.Native.Signal.make(_elm); + var subscribe = $Native$Signal.subscribe; + var send = $Native$Signal.send; + var channel = $Native$Signal.input; + var Message = {ctor: "Message"}; + var Channel = {ctor: "Channel"}; + _op["~"] = F2(function (sf,s) { + return A3($Native$Signal.map2, + F2(function (f,x) { + return f(x); + }), + sf, + s); + }); + _op["<~"] = F2(function (f,s) { + return A2($Native$Signal.map, + f, + s); + }); + var sampleOn = $Native$Signal.sampleOn; + var dropRepeats = $Native$Signal.dropRepeats; + var dropIf = $Native$Signal.dropIf; + var keepIf = $Native$Signal.keepIf; + var keepWhen = F3(function (bs, + def, + sig) { + return A2(_op["<~"], + $Basics.snd, + A3(keepIf, + $Basics.fst, + {ctor: "_Tuple2" + ,_0: false + ,_1: def}, + A2(_op["~"], + A2(_op["<~"], + F2(function (v0,v1) { + return {ctor: "_Tuple2" + ,_0: v0 + ,_1: v1}; + }), + A2(sampleOn,sig,bs)), + sig))); + }); + var dropWhen = function (bs) { + return keepWhen(A2(_op["<~"], + $Basics.not, + bs)); + }; + var merge = $Native$Signal.merge; + var mergeMany = function (signals) { + return A2($List.foldr1, + merge, + signals); + }; + var foldp = $Native$Signal.foldp; + var map5 = $Native$Signal.map5; + var map4 = $Native$Signal.map4; + var map3 = $Native$Signal.map3; + var map2 = $Native$Signal.map2; + var map = $Native$Signal.map; + var constant = $Native$Signal.constant; + var Signal = {ctor: "Signal"}; + _elm.Signal.values = {_op: _op + ,Signal: Signal + ,constant: constant + ,map: map + ,map2: map2 + ,map3: map3 + ,map4: map4 + ,map5: map5 + ,foldp: foldp + ,merge: merge + ,mergeMany: mergeMany + ,keepIf: keepIf + ,dropIf: dropIf + ,keepWhen: keepWhen + ,dropWhen: dropWhen + ,dropRepeats: dropRepeats + ,sampleOn: sampleOn + ,Channel: Channel + ,Message: Message + ,channel: channel + ,send: send + ,subscribe: subscribe}; + return _elm.Signal.values; +}; +Elm.Slider = Elm.Slider || {}; +Elm.Slider.make = function (_elm) { + "use strict"; + _elm.Slider = _elm.Slider || {}; + if (_elm.Slider.values) + return _elm.Slider.values; + var _op = {}, + _N = Elm.Native, + _U = _N.Utils.make(_elm), + _L = _N.List.make(_elm), + _P = _N.Ports.make(_elm), + $moduleName = "Slider", + $Graphics$Element = Elm.Graphics.Element.make(_elm), + $Native$Slider = Elm.Native.Slider.make(_elm), + $Signal = Elm.Signal.make(_elm); + var slider = $Native$Slider.slider; + var defaultSlider = {_: {} + ,disabled: false + ,horizontal: true + ,length: 100 + ,max: 100 + ,min: 0 + ,step: 1 + ,value: 0}; + var SliderStyle = F7(function (a, + b, + c, + d, + e, + f, + g) { + return {_: {} + ,disabled: b + ,horizontal: a + ,length: c + ,max: e + ,min: d + ,step: f + ,value: g}; + }); + _elm.Slider.values = {_op: _op + ,SliderStyle: SliderStyle + ,defaultSlider: defaultSlider + ,slider: slider}; + return _elm.Slider.values; +}; +Elm.String = Elm.String || {}; +Elm.String.make = function (_elm) { + "use strict"; + _elm.String = _elm.String || {}; + if (_elm.String.values) + return _elm.String.values; + var _op = {}, + _N = Elm.Native, + _U = _N.Utils.make(_elm), + _L = _N.List.make(_elm), + _P = _N.Ports.make(_elm), + $moduleName = "String", + $Maybe = Elm.Maybe.make(_elm), + $Native$String = Elm.Native.String.make(_elm), + $Result = Elm.Result.make(_elm); + var fromList = $Native$String.fromList; + var toList = $Native$String.toList; + var toFloat = $Native$String.toFloat; + var toInt = $Native$String.toInt; + var indices = $Native$String.indexes; + var indexes = $Native$String.indexes; + var endsWith = $Native$String.endsWith; + var startsWith = $Native$String.startsWith; + var contains = $Native$String.contains; + var all = $Native$String.all; + var any = $Native$String.any; + var toLower = $Native$String.toLower; + var toUpper = $Native$String.toUpper; + var lines = $Native$String.lines; + var words = $Native$String.words; + var trimRight = $Native$String.trimRight; + var trimLeft = $Native$String.trimLeft; + var trim = $Native$String.trim; + var padRight = $Native$String.padRight; + var padLeft = $Native$String.padLeft; + var pad = $Native$String.pad; + var dropRight = $Native$String.dropRight; + var dropLeft = $Native$String.dropLeft; + var right = $Native$String.right; + var left = $Native$String.left; + var slice = $Native$String.slice; + var repeat = $Native$String.repeat; + var join = $Native$String.join; + var split = $Native$String.split; + var foldr = $Native$String.foldr; + var foldl = $Native$String.foldl; + var reverse = $Native$String.reverse; + var filter = $Native$String.filter; + var map = $Native$String.map; + var length = $Native$String.length; + var concat = $Native$String.concat; + var append = $Native$String.append; + var uncons = $Native$String.uncons; + var cons = $Native$String.cons; + var fromChar = function ($char) { + return A2(cons,$char,""); + }; + var isEmpty = $Native$String.isEmpty; + _elm.String.values = {_op: _op + ,isEmpty: isEmpty + ,cons: cons + ,fromChar: fromChar + ,uncons: uncons + ,append: append + ,concat: concat + ,length: length + ,map: map + ,filter: filter + ,reverse: reverse + ,foldl: foldl + ,foldr: foldr + ,split: split + ,join: join + ,repeat: repeat + ,slice: slice + ,left: left + ,right: right + ,dropLeft: dropLeft + ,dropRight: dropRight + ,pad: pad + ,padLeft: padLeft + ,padRight: padRight + ,trim: trim + ,trimLeft: trimLeft + ,trimRight: trimRight + ,words: words + ,lines: lines + ,toUpper: toUpper + ,toLower: toLower + ,any: any + ,all: all + ,contains: contains + ,startsWith: startsWith + ,endsWith: endsWith + ,indexes: indexes + ,indices: indices + ,toInt: toInt + ,toFloat: toFloat + ,toList: toList + ,fromList: fromList}; + return _elm.String.values; +}; +Elm.Text = Elm.Text || {}; +Elm.Text.make = function (_elm) { + "use strict"; + _elm.Text = _elm.Text || {}; + if (_elm.Text.values) + return _elm.Text.values; + var _op = {}, + _N = Elm.Native, + _U = _N.Utils.make(_elm), + _L = _N.List.make(_elm), + _P = _N.Ports.make(_elm), + $moduleName = "Text", + $Basics = Elm.Basics.make(_elm), + $Color = Elm.Color.make(_elm), + $Graphics$Element = Elm.Graphics.Element.make(_elm), + $List = Elm.List.make(_elm), + $Maybe = Elm.Maybe.make(_elm), + $Native$Text = Elm.Native.Text.make(_elm); + var markdown = $Native$Text.markdown; + var justified = $Native$Text.justified; + var centered = $Native$Text.centered; + var rightAligned = $Native$Text.rightAligned; + var leftAligned = $Native$Text.leftAligned; + var line = $Native$Text.line; + var italic = $Native$Text.italic; + var bold = $Native$Text.bold; + var color = $Native$Text.color; + var height = $Native$Text.height; + var link = $Native$Text.link; + var monospace = $Native$Text.monospace; + var typeface = $Native$Text.typeface; + var style = $Native$Text.style; + var append = $Native$Text.append; + var fromString = $Native$Text.fromString; + var empty = fromString(""); + var concat = function (texts) { + return A3($List.foldr, + append, + empty, + texts); + }; + var join = F2(function (seperator, + texts) { + return concat(A2($List.intersperse, + seperator, + texts)); + }); + var plainText = function (str) { + return leftAligned(fromString(str)); + }; + var asText = function (value) { + return leftAligned(monospace(fromString($Basics.toString(value)))); + }; + var defaultStyle = {_: {} + ,bold: false + ,color: $Color.black + ,height: $Maybe.Nothing + ,italic: false + ,line: $Maybe.Nothing + ,typeface: _L.fromArray([])}; + var Style = F6(function (a, + b, + c, + d, + e, + f) { + return {_: {} + ,bold: d + ,color: c + ,height: b + ,italic: e + ,line: f + ,typeface: a}; + }); + var Through = {ctor: "Through"}; + var Over = {ctor: "Over"}; + var Under = {ctor: "Under"}; + var Text = {ctor: "Text"}; + _elm.Text.values = {_op: _op + ,Text: Text + ,Under: Under + ,Over: Over + ,Through: Through + ,Style: Style + ,defaultStyle: defaultStyle + ,fromString: fromString + ,empty: empty + ,append: append + ,concat: concat + ,join: join + ,style: style + ,typeface: typeface + ,monospace: monospace + ,link: link + ,height: height + ,color: color + ,bold: bold + ,italic: italic + ,line: line + ,leftAligned: leftAligned + ,rightAligned: rightAligned + ,centered: centered + ,justified: justified + ,plainText: plainText + ,markdown: markdown + ,asText: asText}; + return _elm.Text.values; +}; +Elm.Transform2D = Elm.Transform2D || {}; +Elm.Transform2D.make = function (_elm) { + "use strict"; + _elm.Transform2D = _elm.Transform2D || {}; + if (_elm.Transform2D.values) + return _elm.Transform2D.values; + var _op = {}, + _N = Elm.Native, + _U = _N.Utils.make(_elm), + _L = _N.List.make(_elm), + _P = _N.Ports.make(_elm), + $moduleName = "Transform2D", + $Native$Transform2D = Elm.Native.Transform2D.make(_elm); + var multiply = $Native$Transform2D.multiply; + var rotation = $Native$Transform2D.rotation; + var matrix = $Native$Transform2D.matrix; + var translation = F2(function (x, + y) { + return A6(matrix, + 1, + 0, + 0, + 1, + x, + y); + }); + var scale = function (s) { + return A6(matrix, + s, + 0, + 0, + s, + 0, + 0); + }; + var scaleX = function (x) { + return A6(matrix, + x, + 0, + 0, + 1, + 0, + 0); + }; + var scaleY = function (y) { + return A6(matrix, + 1, + 0, + 0, + y, + 0, + 0); + }; + var identity = $Native$Transform2D.identity; + var Transform2D = {ctor: "Transform2D"}; + _elm.Transform2D.values = {_op: _op + ,identity: identity + ,matrix: matrix + ,multiply: multiply + ,rotation: rotation + ,translation: translation + ,scale: scale + ,scaleX: scaleX + ,scaleY: scaleY}; + return _elm.Transform2D.values; +}; +Elm.VirtualDom = Elm.VirtualDom || {}; +Elm.VirtualDom.make = function (_elm) { + "use strict"; + _elm.VirtualDom = _elm.VirtualDom || {}; + if (_elm.VirtualDom.values) + return _elm.VirtualDom.values; + var _op = {}, + _N = Elm.Native, + _U = _N.Utils.make(_elm), + _L = _N.List.make(_elm), + _P = _N.Ports.make(_elm), + $moduleName = "VirtualDom", + $Graphics$Element = Elm.Graphics.Element.make(_elm), + $Json$Decode = Elm.Json.Decode.make(_elm), + $Native$VirtualDom = Elm.Native.VirtualDom.make(_elm), + $Signal = Elm.Signal.make(_elm); + var lazy3 = $Native$VirtualDom.lazy3; + var lazy2 = $Native$VirtualDom.lazy2; + var lazy = $Native$VirtualDom.lazy; + var on = $Native$VirtualDom.on; + var property = $Native$VirtualDom.property; + var Property = {ctor: "Property"}; + var fromElement = $Native$VirtualDom.fromElement; + var toElement = $Native$VirtualDom.toElement; + var text = $Native$VirtualDom.text; + var node = $Native$VirtualDom.node; + var Node = {ctor: "Node"}; + _elm.VirtualDom.values = {_op: _op + ,Node: Node + ,node: node + ,text: text + ,toElement: toElement + ,fromElement: fromElement + ,Property: Property + ,property: property + ,on: on + ,lazy: lazy + ,lazy2: lazy2 + ,lazy3: lazy3}; + return _elm.VirtualDom.values; +}; +Elm.Window = Elm.Window || {}; +Elm.Window.make = function (_elm) { + "use strict"; + _elm.Window = _elm.Window || {}; + if (_elm.Window.values) + return _elm.Window.values; + var _op = {}, + _N = Elm.Native, + _U = _N.Utils.make(_elm), + _L = _N.List.make(_elm), + _P = _N.Ports.make(_elm), + $moduleName = "Window", + $Native$Window = Elm.Native.Window.make(_elm), + $Signal = Elm.Signal.make(_elm); + var height = $Native$Window.height; + var width = $Native$Window.width; + var dimensions = $Native$Window.dimensions; + _elm.Window.values = {_op: _op + ,dimensions: dimensions + ,width: width + ,height: height}; + return _elm.Window.values; +}; +(function() { +'use strict'; + +function assert(bool, msg) { + if (!bool) { + throw new Error("Assertion error: " + msg); + } +} + + +// SIDE BAR + +var SIDE_BAR_ID = "elm-reactor-side-bar"; +var SIDE_BAR_BODY_ID = "elm-reactor-side-bar-body"; +var SIDE_BAR_WIDTH = 275; + +var DARK_GREY = "#4A4A4A"; +var LIGHT_GREY = "#E4E4E4"; + +function createSideBar() { + var debuggingPanelExpanded = true; + + var sideBar = document.createElement("div"); + sideBar.id = SIDE_BAR_ID; + + var sideBarBody = document.createElement("div"); + sideBarBody.id = SIDE_BAR_BODY_ID; + sideBarBody.style.overflow = "hidden"; + sideBarBody.style.height = "100%"; + + // Create and style the panel + sideBar.style.background = DARK_GREY; + sideBar.style.width = SIDE_BAR_WIDTH + "px"; + sideBar.style.height = "100%"; + sideBar.style.position = "absolute"; + sideBar.style.top = "0px"; + sideBar.style.right = "0px"; + sideBar.style.transitionDuration = "0.3s"; + sideBar.style.opacity = 0.97; + sideBar.style.zIndex = 1; + + // Prevent clicks from reaching the main elm instance under the panel + sideBar.addEventListener("click", blockClicks); + function blockClicks(e) { + var event = e || window.event; + event.cancelBubble = true; + if (event.stopPropagation) { + event.stopPropagation(); + } + } + + // Create and style the button + var tabWidth = 25; + var sideBarTab = document.createElement("div"); + sideBarTab.id = "debugToggle"; + sideBarTab.style.position = "absolute"; + sideBarTab.style.width = tabWidth + "px"; + sideBarTab.style.height = "60px"; + sideBarTab.style.top = "50%"; + sideBarTab.style.left = "-" + tabWidth + "px"; + sideBarTab.style.borderTopLeftRadius = "3px"; + sideBarTab.style.borderBottomLeftRadius = "3px"; + sideBarTab.style.background = DARK_GREY; + + + // Wire the button + sideBarTab.onclick = function() { + var toolPanel = document.getElementById(SIDE_BAR_ID); + if (debuggingPanelExpanded){ + toolPanel.style.width = "0px"; + debuggingPanelExpanded = false; + } else { + toolPanel.style.right = "0px"; + toolPanel.style.width = SIDE_BAR_WIDTH + "px"; + debuggingPanelExpanded = true; + } + }; + + sideBar.appendChild(sideBarTab); + sideBar.appendChild(sideBarBody); + return sideBar; +} + + +// ERROR MESSAGE + +var ERROR_MESSAGE_ID = 'elm-reactor-error-message'; + +function initErrorMessage(message) { + var node = document.createElement("pre"); + node.id = ERROR_MESSAGE_ID; + node.innerHTML = message; + node.style.zindex = 1; + node.style.position = "absolute"; + node.style.top = "0"; + node.style.left = "0"; + node.style.color = DARK_GREY; + node.style.backgroundColor = LIGHT_GREY; + node.style.padding = "1em"; + node.style.margin = "1em"; + node.style.borderRadius = "10px"; + return node; +} + + +// EVENT BLOCKER + +var EVENT_BLOCKER_ID = 'elm-reactor-event-blocker' + +var eventsToIgnore = [ + "click", "mousemove", "mouseup", "mousedown", "mouseclick", "keydown", + "keypress", "keyup", "touchstart", "touchend", "touchcancel", "touchleave", + "touchmove", "pointermove", "pointerdown", "pointerup", "pointerover", + "pointerout", "pointerenter", "pointerleave", "pointercancel" +]; + +function ignore(e) { + var event = e || window.event; + if (event.stopPropagation) { + event.stopPropagation(); + } + if (event.cancelBubble !== null) { + event.cancelBubble = true; + } + if (event.preventDefault) { + event.preventDefault(); + } + return false; +} + +function initEventBlocker() { + var node = document.createElement("div"); + node.id = EVENT_BLOCKER_ID; + node.style.position = "absolute"; + node.style.top = "0px"; + node.style.left = "0px"; + node.style.width = "100%"; + node.style.height = "100%"; + + for (var i = eventsToIgnore.length; i-- ;) { + node.addEventListener(eventsToIgnore[i], ignore, true); + } + + return node; +} + +function addEventBlocker(node) { + if (!document.getElementById(EVENT_BLOCKER_ID)) { + node.appendChild(initEventBlocker()); + } +} + +function removeEventBlocker() { + var blocker = document.getElementById(EVENT_BLOCKER_ID); + if (blocker) + { + blocker.parentNode.removeChild(blocker); + } +} + + + +// CODE TO SET UP A MODULE FOR DEBUGGING + +Elm.fullscreenDebug = function(moduleName, fileName) { + var result = initModuleWithDebugState(moduleName); + + document.body.appendChild(createSideBar()); + + var sideBar = Elm.embed(Elm.SideBar, document.getElementById(SIDE_BAR_BODY_ID), { + eventCounter: 0, + watches: [], + showSwap: true + }); + + function updateWatches(index) + { + sideBar.ports.watches.send(watchesAt(index, result.debugState)); + } + + sideBar.ports.scrubTo.subscribe(function(index) { + jumpTo(index, result.debugState); + updateWatches(index); + }); + + sideBar.ports.pause.subscribe(function(paused) { + if (paused) { + pause(result.debugState); + } else { + unpause(result.debugState); + redoTraces(result.debugState); + } + }); + + sideBar.ports.restart.subscribe(function() { + restart(result.debugState); + updateWatches(0); + }); + + sideBar.ports.permitSwap.subscribe(function(permitSwaps) { + result.debugState.permitSwaps = permitSwaps; + }); + + result.debugState.onNotify = function(debugState) { + sideBar.ports.eventCounter.send(debugState.index); + updateWatches(debugState.index); + }; + + // handle swaps + var updates = 'ws://' + window.location.host + '/socket?file=' + fileName + var connection = new WebSocket(updates); + connection.addEventListener('message', function(event) { + if (result.debugState.permitSwaps) + { + result = swap(event.data, result.debugState, result.module.dispose); + updateWatches(result.debugState.index); + } + }); + window.addEventListener("unload", function() { + connection.close(); + }); + + return result.module; +}; + + +function initModuleWithDebugState(moduleName) { + var debugState; + + function make(localRuntime) { + var result = initAndWrap(getModule(moduleName), localRuntime); + debugState = result.debugState; + return result.values; + } + + return { + module: Elm.fullscreen({ make: make }), + debugState: debugState + }; +} + +function getModule(moduleName) +{ + var elmModule = Elm; + var names = moduleName.split('.'); + for (var i = 0; i < names.length; ++i) + { + elmModule = elmModule[names[i]]; + } + return elmModule; +} + + +// DEBUG STATE + +function emptyDebugState() +{ + return { + paused: false, + pausedAtTime: 0, + totalTimeLost: 0, + + index: 0, + events: [], + watches: [{}], + snapshots: [], + asyncCallbacks: [], + + initialSnapshot: [], + initialAsyncCallbacks: [], + signalGraphNodes: [], + + traces: {}, + traceCanvas: createCanvas(), + + permitSwaps: true, + swapInProgress: false, + + onNotify: function() {}, + refreshScreen: function() {}, + node: null, + notify: function() {} + }; +} + +function restart(debugState) +{ + var running = !debugState.paused; + if (running) + { + pause(debugState); + } + debugState.index = 0; + debugState.events = []; + debugState.watches = [debugState.watches[0]]; + + var snap = debugState.initialSnapshot; + debugState.snapshots = [snap]; + for (var i = snap.length; i--; ) + { + debugState.signalGraphNodes[i].value = snap[i].value; + } + + debugState.asyncCallbacks = debugState.initialAsyncCallbacks.map(function(thunk) { + return { + thunk: thunk, + id: 0, + executed: false + }; + }); + + debugState.traces = {}; + redoTraces(debugState); + debugState.refreshScreen(); + + if (running) + { + unpause(debugState); + } +} + +function pause(debugState) +{ + if (debugState.paused) + { + return; + } + debugState.paused = true; + pauseAsyncCallbacks(debugState); + debugState.pausedAtTime = Date.now(); + addEventBlocker(debugState.node); +} + +function unpause(debugState) +{ + debugState.paused = false; + + // add delay due to the pause itself + var pauseDelay = Date.now() - debugState.pausedAtTime; + debugState.totalTimeLost += pauseDelay; + + // add delay if travelling to older event + if (debugState.index < debugState.events.length - 1) + { + debugState.totalTimeLost = Date.now() - debugState.events[debugState.index].time; + } + + // clear out future snapshots, events, and traces + var nearestSnapshotIndex = Math.floor(debugState.index / EVENTS_PER_SAVE); + debugState.snapshots = debugState.snapshots.slice(0, nearestSnapshotIndex + 1); + debugState.events = debugState.events.slice(0, debugState.index); + clearTracesAfter(debugState.index, debugState); + clearWatchesAfter(debugState.index, debugState); + + unpauseAsyncCallbacks(debugState.asyncCallbacks); + + removeEventBlocker(); +} + +function jumpTo(index, debugState) +{ + if (!debugState.paused) + { + pause(debugState); + } + + assert( + 0 <= index && index <= debugState.events.length, + "Trying to step to non-existent event index " + index); + + var potentialIndex = indexOfSnapshotBefore(index); + if (index < debugState.index || potentialIndex > debugState.index) + { + var snapshot = getNearestSnapshot(index, debugState.snapshots); + + for (var i = debugState.signalGraphNodes.length; i-- ; ) + { + debugState.signalGraphNodes[i].value = snapshot[i].value; + } + + debugState.index = potentialIndex; + } + + while (debugState.index < index) + { + var event = debugState.events[debugState.index]; + debugState.notify(event.id, event.value, event.time); + debugState.index += 1; + } + redoTraces(debugState); +} + +function swap(rawJsonResponse, debugState, freeOldRuntime) { + var error = document.getElementById(ERROR_MESSAGE_ID); + if (error) + { + error.parentNode.removeChild(error); + } + + var result = JSON.parse(rawJsonResponse); + + if (!result.code) + { + var msg = result.error || 'something went wrong with swap'; + document.body.appendChild(initErrorMessage(msg)); + return null; + } + // TODO: pause/unpause? + pauseAsyncCallbacks(debugState); + window.eval(result.code); + + // remove old nodes + debugState.node.parentNode.removeChild(debugState.node); + document.body.removeChild(debugState.traceCanvas); + freeOldRuntime(); + + var result = initModuleWithDebugState(result.name); + transferState(debugState, result.debugState); + return result; +} + +function transferState(previousDebugState, debugState) +{ + debugState.swapInProgress = true; + debugState.events = previousDebugState.events; + debugState.onNotify = previousDebugState.onNotify; + + if (previousDebugState.paused) + { + debugState.paused = true; + pauseAsyncCallbacks(debugState); + debugState.pausedAtTime = previousDebugState.pausedAtTime; + debugState.totalTimeLost = previousDebugState.totalTimeLost; + addEventBlocker(debugState.node); + } + + while (debugState.index < debugState.events.length) + { + var event = debugState.events[debugState.index]; + debugState.index += 1; + pushWatchFrame(debugState); + + debugState.notify(event.id, event.value, event.time); + snapshotIfNeeded(debugState); + } + redoTraces(debugState); + debugState.swapInProgress = false; + + jumpTo(previousDebugState.index, debugState); +} + + +// CALLBACKS + +// TODO: is it weird that the callbacks array never shrinks? + +function unpauseAsyncCallbacks(callbacks) { + callbacks.forEach(function(callback) { + if (!callback.executed) { + callback.executed = true; + callback.thunk(); + } + }); +} + +function pauseAsyncCallbacks(debugState) { + debugState.asyncCallbacks.forEach(function(callback) { + if (!callback.executed) { + clearTimeout(callback.id); + } + }); +} + + + +// TRACES + +function clearTracesAfter(index, debugState) +{ + var newTraces = {}; + for (var id in debugState.traces) + { + var trace = debugState.traces[id]; + for (var i = trace.length; i--; ) + { + if (trace[i].index < index) + { + newTraces[id] = debugState.traces[id].slice(0, i + 1); + break; + } + } + } + debugState.traces = newTraces; +} + +function createCanvas() { + var canvas = document.createElement('canvas'); + // TODO: make dimensions adjust based on screen size + canvas.width = window.innerWidth; + canvas.height = window.innerHeight; + canvas.style.position = "absolute"; + canvas.style.top = "0"; + canvas.style.left = "0"; + canvas.style.pointerEvents = "none"; + return canvas; +} + +function addTraces(debugState) +{ + var ctx = debugState.traceCanvas.getContext('2d'); + + ctx.save(); + for (var id in debugState.traces) + { + var points = debugState.traces[id]; + if (points.length < 2) + { + continue; + } + var lastTracePoint = points[points.length - 1]; + if (lastTracePoint.index < debugState.index - 1) + { + continue; + } + ctx.beginPath(); + ctx.moveTo(lastTracePoint.x, lastTracePoint.y); + var secondToLastTracePoint = points[points.length - 2]; + ctx.lineTo(secondToLastTracePoint.x, secondToLastTracePoint.y); + + ctx.lineWidth = 1; + ctx.strokeStyle = "rgba(50, 50, 50, 0.4)"; + ctx.stroke(); + } + ctx.restore(); +} + +function redoTraces(debugState) { + var ctx = debugState.traceCanvas.getContext('2d'); + + // TODO: be more clever about the size of the canvas on resize + ctx.clearRect(0, 0, debugState.traceCanvas.width, debugState.traceCanvas.height); + + ctx.save(); + for (var id in debugState.traces) + { + var points = debugState.traces[id]; + var length = points.length; + if (length < 2) + { + continue; + } + ctx.beginPath(); + ctx.lineWidth = 1; + ctx.moveTo(points[0].x, points[0].y); + var currentIndex = debugState.index; + var traceIndex = points[0].index; + for (var i = 1; traceIndex < currentIndex && i < length; ++i) + { + var point = points[i]; + ctx.lineTo(point.x, point.y); + traceIndex = point.index; + } + ctx.strokeStyle = "rgba(50, 50, 50, 0.4)"; + ctx.stroke(); + + for (; i < length; ++i) + { + var point = points[i]; + ctx.lineTo(point.x, point.y); + traceIndex = point.index; + } + ctx.strokeStyle = "rgba(50, 50, 50, 0.2)"; + ctx.stroke(); + } + ctx.restore(); +} + +function makeTraceRecorder(debugState, runtime) +{ + var List = Elm.List.make(runtime); + var Transform = Elm.Transform2D.make(runtime); + + function crawlElement(element) + { + if (debugState.paused && !debugState.swapInProgress) + { + return; + } + + var e = element.element; + if (!e) + { + return; + } + if (e.ctor === 'Custom' && e.type === 'Collage') + { + var w = element.props.width; + var h = element.props.height; + var identity = A6( Transform.matrix, 1, 0, 0, -1, w/2, h/2 ); + return A2(List.map, crawlForm(identity), e.model.forms); + } + } + + function crawlForm(matrix) + { + return function(form) { + if (form.form.ctor == "FGroup") + { + var scale = form.scale; + var localMatrix = A6( Transform.matrix, scale, 0, 0, scale, form.x, form.y ); + + var theta = form.theta + if (theta !== 0) + { + localMatrix = A2( Transform.multiply, localMatrix, Transform.rotation(theta) ); + } + + var newMatrix = A2( Transform.multiply, matrix, localMatrix ); + A2(List.map, crawlForm(newMatrix), form.form._1); + } + + var tag = form.trace; + if (!tag) + { + return; + } + + var x = matrix[0] * form.x + matrix[1] * form.y + matrix[2]; + var y = matrix[3] * form.x + matrix[4] * form.y + matrix[5]; + + if ( !(tag in debugState.traces) ) + { + debugState.traces[tag] = [{ index: debugState.index, x: x, y: y }]; + return; + } + + var trace = debugState.traces[tag]; + var lastPoint = trace[trace.length - 1]; + if (lastPoint.x === x && lastPoint.y === y) + { + return; + } + trace.push({ index: debugState.index, x: x, y: y }); + } + } + + return crawlElement; +} + + +// SNAPSHOTS + +var EVENTS_PER_SAVE = 100; + +function snapshotIfNeeded(debugState) +{ + if (debugState.index % EVENTS_PER_SAVE === 0) + { + debugState.snapshots.push(createSnapshot(debugState.signalGraphNodes)); + } +} + +function indexOfSnapshotBefore(index) +{ + return Math.floor(index / EVENTS_PER_SAVE) * EVENTS_PER_SAVE; +} + +function getNearestSnapshot(i, snapshots) +{ + var snapshotIndex = Math.floor(i / EVENTS_PER_SAVE); + assert( + snapshotIndex < snapshots.length && snapshotIndex >= 0, + "Trying to access non-existent snapshot (event " + i + ", snapshot " + snapshotIndex + ")"); + return snapshots[snapshotIndex]; +} + +function createSnapshot(signalGraphNodes) +{ + var nodeValues = []; + + signalGraphNodes.forEach(function(node) { + nodeValues.push({ value: node.value, id: node.id }); + }); + + return nodeValues; +} + +function flattenSignalGraph(nodes) +{ + var nodesById = {}; + + function addAllToDict(node) { + nodesById[node.id] = node; + node.kids.forEach(addAllToDict); + } + nodes.forEach(addAllToDict); + + var allNodes = Object.keys(nodesById).sort(compareNumbers).map(function(key) { + return nodesById[key]; + }); + return allNodes; +} + +function compareNumbers(a, b) { + return a - b; +} + + +// WRAP THE RUNTIME + +function initAndWrap(elmModule, runtime) +{ + var debugState = emptyDebugState(); + + // runtime is the prototype of wrappedRuntime + // so we can access all runtime properties too + var wrappedRuntime = Object.create(runtime); + wrappedRuntime.notify = notifyWrapper; + wrappedRuntime.setTimeout = setTimeoutWrapper; + + // make a copy of the wrappedRuntime + var assignedPropTracker = Object.create(wrappedRuntime); + var values = elmModule.make(assignedPropTracker); + + // make sure the signal graph is actually a signal & extract the visual model + var Signal = Elm.Signal.make(assignedPropTracker); + if ( !('recv' in values.main) ) + { + values.main = Signal.constant(values.main); + } + A2(Signal.map, makeTraceRecorder(debugState, assignedPropTracker), values.main); + + debugState.refreshScreen = function() { + var main = values.main + for (var i = main.kids.length ; i-- ; ) + { + main.kids[i].recv(runtime.timer.now(), true, main.id); + } + }; + + // The main module stores imported modules onto the runtime. + // To ensure only one instance of each module is created, + // we assign them back on the original runtime object. + Object.keys(assignedPropTracker).forEach(function(key) { + runtime[key] = assignedPropTracker[key]; + }); + + debugState.signalGraphNodes = flattenSignalGraph(wrappedRuntime.inputs); + debugState.initialSnapshot = createSnapshot(debugState.signalGraphNodes); + debugState.snapshots = [debugState.initialSnapshot]; + debugState.initialAsyncCallbacks = debugState.asyncCallbacks.map(function(callback) { + return callback.thunk; + }); + debugState.node = runtime.node; + debugState.notify = runtime.notify; + + // Tracing stuff + document.body.appendChild(debugState.traceCanvas); + + var replace = Elm.Native.Utils.make(assignedPropTracker).replace; + + runtime.timer.now = function() { + return Date.now() - debugState.totalTimeLost; + }; + + runtime.debug = {}; + + runtime.debug.trace = function(tag, form) { + return replace([['trace', tag]], form); + } + + runtime.debug.watch = function(tag, value) { + if (debugState.paused && !debugState.swapInProgress) + { + return; + } + var index = debugState.index; + var numWatches = debugState.watches.length - 1; + assert( + index === numWatches, + 'number of watch frames (' + numWatches + ') should match current index (' + index + ')'); + debugState.watches[debugState.index][tag] = value; + } + + function notifyWrapper(id, value) + { + // Ignore all events that occur while the program is paused. + if (debugState.paused) + { + return false; + } + + // Record the event + debugState.events.push({ id: id, value: value, time: runtime.timer.now() }); + debugState.index += 1; + pushWatchFrame(debugState); + + var changed = runtime.notify(id, value); + + snapshotIfNeeded(debugState); + debugState.onNotify(debugState); + addTraces(debugState); + + return changed; + } + + function setTimeoutWrapper(thunk, delay) + { + if (debugState.paused) + { + return 0; + } + + var callback = { + thunk: thunk, + id: 0, + executed: false + }; + + callback.id = setTimeout(function() { + callback.executed = true; + thunk(); + }, delay); + + debugState.asyncCallbacks.push(callback); + return callback.id; + } + + return { + values: values, + debugState: debugState + }; +} + + +// WATCHES + +function watchesAt(index, debugState) +{ + var watchSnapshot = []; + var watches = debugState.watches[index]; + + for (var name in watches) + { + var value = prettyPrint(watches[name], " "); + watchSnapshot.push([ name, value ]); + } + return watchSnapshot; +} + +function pushWatchFrame(debugState) +{ + var length = debugState.watches.length; + var oldFrame = length === 0 ? {} : debugState.watches[length - 1]; + var newFrame = {}; + for (var tag in oldFrame) + { + newFrame[tag] = oldFrame[tag]; + } + debugState.watches.push(newFrame); +} + +function clearWatchesAfter(index, debugState) +{ + debugState.watches = debugState.watches.slice(0, index + 1); +} + +var prettyPrint = function() { + + var independentRuntime = {}; + var List; + var ElmArray; + var Dict; + + var toString = function(v, separator) { + var type = typeof v; + if (type === "function") { + var name = v.func ? v.func.name : v.name; + return '
\n`watch : String -> a -> a`\n\n\nUse [Debug.watchSummary](http://package.elm-lang.org/packages/elm-lang/core/latest/Debug#watchSummary) to show a
\nsummary or subvalue of any value.
\n\n"); - var roundedSquare = F3(function (side, - radius, - toForm) { - return function () { - var formedCircle = toForm($Graphics$Collage.circle(radius)); - var shortSide = side - 2 * radius; - var xRect = toForm(A2($Graphics$Collage.rect, - side, - shortSide)); - var yRect = toForm(A2($Graphics$Collage.rect, - shortSide, - side)); - var circleOffset = shortSide / 2; - var tl = $Graphics$Collage.move({ctor: "_Tuple2" - ,_0: 0 - circleOffset - ,_1: circleOffset})(formedCircle); - var tr = $Graphics$Collage.move({ctor: "_Tuple2" - ,_0: circleOffset - ,_1: circleOffset})(formedCircle); - var bl = $Graphics$Collage.move({ctor: "_Tuple2" - ,_0: 0 - circleOffset - ,_1: 0 - circleOffset})(formedCircle); - var br = $Graphics$Collage.move({ctor: "_Tuple2" - ,_0: circleOffset - ,_1: 0 - circleOffset})(formedCircle); - return $Graphics$Collage.group(_L.fromArray([xRect - ,yRect - ,tl - ,tr - ,bl - ,br])); - }(); - }); - var startState = {_: {} - ,paused: false - ,scrubPosition: 0 - ,totalEvents: 0}; - var step = F2(function (update, - state) { - return function () { - switch (update.ctor) - {case "Pause": - return _U.replace([["paused" - ,update._0] - ,["totalEvents" - ,update._0 ? state.totalEvents : state.scrubPosition]], - state); - case "Restart": - return startState; - case "ScrubPosition": - return _U.replace([["scrubPosition" - ,update._0] - ,["paused",true]], - state); - case "TotalEvents": - return _U.replace([["totalEvents" - ,update._0] - ,["scrubPosition",update._0]], - state);} - _U.badCase($moduleName, - "between lines 289 and 310"); - }(); - }); - var showSwap = _P.portIn("showSwap", - function (v) { - return typeof v === "boolean" ? v : _U.badPort("a boolean (true or false)", - v); - }); - var watches = _P.portIn("watches", - _P.incomingSignal(function (v) { - return typeof v === "object" && v instanceof Array ? Elm.Native.List.make(_elm).fromArray(v.map(function (v) { - return typeof v === "object" && v instanceof Array ? {ctor: "_Tuple2" - ,_0: typeof v[0] === "string" || typeof v[0] === "object" && v[0] instanceof String ? v[0] : _U.badPort("a string", - v[0]) - ,_1: typeof v[1] === "string" || typeof v[1] === "object" && v[1] instanceof String ? v[1] : _U.badPort("a string", - v[1])} : _U.badPort("an array", - v); - })) : _U.badPort("an array",v); - })); - var eventCounter = _P.portIn("eventCounter", - _P.incomingSignal(function (v) { - return typeof v === "number" ? v : _U.badPort("a number", - v); - })); - var scrupChannel = $Signal.channel(0); - var restartChannel = $Signal.channel({ctor: "_Tuple0"}); - var permitSwapChannel = $Signal.channel(true); - var pausedInput = $Signal.channel(false); - var permitSwap = _P.portOut("permitSwap", - _P.outgoingSignal(function (v) { - return v; - }), - $Signal.subscribe(permitSwapChannel)); - var restart = _P.portOut("restart", - _P.outgoingSignal(function (v) { - return v; - }), - A2($Signal.map, - $Basics.always(0), - $Signal.subscribe(restartChannel))); - var scrubSlider = F2(function (_v4, - state) { - return function () { - switch (_v4.ctor) - {case "_Tuple2": - return function () { - var sliderLength = _v4._0; - var sliderStyle = _U.replace([["length" - ,sliderLength] - ,["max" - ,$Basics.toFloat(state.totalEvents)] - ,["value" - ,$Basics.toFloat(state.scrubPosition)]], - $Slider.defaultSlider); - return A3($Graphics$Element.container, - sliderLength, - 20, - $Graphics$Element.middle)(A2($Slider.slider, - function (n) { - return A2($Signal.send, - scrupChannel, - $Basics.round(n)); - }, - sliderStyle)); - }();} - _U.badCase($moduleName, - "between lines 127 and 136"); - }(); - }); - var myButton = F2(function (message, - name) { - return function () { - var img = function (state) { - return A3($Graphics$Element.image, - 40, - 40, - A2($Basics._op["++"], - "/_reactor/debugger/", - A2($Basics._op["++"], - name, - A2($Basics._op["++"], - "-button-", - A2($Basics._op["++"], - state, - ".png"))))); - }; - return A4($Graphics$Input.customButton, - message, - img("up"), - img("hover"), - img("down")); - }(); - }); - var playButton = A2(myButton, - A2($Signal.send, - pausedInput, - false), - "play"); - var pauseButton = A2(myButton, - A2($Signal.send, - pausedInput, - true), - "pause"); - var restartButton = A2(myButton, - A2($Signal.send, - restartChannel, - {ctor: "_Tuple0"}), - "restart"); - var darkGrey = A3($Color.rgb, - 74, - 74, - 74); - var lightGrey = A3($Color.rgb, - 228, - 228, - 228); - var dataStyle = F3(function (typefaces, - height, - string) { - return function () { - var myStyle = _U.replace([["typeface" - ,typefaces] - ,["color",lightGrey] - ,["height" - ,$Maybe.Just(height)]], - $Text.defaultStyle); - return A2($Text.style, - myStyle, - $Text.fromString(string)); - }(); - }); - var textStyle = A2(dataStyle, - _L.fromArray(["Gotham" - ,"Futura" - ,"Lucida Grande" - ,"sans-serif"]), - 12); - var watchStyle = A2(dataStyle, - _L.fromArray(["Gotham" - ,"Futura" - ,"Lucida Grande" - ,"sans-serif"]), - 14); - var codeStyle = A2(dataStyle, - _L.fromArray(["Menlo for Powerline" - ,"monospace"]), - 12); - var blue = A3($Color.rgb, - 28, - 129, - 218); - var swapButton = function (permitSwap) { - return function () { - var info = $Text.leftAligned(textStyle("swap")); - var radius = 4; - var hsWidth = 25; - var bgButton = A3(roundedSquare, - hsWidth, - radius, - $Graphics$Collage.filled(lightGrey)); - var trueButton = _L.fromArray([bgButton - ,A3(roundedSquare, - 22, - radius, - $Graphics$Collage.filled(blue))]); - var falseButtonClick = trueButton; - var trueButtonHover = _L.fromArray([bgButton - ,A3(roundedSquare, - 22, - radius, - $Graphics$Collage.filled(blue)) - ,$Graphics$Collage.alpha(0.1)(A3(roundedSquare, - 22, - radius, - $Graphics$Collage.filled(darkGrey)))]); - var falseButton = _L.fromArray([bgButton - ,A3(roundedSquare, - 22, - radius, - $Graphics$Collage.filled(darkGrey))]); - var trueButtonClick = falseButton; - var falseButtonHover = _L.fromArray([bgButton - ,A3(roundedSquare, - 22, - radius, - $Graphics$Collage.filled(darkGrey)) - ,$Graphics$Collage.alpha(0.1)(A3(roundedSquare, - 22, - radius, - $Graphics$Collage.filled(blue)))]); - var button = permitSwap ? A4($Graphics$Input.customButton, - A2($Signal.send, - permitSwapChannel, - false), - A3($Graphics$Collage.collage, - hsWidth, - hsWidth, - trueButton), - A3($Graphics$Collage.collage, - hsWidth, - hsWidth, - trueButtonHover), - A3($Graphics$Collage.collage, - hsWidth, - hsWidth, - trueButtonClick)) : A4($Graphics$Input.customButton, - A2($Signal.send, - permitSwapChannel, - true), - A3($Graphics$Collage.collage, - hsWidth, - hsWidth, - falseButton), - A3($Graphics$Collage.collage, - hsWidth, - hsWidth, - falseButtonHover), - A3($Graphics$Collage.collage, - hsWidth, - hsWidth, - falseButtonClick)); - return A2($Graphics$Element.flow, - $Graphics$Element.right, - _L.fromArray([info - ,A2($Graphics$Element.spacer, - 10, - 1) - ,button])); - }(); - }; - var panelWidth = 275; - var textHeight = 20; - var sliderMinMaxText = F2(function (w, - state) { - return function () { - var sliderTotalEvents = A3($Graphics$Element.container, - w, - textHeight, - $Graphics$Element.topRight)($Text.rightAligned(textStyle($Basics.toString(state.totalEvents)))); - var sliderStartText = A3($Graphics$Element.container, - w, - textHeight, - $Graphics$Element.topLeft)($Text.leftAligned(textStyle("0"))); - return A2($Graphics$Element.flow, - $Graphics$Element.outward, - _L.fromArray([sliderStartText - ,sliderTotalEvents])); - }(); - }); - var sideMargin = 2 * 20; - var sliderEventText = F2(function (w, - state) { - return function () { - var text$ = $Text.centered(textStyle($Basics.toString(state.scrubPosition))); - var yPos = $Graphics$Element.absolute($Basics.round(textHeight / 2)); - var totalEvents = $Basics.toFloat(state.totalEvents); - var scrubPosition = $Basics.toFloat(state.scrubPosition); - var textWidthOffset = 14; - var midWidth = $Basics.toFloat(w) - sideMargin - textWidthOffset; - var leftDistance = _U.eq(totalEvents, - 0) ? sideMargin / 2 + textWidthOffset / 2 : scrubPosition / totalEvents * midWidth + sideMargin / 2 + textWidthOffset / 2; - var xPos = $Graphics$Element.absolute($Basics.round(leftDistance)); - var textPosition = A2($Graphics$Element.middleAt, - xPos, - yPos); - return A4($Graphics$Element.container, - w, - textHeight, - textPosition, - text$); - }(); - }); - var buttonWidth = 40; - var buttonHeight = 40; - var view = F4(function (_v8, - watches, - permitSwap, - state) { - return function () { - switch (_v8.ctor) - {case "_Tuple2": - return function () { - var showWatch = function (_v12) { - return function () { - switch (_v12.ctor) - {case "_Tuple2": - return A2($Graphics$Element.flow, - $Graphics$Element.down, - _L.fromArray([$Graphics$Element.width(_v8._0)($Text.leftAligned($Text.bold(watchStyle(_v12._0)))) - ,$Graphics$Element.width(_v8._0)($Text.leftAligned(codeStyle(_v12._1))) - ,A2($Graphics$Element.spacer, - 1, - 12)]));} - _U.badCase($moduleName, - "between lines 212 and 216"); - }(); - }; - var watchView = A2($Graphics$Element.flow, - $Graphics$Element.right, - _L.fromArray([A2($Graphics$Element.spacer, - 20, - 1) - ,function () { - switch (watches.ctor) - {case "[]": return noWatches;} - return $Graphics$Element.flow($Graphics$Element.down)(A2($List.map, - showWatch, - watches)); - }()])); - var bar = A2($Graphics$Element.flow, - $Graphics$Element.down, - _L.fromArray([$Graphics$Element.opacity(0.3)($Graphics$Element.color(lightGrey)(A2($Graphics$Element.spacer, - _v8._0, - 1))) - ,A2($Graphics$Element.spacer, - _v8._0, - 12)])); - var fittedSwapButton = showSwap ? A3($Graphics$Element.container, - _v8._0 - 2 * buttonWidth - sideMargin, - buttonHeight, - $Graphics$Element.middle)(swapButton(permitSwap)) : A2($Graphics$Element.spacer, - 2 * buttonWidth, - 1); - var buttons = A2($Graphics$Element.flow, - $Graphics$Element.right, - _L.fromArray([restartButton - ,fittedSwapButton - ,state.paused ? playButton : pauseButton])); - var buttonContainer = A4($Graphics$Element.container, - _v8._0, - buttonHeight, - $Graphics$Element.midTop, - buttons); - var buttonSliderSpaceHeight = 10; - var topSpacerHeight = 15; - var midWidth = _v8._0 - sideMargin; - var centeredSliderContainer = A3($Graphics$Element.container, - _v8._0, - 24 + textHeight, - $Graphics$Element.midTop)(A2($Graphics$Element.flow, - $Graphics$Element.down, - _L.fromArray([A2(scrubSlider, - {ctor: "_Tuple2" - ,_0: midWidth - ,_1: _v8._1}, - state) - ,A2(sliderMinMaxText, - midWidth, - state)]))); - var slider = A3($Graphics$Element.container, - _v8._0, - 24 + 2 * textHeight, - $Graphics$Element.midTop)(A2($Graphics$Element.flow, - $Graphics$Element.down, - _L.fromArray([A2(sliderEventText, - _v8._0, - state) - ,centeredSliderContainer]))); - var controls = A2($Graphics$Element.flow, - $Graphics$Element.down, - _L.fromArray([A2($Graphics$Element.spacer, - midWidth, - topSpacerHeight) - ,buttonContainer - ,A2($Graphics$Element.spacer, - midWidth, - buttonSliderSpaceHeight) - ,slider - ,A2($Graphics$Element.spacer, - midWidth, - 10)])); - return A2($Graphics$Element.flow, - $Graphics$Element.down, - _L.fromArray([controls - ,bar - ,watchView])); - }();} - _U.badCase($moduleName, - "between lines 177 and 227"); - }(); - }); - var State = F3(function (a, - b, - c) { - return {_: {} - ,paused: a - ,scrubPosition: c - ,totalEvents: b}; - }); - var ScrubPosition = function (a) { - return {ctor: "ScrubPosition" - ,_0: a}; - }; - var TotalEvents = function (a) { - return {ctor: "TotalEvents" - ,_0: a}; - }; - var Pause = function (a) { - return {ctor: "Pause",_0: a}; - }; - var Restart = {ctor: "Restart"}; - var aggregateUpdates = $Signal.mergeMany(_L.fromArray([A2($Signal._op["<~"], - $Basics.always(Restart), - $Signal.subscribe(restartChannel)) - ,A2($Signal._op["<~"], - Pause, - $Signal.subscribe(pausedInput)) - ,A2($Signal._op["<~"], - TotalEvents, - eventCounter) - ,A2($Signal._op["<~"], - ScrubPosition, - $Signal.subscribe(scrupChannel))])); - var scene = A3($Signal.foldp, - step, - startState, - aggregateUpdates); - var main = A2($Signal._op["~"], - A2($Signal._op["~"], - A2($Signal._op["~"], - A2($Signal._op["<~"], - view, - A2($Signal._op["<~"], - function (_v17) { - return function () { - switch (_v17.ctor) - {case "_Tuple2": - return {ctor: "_Tuple2" - ,_0: panelWidth - ,_1: _v17._1};} - _U.badCase($moduleName, - "on line 235, column 30 to 43"); - }(); - }, - $Window.dimensions)), - watches), - $Signal.subscribe(permitSwapChannel)), - scene); - var scrubTo = _P.portOut("scrubTo", - _P.outgoingSignal(function (v) { - return v; - }), - A2($Signal._op["<~"], - function (_) { - return _.scrubPosition; - }, - scene)); - var pause = _P.portOut("pause", - _P.outgoingSignal(function (v) { - return v; - }), - A2($Signal._op["<~"], - function (_) { - return _.paused; - }, - scene)); - _elm.DebuggerInterface.values = {_op: _op - ,Restart: Restart - ,Pause: Pause - ,TotalEvents: TotalEvents - ,ScrubPosition: ScrubPosition - ,State: State - ,buttonHeight: buttonHeight - ,buttonWidth: buttonWidth - ,sideMargin: sideMargin - ,textHeight: textHeight - ,panelWidth: panelWidth - ,blue: blue - ,lightGrey: lightGrey - ,darkGrey: darkGrey - ,dataStyle: dataStyle - ,textStyle: textStyle - ,watchStyle: watchStyle - ,codeStyle: codeStyle - ,myButton: myButton - ,playButton: playButton - ,pauseButton: pauseButton - ,restartButton: restartButton - ,swapButton: swapButton - ,scrubSlider: scrubSlider - ,sliderEventText: sliderEventText - ,sliderMinMaxText: sliderMinMaxText - ,view: view - ,main: main - ,pausedInput: pausedInput - ,permitSwapChannel: permitSwapChannel - ,restartChannel: restartChannel - ,scrupChannel: scrupChannel - ,scene: scene - ,startState: startState - ,step: step - ,aggregateUpdates: aggregateUpdates - ,roundedSquare: roundedSquare - ,noWatches: noWatches}; - return _elm.DebuggerInterface.values; -}; -Elm.Dict = Elm.Dict || {}; -Elm.Dict.make = function (_elm) { - "use strict"; - _elm.Dict = _elm.Dict || {}; - if (_elm.Dict.values) - return _elm.Dict.values; - var _op = {}, - _N = Elm.Native, - _U = _N.Utils.make(_elm), - _L = _N.List.make(_elm), - _P = _N.Ports.make(_elm), - $moduleName = "Dict", - $Basics = Elm.Basics.make(_elm), - $List = Elm.List.make(_elm), - $Maybe = Elm.Maybe.make(_elm), - $Native$Debug = Elm.Native.Debug.make(_elm), - $String = Elm.String.make(_elm); - var foldr = F3(function (f, - acc, - t) { - return function () { - switch (t.ctor) - {case "RBEmpty": - switch (t._0.ctor) - {case "LBlack": return acc;} - break; - case "RBNode": return A3(foldr, - f, - A3(f, - t._1, - t._2, - A3(foldr,f,acc,t._4)), - t._3);} - _U.badCase($moduleName, - "between lines 410 and 418"); - }(); - }); - var keys = function (dict) { - return A3(foldr, - F3(function (key, - value, - keyList) { - return A2($List._op["::"], - key, - keyList); - }), - _L.fromArray([]), - dict); - }; - var values = function (dict) { - return A3(foldr, - F3(function (key, - value, - valueList) { - return A2($List._op["::"], - value, - valueList); - }), - _L.fromArray([]), - dict); - }; - var toList = function (dict) { - return A3(foldr, - F3(function (key,value,list) { - return A2($List._op["::"], - {ctor: "_Tuple2" - ,_0: key - ,_1: value}, - list); - }), - _L.fromArray([]), - dict); - }; - var foldl = F3(function (f, - acc, - dict) { - return function () { - switch (dict.ctor) - {case "RBEmpty": - switch (dict._0.ctor) - {case "LBlack": return acc;} - break; - case "RBNode": return A3(foldl, - f, - A3(f, - dict._1, - dict._2, - A3(foldl,f,acc,dict._3)), - dict._4);} - _U.badCase($moduleName, - "between lines 399 and 407"); - }(); - }); - var isBBlack = function (dict) { - return function () { - switch (dict.ctor) - {case "RBEmpty": - switch (dict._0.ctor) - {case "LBBlack": return true;} - break; - case "RBNode": - switch (dict._0.ctor) - {case "BBlack": return true;} - break;} - return false; - }(); - }; - var showFlag = function (f) { - return function () { - switch (f.ctor) - {case "Insert": return "Insert"; - case "Remove": return "Remove"; - case "Same": return "Same";} - _U.badCase($moduleName, - "between lines 175 and 181"); - }(); - }; - var Same = {ctor: "Same"}; - var Remove = {ctor: "Remove"}; - var Insert = {ctor: "Insert"}; - var get = F2(function (targetKey, - dict) { - return function () { - switch (dict.ctor) - {case "RBEmpty": - switch (dict._0.ctor) - {case "LBlack": - return $Maybe.Nothing;} - break; - case "RBNode": - return function () { - var _v29 = A2($Basics.compare, - targetKey, - dict._1); - switch (_v29.ctor) - {case "EQ": - return $Maybe.Just(dict._2); - case "GT": return A2(get, - targetKey, - dict._4); - case "LT": return A2(get, - targetKey, - dict._3);} - _U.badCase($moduleName, - "between lines 131 and 137"); - }();} - _U.badCase($moduleName, - "between lines 126 and 137"); - }(); - }); - var member = F2(function (key, - dict) { - return function () { - var _v30 = A2(get,key,dict); - switch (_v30.ctor) - {case "Just": return true; - case "Nothing": return false;} - _U.badCase($moduleName, - "between lines 140 and 142"); - }(); - }); - var max = function (dict) { - return function () { - switch (dict.ctor) - {case "RBEmpty": - return $Native$Debug.crash("(max Empty) is not defined"); - case "RBNode": - switch (dict._4.ctor) - {case "RBEmpty": - return {ctor: "_Tuple2" - ,_0: dict._1 - ,_1: dict._2};} - return max(dict._4);} - _U.badCase($moduleName, - "between lines 100 and 123"); - }(); - }; - var min = function (dict) { - return function () { - switch (dict.ctor) - {case "RBEmpty": - switch (dict._0.ctor) - {case "LBlack": - return $Native$Debug.crash("(min Empty) is not defined");} - break; - case "RBNode": - switch (dict._3.ctor) - {case "RBEmpty": - switch (dict._3._0.ctor) - {case "LBlack": - return {ctor: "_Tuple2" - ,_0: dict._1 - ,_1: dict._2};} - break;} - return min(dict._3);} - _U.badCase($moduleName, - "between lines 87 and 95"); - }(); - }; - var RBEmpty = function (a) { - return {ctor: "RBEmpty" - ,_0: a}; - }; - var RBNode = F5(function (a, - b, - c, - d, - e) { - return {ctor: "RBNode" - ,_0: a - ,_1: b - ,_2: c - ,_3: d - ,_4: e}; - }); - var showLColor = function (color) { - return function () { - switch (color.ctor) - {case "LBBlack": - return "LBBlack"; - case "LBlack": return "LBlack";} - _U.badCase($moduleName, - "between lines 70 and 72"); - }(); - }; - var LBBlack = {ctor: "LBBlack"}; - var LBlack = {ctor: "LBlack"}; - var empty = RBEmpty(LBlack); - var map = F2(function (f,dict) { - return function () { - switch (dict.ctor) - {case "RBEmpty": - switch (dict._0.ctor) - {case "LBlack": - return RBEmpty(LBlack);} - break; - case "RBNode": return A5(RBNode, - dict._0, - dict._1, - A2(f,dict._1,dict._2), - A2(map,f,dict._3), - A2(map,f,dict._4));} - _U.badCase($moduleName, - "between lines 387 and 396"); - }(); - }); - var showNColor = function (c) { - return function () { - switch (c.ctor) - {case "BBlack": return "BBlack"; - case "Black": return "Black"; - case "NBlack": return "NBlack"; - case "Red": return "Red";} - _U.badCase($moduleName, - "between lines 56 and 60"); - }(); - }; - var reportRemBug = F4(function (msg, - c, - lgot, - rgot) { - return $Native$Debug.crash($String.concat(_L.fromArray(["Internal red-black tree invariant violated, expected " - ,msg - ," and got " - ,showNColor(c) - ,"/" - ,lgot - ,"/" - ,rgot - ,"\nPlease report this bug to
"+(escaped?code:escape(code,true))+"\n'+(escaped?code:escape(code,true))+"\n\n"+quote+"\n"};Renderer.prototype.html=function(html){return html};Renderer.prototype.heading=function(text,level,raw){return"
\n":"
\n"};Renderer.prototype.list=function(body,ordered){var type=ordered?"ol":"ul";return"<"+type+">\n"+body+"\n"};Renderer.prototype.listitem=function(text){return"
"+text+"
\n"};Renderer.prototype.table=function(header,body){return""+text+""};Renderer.prototype.br=function(){return this.options.xhtml?"":"
"};Renderer.prototype.del=function(text){return"
"+escape(e.message+"",true)+""}throw e}}marked.options=marked.setOptions=function(opt){merge(marked.defaults,opt);return marked};marked.defaults={gfm:true,tables:true,breaks:false,pedantic:false,sanitize:false,smartLists:false,silent:false,highlight:null,langPrefix:"lang-",smartypants:false,headerPrefix:"",renderer:new Renderer,xhtml:false};marked.Parser=Parser;marked.parser=Parser.parse;marked.Renderer=Renderer;marked.Lexer=Lexer;marked.lexer=Lexer.lex;marked.InlineLexer=InlineLexer;marked.inlineLexer=InlineLexer.output;marked.parse=marked;if(typeof module!=="undefined"&&typeof exports==="object"){module.exports=marked}else if(typeof define==="function"&&define.amd){define(function(){return marked})}else{this.marked=marked}}).call(function(){return this||(typeof window!=="undefined"?window:global)}()); - - marked.setOptions({ - highlight: function (code, lang) { - if (typeof hljs === 'undefined') { - return code; - } - else if (lang) { - return hljs.highlight(lang, code, true).value; - } - else { - return hljs.highlightAuto(code).value; - } - } - }); - - function formatOptions(options) { - var gfm = options.githubFlavored; - if (gfm.ctor === 'Just') { - return { - gfm: true, - tables: gfm.tables, - breaks: gfm.breaks, - sanitize: options.sanitize, - smartypants: options.smartypants - } - } - else { - return { - gfm: false, - tables: false, - breaks: false, - sanitize: options.sanitize, - smartypants: options.smartypants - } - } - } - - function toHtmlWith(options, rawMarkdown) { - var widget = { - type: "Widget", - - init: function () { - var html = marked(rawMarkdown, formatOptions(options)); - var div = document.createElement('div'); - div.innerHTML = html; - return div; - }, - - update: function (previous, node) { - var html = marked(rawMarkdown, formatOptions(options)); - node.innerHTML = html; - return node; - } - }; - return widget; - } - - function toElementWith(options, rawMarkdown) { - return Text.markdown(marked(rawMarkdown, formatOptions(options))); - } - - return Elm.Native.Markdown.values = { - toHtmlWith: F2(toHtmlWith), - toElementWith: F2(toElementWith) - }; -}; -Elm.Native.Ports = {}; -Elm.Native.Ports.make = function(localRuntime) { - localRuntime.Native = localRuntime.Native || {}; - localRuntime.Native.Ports = localRuntime.Native.Ports || {}; - if (localRuntime.Native.Ports.values) { - return localRuntime.Native.Ports.values; - } - - var Signal; - - function incomingSignal(converter) { - converter.isSignal = true; - return converter; - } - - function outgoingSignal(converter) { - if (!Signal) { - Signal = Elm.Signal.make(localRuntime); - } - return function(signal) { - var subscribers = [] - function subscribe(handler) { - subscribers.push(handler); - } - function unsubscribe(handler) { - subscribers.pop(subscribers.indexOf(handler)); - } - A2( Signal.map, function(value) { - var val = converter(value); - var len = subscribers.length; - for (var i = 0; i < len; ++i) { - subscribers[i](val); - } - }, signal); - return { subscribe:subscribe, unsubscribe:unsubscribe }; - } - } - - function portIn(name, converter) { - var jsValue = localRuntime.ports.incoming[name]; - if (jsValue === undefined) { - throw new Error("Initialization Error: port '" + name + - "' was not given an input!"); - } - localRuntime.ports.uses[name] += 1; - try { - var elmValue = converter(jsValue); - } catch(e) { - throw new Error("Initialization Error on port '" + name + "': \n" + e.message); - } - - // just return a static value if it is not a signal - if (!converter.isSignal) { - return elmValue; - } - - // create a signal if necessary - if (!Signal) { - Signal = Elm.Signal.make(localRuntime); - } - var signal = Signal.constant(elmValue); - function send(jsValue) { - try { - var elmValue = converter(jsValue); - } catch(e) { - throw new Error("Error sending to port '" + name + "': \n" + e.message); - } - setTimeout(function() { - localRuntime.notify(signal.id, elmValue); - }, 0); - } - localRuntime.ports.outgoing[name] = { send:send }; - return signal; - } - - function portOut(name, converter, value) { - try { - localRuntime.ports.outgoing[name] = converter(value); - } catch(e) { - throw new Error("Initialization Error on port '" + name + "': \n" + e.message); - } - return value; - } - - return localRuntime.Native.Ports.values = { - incomingSignal: incomingSignal, - outgoingSignal: outgoingSignal, - portOut: portOut, - portIn: portIn - }; -}; - - - -if (!Elm.fullscreen) { - - (function() { - 'use strict'; - - var Display = { FULLSCREEN: 0, COMPONENT: 1, NONE: 2 }; - - Elm.fullscreen = function(module, ports) { - var container = document.createElement('div'); - document.body.appendChild(container); - return init(Display.FULLSCREEN, container, module, ports || {}); - }; - - Elm.embed = function(module, container, ports) { - var tag = container.tagName; - if (tag !== 'DIV') { - throw new Error('Elm.node must be given a DIV, not a ' + tag + '.'); - } else if (container.hasChildNodes()) { - throw new Error('Elm.node must be given an empty DIV. No children allowed!'); - } - return init(Display.COMPONENT, container, module, ports || {}); - }; - - Elm.worker = function(module, ports) { - return init(Display.NONE, {}, module, ports || {}); - }; - - function init(display, container, module, ports, moduleToReplace) { - // defining state needed for an instance of the Elm RTS - var inputs = []; - - /* OFFSET - * Elm's time traveling debugger lets you interrupt the smooth flow of time - * by pausing and continuing program execution. To ensure the user sees a - * program that moves smoothly through the pause/continue time gap, - * we need to adjsut the value of Date.now(). - */ - var timer = function() { - var inducedDelay = 0; - - var now = function() { - return Date.now() - inducedDelay; - }; - - var addDelay = function(d) { - inducedDelay += d; - return inducedDelay; - }; - - return { now : now - , addDelay : addDelay - } - }(); - - var updateInProgress = false; - function notify(id, v) { - if (updateInProgress) { - throw new Error( - 'The notify function has been called synchronously!\n' + - 'This can lead to frames being dropped.\n' + - 'Definitely report this to
"); - var arr = str.split('
'); - for (var i = arr.length; i--; ) { - arr[i] = makeSpaces(arr[i]); - } - return arr.join('
'); - } - - function fromString(str) { - return Utils.txt(properEscape(str)); - } - - function append(xs, ys) { - return Utils.txt(Utils.makeText(xs) + Utils.makeText(ys)); - } - - // conversions from Elm values to CSS - function toTypefaces(list) { - var typefaces = List.toArray(list); - for (var i = typefaces.length; i--; ) { - var typeface = typefaces[i]; - if (typeface.indexOf(' ') > -1) { - typefaces[i] = "'" + typeface + "'"; - } - } - return typefaces.join(','); - } - function toLine(line) { - var ctor = line.ctor; - return ctor === 'Under' ? 'underline' : - ctor === 'Over' ? 'overline' : 'line-through'; - } - - // setting styles of Text - function style(style, text) { - var newText = '' - return Utils.txt(newText); - } - function height(px, text) { - return { style: 'font-size:' + px + 'px;', text:text } - } - function typeface(names, text) { - return { style: 'font-family:' + toTypefaces(names) + ';', text:text } - } - function monospace(text) { - return { style: 'font-family:monospace;', text:text } - } - function italic(text) { - return { style: 'font-style:italic;', text:text } - } - function bold(text) { - return { style: 'font-weight:bold;', text:text } - } - function link(href, text) { - return { href: fromString(href), text:text }; - } - function line(line, text) { - return { style: 'text-decoration:' + toLine(line) + ';', text:text }; - } - - function color(color, text) { - return { style: 'color:' + toCss(color) + ';', text:text }; - } - - function block(align) { - return function(text) { - var raw = { - ctor :'RawHtml', - html : Utils.makeText(text), - align: align, - guid : null - }; - var pos = A2(NativeElement.htmlHeight, 0, raw); - return A3(Element.newElement, pos._0, pos._1, raw); - } - } - - function markdown(text, guid) { - var raw = { - ctor:'RawHtml', - html: text, - align: null, - guid: guid - }; - var pos = A2(NativeElement.htmlHeight, 0, raw); - return A3(Element.newElement, pos._0, pos._1, raw); - } - - return elm.Native.Text.values = { - fromString: fromString, - append: F2(append), - - height : F2(height), - italic : italic, - bold : bold, - line : F2(line), - monospace : monospace, - typeface : F2(typeface), - color : F2(color), - link : F2(link), - style : F2(style), - - leftAligned : block('left'), - rightAligned : block('right'), - centered : block('center'), - justified : block('justify'), - markdown : markdown, - - toTypefaces:toTypefaces, - toLine:toLine - }; -}; - -Elm.Native.Transform2D = {}; -Elm.Native.Transform2D.make = function(elm) { - - elm.Native = elm.Native || {}; - elm.Native.Transform2D = elm.Native.Transform2D || {}; - if (elm.Native.Transform2D.values) return elm.Native.Transform2D.values; - - var A; - if (typeof Float32Array === 'undefined') { - A = function(arr) { - this.length = arr.length; - this[0] = arr[0]; - this[1] = arr[1]; - this[2] = arr[2]; - this[3] = arr[3]; - this[4] = arr[4]; - this[5] = arr[5]; - }; - } else { - A = Float32Array; - } - - // layout of matrix in an array is - // - // | m11 m12 dx | - // | m21 m22 dy | - // | 0 0 1 | - // - // new A([ m11, m12, dx, m21, m22, dy ]) - - var identity = new A([1,0,0,0,1,0]); - function matrix(m11, m12, m21, m22, dx, dy) { - return new A([m11, m12, dx, m21, m22, dy]); - } - function rotation(t) { - var c = Math.cos(t); - var s = Math.sin(t); - return new A([c, -s, 0, s, c, 0]); - } - function rotate(t,m) { - var c = Math.cos(t); - var s = Math.sin(t); - var m11 = m[0], m12 = m[1], m21 = m[3], m22 = m[4]; - return new A([m11*c + m12*s, -m11*s + m12*c, m[2], - m21*c + m22*s, -m21*s + m22*c, m[5]]); - } - /* - function move(xy,m) { - var x = xy._0; - var y = xy._1; - var m11 = m[0], m12 = m[1], m21 = m[3], m22 = m[4]; - return new A([m11, m12, m11*x + m12*y + m[2], - m21, m22, m21*x + m22*y + m[5]]); - } - function scale(s,m) { return new A([m[0]*s, m[1]*s, m[2], m[3]*s, m[4]*s, m[5]]); } - function scaleX(x,m) { return new A([m[0]*x, m[1], m[2], m[3]*x, m[4], m[5]]); } - function scaleY(y,m) { return new A([m[0], m[1]*y, m[2], m[3], m[4]*y, m[5]]); } - function reflectX(m) { return new A([-m[0], m[1], m[2], -m[3], m[4], m[5]]); } - function reflectY(m) { return new A([m[0], -m[1], m[2], m[3], -m[4], m[5]]); } - - function transform(m11, m21, m12, m22, mdx, mdy, n) { - var n11 = n[0], n12 = n[1], n21 = n[3], n22 = n[4], ndx = n[2], ndy = n[5]; - return new A([m11*n11 + m12*n21, - m11*n12 + m12*n22, - m11*ndx + m12*ndy + mdx, - m21*n11 + m22*n21, - m21*n12 + m22*n22, - m21*ndx + m22*ndy + mdy]); - } - */ - function multiply(m, n) { - var m11 = m[0], m12 = m[1], m21 = m[3], m22 = m[4], mdx = m[2], mdy = m[5]; - var n11 = n[0], n12 = n[1], n21 = n[3], n22 = n[4], ndx = n[2], ndy = n[5]; - return new A([m11*n11 + m12*n21, - m11*n12 + m12*n22, - m11*ndx + m12*ndy + mdx, - m21*n11 + m22*n21, - m21*n12 + m22*n22, - m21*ndx + m22*ndy + mdy]); - } - - return elm.Native.Transform2D.values = { - identity:identity, - matrix:F6(matrix), - rotation:rotation, - multiply:F2(multiply) - /* - transform:F7(transform), - rotate:F2(rotate), - move:F2(move), - scale:F2(scale), - scaleX:F2(scaleX), - scaleY:F2(scaleY), - reflectX:reflectX, - reflectY:reflectY - */ - }; - -}; - -Elm.Native = Elm.Native || {}; -Elm.Native.Utils = {}; -Elm.Native.Utils.make = function(localRuntime) { - - localRuntime.Native = localRuntime.Native || {}; - localRuntime.Native.Utils = localRuntime.Native.Utils || {}; - if (localRuntime.Native.Utils.values) { - return localRuntime.Native.Utils.values; - } - - function eq(l,r) { - var stack = [{'x': l, 'y': r}] - while (stack.length > 0) { - var front = stack.pop(); - var x = front.x; - var y = front.y; - if (x === y) continue; - if (typeof x === "object") { - var c = 0; - for (var i in x) { - ++c; - if (i in y) { - if (i !== 'ctor') { - stack.push({ 'x': x[i], 'y': y[i] }); - } - } else { - return false; - } - } - if ('ctor' in x) { - stack.push({'x': x.ctor, 'y': y.ctor}); - } - if (c !== Object.keys(y).length) { - return false; - }; - } else if (typeof x === 'function') { - throw new Error('Equality error: general function equality is ' + - 'undecidable, and therefore, unsupported'); - } else { - return false; - } - } - return true; - } - - // code in Generate/JavaScript.hs depends on the particular - // integer values assigned to LT, EQ, and GT - var LT = -1, EQ = 0, GT = 1, ord = ['LT','EQ','GT']; - function compare(x,y) { return { ctor: ord[cmp(x,y)+1] } } - function cmp(x,y) { - var ord; - if (typeof x !== 'object'){ - return x === y ? EQ : x < y ? LT : GT; - } - else if (x.isChar){ - var a = x.toString(); - var b = y.toString(); - return a === b ? EQ : a < b ? LT : GT; - } - else if (x.ctor === "::" || x.ctor === "[]") { - while (true) { - if (x.ctor === "[]" && y.ctor === "[]") return EQ; - if (x.ctor !== y.ctor) return x.ctor === '[]' ? LT : GT; - ord = cmp(x._0, y._0); - if (ord !== EQ) return ord; - x = x._1; - y = y._1; - } - } - else if (x.ctor.slice(0,6) === '_Tuple') { - var n = x.ctor.slice(6) - 0; - var err = 'cannot compare tuples with more than 6 elements.'; - if (n === 0) return EQ; - if (n >= 1) { ord = cmp(x._0, y._0); if (ord !== EQ) return ord; - if (n >= 2) { ord = cmp(x._1, y._1); if (ord !== EQ) return ord; - if (n >= 3) { ord = cmp(x._2, y._2); if (ord !== EQ) return ord; - if (n >= 4) { ord = cmp(x._3, y._3); if (ord !== EQ) return ord; - if (n >= 5) { ord = cmp(x._4, y._4); if (ord !== EQ) return ord; - if (n >= 6) { ord = cmp(x._5, y._5); if (ord !== EQ) return ord; - if (n >= 7) throw new Error('Comparison error: ' + err); } } } } } } - return EQ; - } - else { - throw new Error('Comparison error: comparison is only defined on ints, ' + - 'floats, times, chars, strings, lists of comparable values, ' + - 'and tuples of comparable values.'); - } - } - - - var Tuple0 = { ctor: "_Tuple0" }; - function Tuple2(x,y) { - return { - ctor: "_Tuple2", - _0: x, - _1: y - }; - } - - function chr(c) { - var x = new String(c); - x.isChar = true; - return x; - } - - function txt(str) { - var t = new String(str); - t.text = true; - return t; - } - - function makeText(text) { - var style = ''; - var href = ''; - while (true) { - if (text.style) { - style += text.style; - text = text.text; - continue; - } - if (text.href) { - href = text.href; - text = text.text; - continue; - } - if (href) { - text = '' + text + ''; - } - if (style) { - text = '' + text + ''; - } - return text; - } - } - - var count = 0; - function guid(_) { - return count++ - } - - function copy(oldRecord) { - var newRecord = {}; - for (var key in oldRecord) { - var value = key === '_' - ? copy(oldRecord._) - : oldRecord[key] - ; - newRecord[key] = value; - } - return newRecord; - } - - function remove(key, oldRecord) { - var record = copy(oldRecord); - if (key in record._) { - record[key] = record._[key][0]; - record._[key] = record._[key].slice(1); - if (record._[key].length === 0) { - delete record._[key]; - } - } else { - delete record[key]; - } - return record; - } - - function replace(keyValuePairs, oldRecord) { - var record = copy(oldRecord); - for (var i = keyValuePairs.length; i--; ) { - var pair = keyValuePairs[i]; - record[pair[0]] = pair[1]; - } - return record; - } - - function insert(key, value, oldRecord) { - var newRecord = copy(oldRecord); - if (key in newRecord) { - var values = newRecord._[key]; - var copiedValues = values ? values.slice(0) : []; - newRecord._[key] = [newRecord[key]].concat(copiedValues); - } - newRecord[key] = value; - return newRecord; - } - - function getXY(e) { - var posx = 0; - var posy = 0; - if (e.pageX || e.pageY) { - posx = e.pageX; - posy = e.pageY; - } else if (e.clientX || e.clientY) { - posx = e.clientX + document.body.scrollLeft + document.documentElement.scrollLeft; - posy = e.clientY + document.body.scrollTop + document.documentElement.scrollTop; - } - - if (localRuntime.isEmbed()) { - var rect = localRuntime.node.getBoundingClientRect(); - var relx = rect.left + document.body.scrollLeft + document.documentElement.scrollLeft; - var rely = rect.top + document.body.scrollTop + document.documentElement.scrollTop; - // TODO: figure out if there is a way to avoid rounding here - posx = posx - Math.round(relx) - localRuntime.node.clientLeft; - posy = posy - Math.round(rely) - localRuntime.node.clientTop; - } - return Tuple2(posx, posy); - } - - - //// LIST STUFF //// - - var Nil = { ctor:'[]' }; - - function Cons(hd,tl) { - return { - ctor: "::", - _0: hd, - _1: tl - }; - } - - function append(xs,ys) { - // append Text - if (xs.text || ys.text) { - return txt(makeText(xs) + makeText(ys)); - } - - // append Strings - if (typeof xs === "string") { - return xs + ys; - } - - // append Lists - if (xs.ctor === '[]') { - return ys; - } - var root = Cons(xs._0, Nil); - var curr = root; - xs = xs._1; - while (xs.ctor !== '[]') { - curr._1 = Cons(xs._0, Nil); - xs = xs._1; - curr = curr._1; - } - curr._1 = ys; - return root; - } - - //// RUNTIME ERRORS //// - - function indent(lines) { - return '\n' + lines.join('\n'); - } - - function badCase(moduleName, span) { - var msg = indent([ - 'Non-exhaustive pattern match in case-expression.', - 'Make sure your patterns cover every case!' - ]); - throw new Error('Runtime error in module ' + moduleName + ' (' + span + ')' + msg); - } - - function badIf(moduleName, span) { - var msg = indent([ - 'Non-exhaustive pattern match in multi-way-if expression.', - 'It is best to use \'otherwise\' as the last branch of multi-way-if.' - ]); - throw new Error('Runtime error in module ' + moduleName + ' (' + span + ')' + msg); - } - - - function badPort(expected, received) { - var msg = indent([ - 'Expecting ' + expected + ' but was given ', - JSON.stringify(received) - ]); - throw new Error('Runtime error when sending values through a port.' + msg); - } - - - return localRuntime.Native.Utils.values = { - eq:eq, - cmp:cmp, - compare:F2(compare), - Tuple0:Tuple0, - Tuple2:Tuple2, - chr:chr, - txt:txt, - makeText:makeText, - copy: copy, - remove: remove, - replace: replace, - insert: insert, - guid: guid, - getXY: getXY, - - Nil: Nil, - Cons: Cons, - append: F2(append), - - badCase: badCase, - badIf: badIf, - badPort: badPort - }; -}; - -(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o