7b1a2f4 · elk · git.iko.soy

git.iko.soy/elk

on master help sign in

Add `zip` and `zipWith` to Prelude. Fix an oversight in the constraint generator. Upload the elm runtime system.

7b1a2f4evancz14 years ago

core-js/Prelude.js+2

compare with master

unifiedsplit

@@ -112,6 +112,8 @@ Elm.Prelude = function() {

112 Nothing : Elm.Maybe.Nothing,

113 maybe : Elm.Maybe.maybe,

114 map : Elm.List.map,

115+ zip : Elm.List.zip,

116+ zipWith : Elm.List.zipWith,

115 filter : Elm.List.filter,

117 filter : Elm.List.filter,

116 head : Elm.List.head,

118 head : Elm.List.head,

117 tail : Elm.List.tail,

119 tail : Elm.List.tail,

elm/elm-runtime-0.5.5.jsnew file+3843

@@ -0,0 +1,3843 @@

2+Elm = {};

4+var Guid = function() {

5+ var counter = 0;

6+ var guid = function() { counter += 1; return counter; };

7+ return {guid : guid};

8+}();

9+Elm.JavaScript = function() {

10+ function castJSBoolToBool(b) { return b; }

11+ function castBoolToJSBool(b) { return b; }

12+

13+ function castJSNumberToFloat(n) { return n; }

14+ function castFloatToJSNumber(n) { return n; }

15+

16+ function castJSNumberToInt(n) { return ~~n; }

17+ function castIntToJSNumber(n) { return n; }

18+

19+ function castJSElementToElement(w) {

20+ return function(h) {

21+ return function(node) {

22+ return ["Element",Guid.guid(),

23+ ["EExternalHtml",node],

24+ w,h,1,Nothing,Nothing];

25+ }

26+ }

27+ }

28+ function castElementToJSElement(elem) { return Render.render(elem); }

29+

30+ function castJSArrayToList(arr) {

31+ var list = ["Nil"];

32+ for (var i = arr.length; i--; ) {

33+ list = [ "Cons", arr[i], list ];

34+ }

35+ return list;

36+ }

37+ function castListToJSArray(list) {

38+ var a = [];

39+ while (list[0] === "Cons") {

40+ a.push(list[1]);

41+ list = list[2];

42+ }

43+ return a;

44+ }

45+

46+ var castJSStringToString = castJSArrayToList;

47+ function castStringToJSString(str) {

48+ if (typeof str === "string") return str;

49+ return castListToJSArray(str).join('');

50+ }

51+

52+ function fromTuple(t) { return t.slice(1); }

53+ function toTuple(a) { return ["Tuple" + a.length].concat(a); }

54+

55+ return {castJSBoolToBool:castJSBoolToBool,

56+ castBoolToJSBool:castBoolToJSBool,

57+ castJSNumberToFloat:castJSNumberToFloat,

58+ castFloatToJSNumber:castFloatToJSNumber,

59+ castJSNumberToInt:castJSNumberToInt,

60+ castIntToJSNumber:castIntToJSNumber,

61+ Experimental : {castJSElementToElement:castJSElementToElement,

62+ castElementToJSElement:castElementToJSElement},

63+ castJSArrayToList:castJSArrayToList,

64+ castListToJSArray:castListToJSArray,

65+ castJSStringToString:castJSStringToString,

66+ castStringToJSString:castStringToJSString,

67+ castTupleToJSTuple2:fromTuple,

68+ castTupleToJSTuple3:fromTuple,

69+ castTupleToJSTuple4:fromTuple,

70+ castTupleToJSTuple5:fromTuple,

71+ castJSTupleToTuple2:toTuple,

72+ castJSTupleToTuple3:toTuple,

73+ castJSTupleToTuple4:toTuple,

74+ castJSTupleToTuple5:toTuple

75+ };

76+}();

77+

78+var JSjson = window.JSON;

79+Elm.JSON = function() {

80+ var JS = Elm.JavaScript;

81+ var empty = ['JSON',{}];

82+ function singleton(k) { return function(v) {

83+ var obj = {};

84+ obj[JS.castStringToJSString(k)] = v;

85+ return ['JSON', obj ];

86+ };

87+ }

88+ function insert(k) { return function(v) { return function(inObj) {

89+ var obj = inObj[1];

90+ var outObj = {};

91+ for (var i in obj) {

92+ outObj[i] = obj[i];

93+ }

94+ outObj[JS.castStringToJSString(k)] = v;

95+ return ['JSON', outObj ];

96+ };

97+ };

98+ }

99+

100+ function lookup(key) { return function(obj) {

101+ var k = JS.castStringToJSString(key);

102+ return obj[1].hasOwnProperty(k) ? ["Just", obj[1][k]] : ["Nothing"] ;

103+ };

104+ }

105+ function find(tipe,base) { return function (key) { return function(obj) {

106+ var k = JS.castStringToJSString(key);

107+ if (obj[1].hasOwnProperty(k)) {

108+ var v = obj[1][k];

109+ if (v[0] === tipe) { return v[1]; }

110+ }

111+ return base;

112+ };

113+ }

114+ }

115+ function lookupWithDefault(base) { return function(key) { return function(obj) {

116+ var k = JS.castStringToJSString(key);

117+ return obj[1].hasOwnProperty(k) ? obj[1][k] : base ;

118+ };

119+ };

120+ }

121+

122+ function remove(k) { return function(inObj) {

123+ var obj = inObj[1];

124+ var outObj = {};

125+ for (var i in obj) {

126+ outObj[i] = obj[i];

127+ }

128+ delete outObj[JS.castStringToJSString(k)];

129+ return ['JSON', outObj];

130+ };

131+ }

132+

133+ function JsonString(v) { return [ "JsonString", v ]; }

134+ function JsonNumber(v) { return [ "JsonNumber", v ]; }

135+ function JsonBool(v) { return [ "JsonBool", v ]; }

136+ var JsonNull = [ "JsonNull" ];

137+ function JsonArray(v) { return [ "JsonArray", v ]; }

138+ function JsonObject(v) { return [ "JsonObject", v ]; }

139+

140+ function toList(json) {

141+ var obj = json[1];

142+ var arr = [];

143+ for (var i in obj) {

144+ arr.push(Value.Tuple(JS.castJSStringToString(i), obj[i]));

145+ }

146+ return JS.castJSArrayToList(arr);

147+ }

148+ function fromList(list) {

149+ var arr = JS.castListToJSArray(list);

150+ var obj = {};

151+ for (var i = arr.length; i--; ) {

152+ obj[JS.castStringToJSString(arr[i][1])] = arr[i][2];

153+ }

154+ return [ "JSON", obj ];

155+ }

156+

157+ function toPrettyJSString(sep) { return function (obj) {

158+ function fromValue(v) {

159+ switch (v[0]) {

160+ case 'JsonNull' : return null;

161+ case 'JsonString' : return JS.castStringToJSString(v[1]);

162+ case 'JsonObject' :

163+ var o = {};

164+ var from = v[1][1];

165+ for (var i in from) {

166+ o[i] = fromValue(from[i]);

167+ }

168+ return o;

169+ case 'JsonArray' :

170+ var a = JS.castListToJSArray(v[1]);

171+ for (var i = a.length; i--; ) {

172+ a[i] = fromValue(a[i]);

173+ }

174+ return a;

175+ default :

176+ return v[1];

177+ }

178+ }

179+ return JSjson.stringify(fromValue([ 'JsonObject', obj ]), null, JS.castStringToJSString(sep));

180+ };

181+ }

182+ function fromJSString(str) {

183+ var obj = JSjson.parse(str);

184+ function toValue(v) {

185+ switch (typeof v) {

186+ case 'string' : return [ "JsonString", JS.castJSStringToString(v) ];

187+ case 'number' : return [ "JsonNumber", JS.castJSNumberToFloat(v) ];

188+ case 'boolean' : return [ "JsonBool", JS.castJSBoolToBool(v) ];

189+ case 'object' :

190+ if (v === null) return [ "JsonNull" ];

191+ for (var i in v) {

192+ v[i] = toValue(v[i]);

193+ }

194+ if (v instanceof Array) return [ "JsonArray", JS.castJSArrayToList(v) ];

195+ return [ "JsonObject", [ "JSON", v ] ];

196+ }

197+ }

198+ for (var i in obj) {

199+ obj[i] = toValue(obj[i]);

200+ }

201+ return ['JSON',obj];

202+ }

203+ return {empty : empty,

204+ singleton : singleton,

205+ insert : insert,

206+ lookup : lookup,

207+ findString : find("JsonString",["Nil"]),

208+ findObject : find("JsonObject", empty ),

209+ findArray : find("JsonArray" ,["Nil"]),

210+ findWithDefault : lookupWithDefault,

211+ remove : remove,

212+ toPrettyJSString : toPrettyJSString,

213+ toJSString : toPrettyJSString(''),

214+ fromJSString : fromJSString,

215+ toPrettyString : function(sep) { return function(v) {

216+ return JS.castJSStringToString(toPrettyJSString(sep)(v)); }; },

217+ toString : function(v) { return JS.castJSStringToString(toPrettyJSString('')(v)); },

218+ fromString : function(v) { return fromJSString(JS.castStringToJSString(v)); },

219+ toList : toList,

220+ fromList : fromList,

221+ JsonString : JsonString,

222+ JsonNumber : JsonNumber,

223+ JsonBool : JsonBool,

224+ JsonNull : JsonNull,

225+ JsonArray : JsonArray,

226+ JsonObject : JsonObject

227+ };

228+}();

229+

230+var Value = function(){

231+

232+ var eq = function(x,y) {

233+ if (typeof x === "object") {

234+ if (x === y) return true;

235+ if (x.length !== y.length) return false;

236+ for (var i = x.length; i--; ) {

237+ if (!eq(x[i],y[i])) return false;

238+ }

239+ return true;

240+ }

241+ return x === y;

242+ };

243+

244+ var Tuple = function() {

245+ var len = arguments.length;

246+ var arr = new Array(len+1);

247+ arr[0] = "Tuple" + arguments.length;

248+ for (var i = len; i--; ) {

249+ arr[i+1] = arguments[i];

250+ }

251+ return arr;

252+ };

253+

254+ var listToArray = function(list) {

255+ var arr = [];

256+ while (list[0] === "Cons") {

257+ arr.push(list[1]);

258+ list = list[2];

259+ }

260+ return arr;

261+ };

262+

263+ function makeSpaces(s) {

264+ if (s.length == 0) { return s; }

265+ var arr = s.split('');

266+ if (arr[0] == ' ') { arr[0] = " " }

267+ for (var i = arr.length; --i; ) {

268+ if (arr[i][0] == ' ' && arr[i-1] == ' ') {

269+ arr[i-1] = arr[i-1] + arr[i];

270+ arr[i] = '';

271+ }

272+ }

273+ for (var i = arr.length; i--; ) {

274+ if (arr[i].length > 1 && arr[i][0] == ' ') {

275+ var spaces = arr[i].split('');

276+ for (var j = spaces.length - 2; j >= 0; j -= 2) {

277+ spaces[j] = ' ';

278+ }

279+ arr[i] = spaces.join('');

280+ }

281+ }

282+ arr = arr.join('');

283+ if (arr[arr.length-1] === " ") {

284+ return arr.slice(0,-1) + ' ';

285+ }

286+ return arr;

287+ }

288+

289+ function properEscape(str) {

290+ if (str.length == 0) return str;

291+ str = str //.replace(/&/g, "&")

292+ .replace(/"/g, /*"*/ """)

293+ .replace(/'/g, /*'*/ "'")

294+ .replace(/</g, "<")

295+ .replace(/>/g, ">")

296+ .replace(/\n/g, " ");

297+ var arr = str.split(' ');

298+ for (var i = arr.length; i--; ) {

299+ arr[i] = makeSpaces(arr[i]);

300+ }

301+ return arr.join(' ');

302+ }

303+

304+ var toText = function(elmList) {

305+ if (typeof elmList === "string") return properEscape(elmList);

306+ var a = [];

307+ while (elmList[0] === "Cons") {

308+ a.push(elmList[1]);

309+ elmList = elmList[2];

310+ }

311+ return properEscape(a.join(''));

312+ };

313+

314+ function getTextSize(w,h,txt) {

315+ var t = document.createElement('div');

316+ t.innerHTML = txt;

317+ t.style.textAlign = 'left';

318+ if (w > 0) { t.style.width = w + "px"; }

319+

320+ t.style.visibility = "hidden";

321+ t.style.styleFloat = "left";

322+ t.style.cssFloat = "left";

323+

324+ document.body.appendChild(t);

325+ var cStyle = window.getComputedStyle(t,null);

326+ var realW = cStyle.getPropertyValue("width").slice(0,-2) - 0;

327+ var realH = cStyle.getPropertyValue("height").slice(0,-2) - 0;

328+ document.body.removeChild(t);

329+ //delete t;

330+ return [Math.ceil(realW),Math.ceil(Math.max(h,realH))];

331+ }

332+

333+ function getSize(e) {

334+ var t = e.cloneNode(true);

335+

336+ t.style.visibility = "hidden";

337+ t.style.styleFloat = "left";

338+ t.style.cssFloat = "left";

339+

340+ document.body.appendChild(t);

341+ var w = t.offsetWidth;

342+ var h = t.offsetHeight;

343+ document.body.removeChild(t);

344+ //delete t;

345+ return [w,h];

346+ }

347+

348+ function getExcess(e) {

349+ var t = e.cloneNode(true);

350+

351+ t.style.visibility = "hidden";

352+ t.style.styleFloat = "left";

353+ t.style.cssFloat = "left";

354+

355+ document.body.appendChild(t);

356+ var ow = t.offsetWidth;

357+ var oh = t.offsetHeight;

358+ var cStyle = window.getComputedStyle(t,null);

359+ var w = cStyle.getPropertyValue("width").slice(0,-2) - 0;

360+ var h = cStyle.getPropertyValue("height").slice(0,-2) - 0;

361+ document.body.removeChild(t);

362+ //delete t;

363+ return [ow-w,oh-h];

364+ }

365+

366+

367+ function groupForms(forms) {

368+ forms = Elm.JavaScript.castListToJSArray(forms);

369+ var groups = [];

370+ var arr = [];

371+ for (var i = forms.length; i--; ) {

372+ var f = forms[i];

373+ switch(f[4][0]) {

374+ case "FElement":

375+ if (arr.length > 0) {

376+ groups.push(arr);

377+ arr = [];

378+ }

379+ groups.push(f);

380+ break;

381+ default:

382+ arr.push(f);

383+ }

384+ }

385+ if (arr.length > 0) groups.push(arr);

386+ return groups;

387+ }

388+

389+ var toString = function(v) {

390+ if (typeof v === "boolean") {

391+ return v ? "True" : "False";

392+ } else if (typeof v === "number") {

393+ return v+"";

394+ } else if (typeof v === "string" && v.length < 2) {

395+ return "'"+v+"'";

396+ } else if (v[0]) {

397+ if (v[0].substring(0,5) === "Tuple") {

398+ var output = "";

399+ for (var i = v.length; --i; ) {

400+ output = "," + toString(v[i]) + output;

401+ }

402+ if (output[0] === ",") output = output.substring(1);

403+ return "("+output+")";

404+ } else if (v[0] === "Cons") {

405+ var start = (typeof v[1] === "string") ? '"' : "[";

406+ var end = (typeof v[1] === "string") ? '"' : "]";

407+ var div = (typeof v[1] === "string") ? "" : ",";

408+ var f = (typeof v[1] === "string") ? function(x){return x} : toString;

409+ var output = start + f(v[1]);

410+ v = v[2];

411+ while (true) {

412+ if (v[0] === "Cons") {

413+ output += div + f(v[1]);

414+ v = v[2];

415+ } else {

416+ return output + end;

417+ }

418+ }

419+ } else if (v[0] === "Nil") {

420+ return "[]";

421+ } else if (v[0] === "JSON") {

422+ return "(JSON.fromList " + toString(Elm.JSON.toList(v)) + ")";

423+ } else if (v[0] === "RBNode" || v[0] === "RBEmpty") {

424+ function cons(k){ return function(v) { return function(acc) { return ["Cons",["Tuple2",k,v],acc]; }; }; }

425+ var list = Elm.Dict.foldr(cons)(["Nil"])(v);

426+ var name = "Dict";

427+ if (list[0] === "Cons" && list[1][2][0] === "Tuple0") {

428+ name = "Set";

429+ list = Elm.List.map(function(x) { return x[1]; })(list);

430+ }

431+ return "(" + name + ".fromList " + toString(list) + ")";

432+ } else {

433+ var output = "";

434+ for (var i = v.length; --i; ) {

435+ output = " " + toString(v[i]) + output

436+ }

437+ output = v[0] + output;

438+ return (v.length > 1) ? "(" + output + ")" : output;

439+ }

440+ }

441+ return v+"";

442+ };

443+ var show = function(v) { return str(toString(v)); };

444+ var append = function(xs,ys) {

445+ if (typeof xs === "string" && typeof ys === "string") {

446+ return xs.concat(ys);

447+ }

448+ if (xs[0] === "Nil") {

449+ return ys;

450+ }

451+ var root = ["Cons", xs[1], ["Nil"]];

452+ var curr = root;

453+ xs = xs[2];

454+ while (xs[0]==="Cons") {

455+ curr[2] = ["Cons", xs[1], ["Nil"]];

456+ xs = xs[2];

457+ curr = curr[2];

458+ }

459+ curr[2] = ys;

460+ return root;

461+ };

462+

463+ var str = function(s) {

464+ var out = ["Nil"];

465+ for (var i = s.length; i--; ) {

466+ out = ["Cons", s[i], out];

467+ }

468+ return out;

469+ };

470+

471+ function wrap(elem) {

472+ var p = Value.getSize(elem);

473+ return ["Element", Guid.guid(), ["EHtml",elem],

474+ p[0], p[1], 1, ["Nothing"], ["Nothing"]];

475+ }

476+ var addListener = function() {

477+ if(document.addEventListener) {

478+ return function(element, event, handler) {

479+ element.addEventListener(event, handler, false);

480+ };

481+ } else {

482+ return function(element, event, handler) {

483+ element.attachEvent('on' + event, handler);

484+ };

485+ }

486+ }();

487+

488+ return {eq:eq,

489+ str:str,

490+ show:show,

491+ Tuple:Tuple,

492+ append:append,

493+ listToArray:listToArray,

494+ toText : toText,

495+ properEscape : properEscape,

496+ getTextSize : getTextSize,

497+ getSize : getSize,

498+ getExcess : getExcess,

499+ groupForms : groupForms,

500+ wrap : wrap,

501+ addListener : addListener

502+ };

503+}();Elm.List = function() {

504+

505+ var throwError = function(f) {

506+ throw "Function '" + f + "' expecting a list!";

507+ }

508+

509+ function length(xs) {

510+ var out = 0;

511+ while (xs[0] === "Cons") {

512+ out += 1;

513+ xs = xs[2];

514+ }

515+ return out;

516+ };

517+ var reverse = foldl(function(x_72) {

518+ return function(y_73) {

519+ return["Cons", x_72, y_73]

520+ }

521+ })(["Nil"]);

522+ var concat = foldr(function(x_74) {

523+ return function(y_75) {

524+ return Value.append(x_74, y_75)

525+ }

526+ })(["Nil"]);

527+ var and = foldl(function(x_77) {

528+ return function(y_78) {

529+ return x_77 && y_78

530+ }

531+ })(true);

532+ var or = foldl(function(x_79) {

533+ return function(y_80) {

534+ return x_79 || y_80

535+ }

536+ })(false);

537+ var sum = foldl(function(x_89) {

538+ return function(y_90) {

539+ return x_89 + y_90

540+ }

541+ })(0);

542+ var product = foldl(function(x_91) {

543+ return function(y_92) {

544+ return x_91 * y_92

545+ }

546+ })(1);

547+ var maximum = foldl1(function(x) { return function(y) { return Math.max(x,y) } });

548+ var minimum = foldl1(function(x) { return function(y) { return Math.min(x,y) } });

549+ function head(v) {

550+ if (v[0] !== "Cons") {

551+ throw "Error: 'head' only accepts lists of length greater than one.";

552+ }

553+ return v[1];

554+ }

555+ function tail(v) {

556+ if (v[0] !== "Cons") {

557+ throw "Error: 'tail' only accepts lists of length greater than one.";

558+ }

559+ return v[2];

560+ }

561+ function last(v) {

562+ if (v[0] !== "Cons") {

563+ throw "Error: 'last' only accepts lists of length greater than one.";

564+ }

565+ var out = v[1];

566+ while (v[0] === "Cons") {

567+ out = v[1];

568+ v = v[2];

569+ }

570+ return out;

571+ }

572+ function map(f) {

573+ return function(xs) {

574+ if (xs[0] === "Nil") { return xs; }

575+ if (xs[0] !== "Cons") { throwError('map'); }

576+ var root = ["Cons", f(xs[1]), ["Nil"]];

577+ var curr = root;

578+ xs = xs[2];

579+ while (xs[0]==="Cons") {

580+ curr[2] = ["Cons", f(xs[1]), ["Nil"]];

581+ xs = xs[2];

582+ curr = curr[2];

583+ }

584+ return root;

585+ }

586+ }

587+ function foldl(f) {

588+ return function(b) {

589+ return function(xs) {

590+ var acc = b;

591+ if (xs[0] === "Nil") { return acc; }

592+ if (xs[0] !== "Cons") { throwError('foldl'); }

593+ while (xs[0] === "Cons") {

594+ acc = f(xs[1])(acc);

595+ xs = xs[2];

596+ }

597+ return acc;

598+ }

599+ }

600+ }

601+ function foldr(f) {

602+ return function(b) {

603+ return function(xs) {

604+ var acc = b;

605+ if (xs[0] === "Nil") { return acc; }

606+ if (xs[0] !== "Cons") { throwError('foldr'); }

607+ var arr = [];

608+ while (xs[0] === "Cons") {

609+ arr.push(xs[1]);

610+ xs = xs[2];

611+ }

612+ for (var i = arr.length; i--; ) {

613+ acc = f(arr[i])(acc);

614+ }

615+ return acc;

616+ }

617+ }

618+ }

619+ function foldl1(f_49) {

620+ return function(_temp_50) {

621+ return function(v) {

622+ if("Cons" !== v[0]) {

623+ return undefined

624+ }else {

625+ var x_51 = v[1];

626+ var xs_52 = v[2];

627+ return foldl(f_49)(x_51)(xs_52)

628+ }

629+ }(_temp_50)

630+ }

631+ }

632+ function foldr1(f) {

633+ return function(xs) {

634+ if (xs[0] === "Nil") { throw "'foldr1' requires an non-empty list." }

635+ if (xs[0] !== "Cons") { throwError('foldr1'); }

636+ var arr = [];

637+ while (xs[0] === "Cons") {

638+ arr.push(xs[1]);

639+ xs = xs[2];

640+ }

641+ var acc = arr.pop();

642+ for (var i = arr.length; i--; ) {

643+ acc = f(arr[i])(acc);

644+ }

645+ return acc;

646+ }

647+ }

648+ function scanl(f) {

649+ return function(b) {

650+ return function(xs) {

651+ if (xs[0] === "Nil") { return ["Cons",b,["Nil"]]; }

652+ if (xs[0] !== "Cons") { throwError('scanl'); }

653+ var arr = [b];

654+ while (xs[0] === "Cons") {

655+ b = f(xs[1])(b);

656+ arr.push(b);

657+ xs = xs[2];

658+ }

659+ var out = ["Nil"];

660+ for (var i = arr.length; i--; ) {

661+ out = ["Cons", arr[i], out];

662+ }

663+ return out;

664+ }

665+ }

666+ }

667+ function scanl1(f) {

668+ return function(xs) {

669+ if (xs[0] !== "Cons") {

670+ throw "Error: 'scanl1' requires a list of at least length 1.";

671+ }

672+ return scanl(f)(xs[1])(xs[2]);

673+ }

674+ }

675+ function filter(pred) {

676+ return function(xs) {

677+ if (xs[0] === "Nil") { return xs; }

678+ if (xs[0] !== "Cons") { throwError('filter'); }

679+ var arr = [];

680+ while (xs[0] === "Cons") {

681+ if (pred(xs[1])) { arr.push(xs[1]); }

682+ xs = xs[2];

683+ }

684+ var out = ["Nil"];

685+ for (var i = arr.length; i--; ) {

686+ out = ["Cons", arr[i], out];

687+ }

688+ return out;

689+ }

690+ }

691+ function concatMap(f_76) {

692+ return function(x) {

693+ return concat(map(f_76)(x))

694+ }

695+ }

696+ function all(pred) {

697+ return foldl(function(x) { return function(acc) {

698+ return acc && pred(x);

699+ };})(true);

700+ }

701+ function any(pred) {

702+ return foldl(function(x) { return function(acc) {

703+ return acc || pred(x);

704+ };})(false);

705+ }

706+ function partition(pred_93) {

707+ return function(lst_94) {

708+ return function() {

709+ var v = lst_94;

710+ var c = [function(v) {

711+ if("Nil" !== v[0]) {

712+ return undefined

713+ }else {

714+ return["Tuple2", ["Nil"], ["Nil"]]

715+ }

716+ }, function(v) {

717+ if("Cons" !== v[0]) {

718+ return undefined

719+ }else {

720+ var x_95 = v[1];

721+ var xs_96 = v[2];

722+ return function(v) {

723+ if("Tuple2" !== v[0]) {

724+ return undefined

725+ }else {

726+ var as_97 = v[1];

727+ var bs_98 = v[2];

728+ return pred_93(x_95) ? ["Tuple2", ["Cons", x_95, as_97], bs_98] : ["Tuple2", as_97, ["Cons", x_95, bs_98]]

729+ }

730+ }(partition(pred_93)(xs_96))

731+ }

732+ }];

733+ for(var i = c.length;i--;) {

734+ var r = c[i](v);

735+ if(r !== undefined) {

736+ return r

737+ }

738+ }

739+ }()

740+ }

741+ }

742+ function zipWith(f) {

743+ return function(listA) {

744+ return function(listB) {

745+ if (listA[0] === "Nil" || listB[0] === "Nil") { return ["Nil"]; }

746+ if (listA[0] !== "Cons" || listB[0] !== "Cons") { throwError('zipWith'); }

747+ var arr = [];

748+ while (listA[0] === "Cons" && listB[0] === "Cons") {

749+ arr.push(f(listA[1])(listB[1]));

750+ listA = listA[2];

751+ listB = listB[2];

752+ }

753+ var out = ["Nil"];

754+ for (var i = arr.length; i--; ) {

755+ out = ["Cons", arr[i], out];

756+ }

757+ return out;

758+ }

759+ }

760+ }

761+ function zip(listA) {

762+ return function(listB) {

763+ if (listA[0] === "Nil" || listB[0] === "Nil") { return ["Nil"]; }

764+ if (listA[0] !== "Cons" || listB[0] !== "Cons") { throwError('zip'); }

765+ var arr = [];

766+ while (listA[0] === "Cons" && listB[0] === "Cons") {

767+ arr.push(["Tuple2", listA[1], listB[1]]);

768+ listA = listA[2];

769+ listB = listB[2];

770+ }

771+ var out = ["Nil"];

772+ for (var i = arr.length; i--; ) {

773+ out = ["Cons", arr[i], out];

774+ }

775+ return out;

776+ }

777+ }

778+ function unzip(pairs_112) {

779+ return function() {

780+ var v = pairs_112;

781+ var c = [function(v) {

782+ if("Nil" !== v[0]) {

783+ return undefined

784+ }else {

785+ return["Tuple2", ["Nil"], ["Nil"]]

786+ }

787+ }, function(v) {

788+ if("Cons" !== v[0]) {

789+ return undefined

790+ }else {

791+ var p_113 = v[1];

792+ var ps_114 = v[2];

793+ return function(v) {

794+ if("Tuple2" !== v[0]) {

795+ return undefined

796+ }else {

797+ if("Tuple2" !== v[1][0]) {

798+ return undefined

799+ }else {

800+ var x_115 = v[1][1];

801+ var y_116 = v[1][2];

802+ if("Tuple2" !== v[2][0]) {

803+ return undefined

804+ }else {

805+ var xs_117 = v[2][1];

806+ var ys_118 = v[2][2];

807+ return["Tuple2", ["Cons", x_115, xs_117], ["Cons", y_116, ys_118]]

808+ }

809+ }

810+ }

811+ }(["Tuple2", p_113, unzip(ps_114)])

812+ }

813+ }];

814+ for(var i = c.length;i--;) {

815+ var r = c[i](v);

816+ if(r !== undefined) {

817+ return r

818+ }

819+ }

820+ }()

821+ }

822+ function intersperse(sep_119) {

823+ return function(xs_120) {

824+ return function() {

825+ var v = xs_120;

826+ var c = [function(v) {

827+ if("Nil" !== v[0]) {

828+ return undefined

829+ }else {

830+ return["Nil"]

831+ }

832+ }, function(v) {

833+ if("Cons" !== v[0]) {

834+ return undefined

835+ }else {

836+ var a_124 = v[1];

837+ if("Nil" !== v[2][0]) {

838+ return undefined

839+ }else {

840+ return["Cons", a_124, ["Nil"]]

841+ }

842+ }

843+ }, function(v) {

844+ if("Cons" !== v[0]) {

845+ return undefined

846+ }else {

847+ var a_121 = v[1];

848+ if("Cons" !== v[2][0]) {

849+ return undefined

850+ }else {

851+ var b_122 = v[2][1];

852+ var cs_123 = v[2][2];

853+ return["Cons", a_121, ["Cons", sep_119, intersperse(sep_119)(["Cons", b_122, cs_123])]]

854+ }

855+ }

856+ }];

857+ for(var i = c.length;i--;) {

858+ var r = c[i](v);

859+ if(r !== undefined) {

860+ return r

861+ }

862+ }

863+ }()

864+ }

865+ }

866+ function intercalate(sep_125) {

867+ return function(xs_126) {

868+ return function() {

869+ var v = xs_126;

870+ var c = [function(v) {

871+ if("Nil" !== v[0]) {

872+ return undefined

873+ }else {

874+ return["Nil"]

875+ }

876+ }, function(v) {

877+ if("Cons" !== v[0]) {

878+ return undefined

879+ }else {

880+ var a_130 = v[1];

881+ if("Nil" !== v[2][0]) {

882+ return undefined

883+ }else {

884+ return a_130

885+ }

886+ }

887+ }, function(v) {

888+ if("Cons" !== v[0]) {

889+ return undefined

890+ }else {

891+ var a_127 = v[1];

892+ if("Cons" !== v[2][0]) {

893+ return undefined

894+ }else {

895+ var b_128 = v[2][1];

896+ var cs_129 = v[2][2];

897+ return Value.append(a_127, Value.append(sep_125, intercalate(sep_125)(["Cons", b_128, cs_129])))

898+ }

899+ }

900+ }];

901+ for(var i = c.length;i--;) {

902+ var r = c[i](v);

903+ if(r !== undefined) {

904+ return r

905+ }

906+ }

907+ }()

908+ }

909+ }

910+ function sort(xs) {

911+ if (xs[0] === "Nil") { return xs; }

912+ if (xs[0] !== "Cons") { throwError('sort'); }

913+ var arr = [];

914+ while (xs[0] === "Cons") {

915+ arr.push(xs[1]);

916+ xs = xs[2];

917+ }

918+ arr.sort(function(a,b) { return a - b});

919+ var out = ["Nil"];

920+ for (var i = arr.length; i--; ) {

921+ out = [ "Cons", arr[i], out ];

922+ }

923+ return out;

924+ }

925+ function take(n) { return function(xs) {

926+ if (n <= 0) { return ["Nil"]; }

927+ if (xs[0] === "Nil") { return xs; }

928+ if (xs[0] !== "Cons") { throwError('take'); }

929+ var out = [ "Cons", xs[1], ["Nil"] ];

930+ var temp = out;

931+ xs = xs[2];

932+ --n;

933+ while (xs[0] === "Cons" && n > 0) {

934+ temp[2] = [ "Cons", xs[1], ["Nil"] ];

935+ temp = temp[2];

936+ xs = xs[2];

937+ --n;

938+ }

939+ return out;

940+ };

941+ }

942+ function drop(n) { return function(xs) {

943+ if (xs[0] === "Nil") { return xs; }

944+ if (xs[0] !== "Cons") { throwError('drop'); }

945+ while (xs[0] === "Cons" && n > 0) {

946+ xs = xs[2];

947+ --n;

948+ }

949+ return xs;

950+ };

951+ }

952+ return {head:head,

953+ tail:tail,

954+ last:last,

955+ map:map,

956+ foldl:foldl,

957+ foldr:foldr,

958+ foldl1:foldl1,

959+ foldr1:foldr1,

960+ scanl:scanl,

961+ scanl1:scanl1,

962+ filter:filter,

963+ length:length,

964+ reverse:reverse,

965+ concat:concat,

966+ concatMap:concatMap,

967+ and:and,

968+ or:or,

969+ all:all,

970+ any:any,

971+ sum:sum,

972+ product:product,

973+ maximum:maximum,

974+ minimum:minimum,

975+ partition:partition,

976+ zipWith:zipWith,

977+ zip:zip,

978+ unzip:unzip,

979+ intersperse:intersperse,

980+ intercalate:intercalate,

981+ sort:sort,

982+ take:take,

983+ drop:drop};

984+}();

985+Elm.Maybe = function() {

986+ function consMaybe(x) { return function(xs) {

987+ if (x[0] === "Just") return ["Cons", x[1], xs];

988+ return xs;

989+ };

990+ }

991+ function fromMaybe(b) { return function(m) {

992+ if (m[0] === "Just") return m[1];

993+ return b;

994+ };

995+ }

996+ function mapCons(f) { return function(y) { return function(xs) {

997+ var x = f(y);

998+ if (x[0] === "Just") return ["Cons", x[1], xs];

999+ return xs;

1000+ };

1001+ };

1002+ }

1003+ function maybe(b) { return function(f) { return function(m) {

1004+ if (m[0] === "Just") return f(m[1]);

1005+ return b;

1006+ };

1007+ };

1008+ }

1009+

1010+ return {Just : function(x) { return ["Just",x]; },

1011+ Nothing : ["Nothing"],

1012+ catMaybes : Elm.List.foldr(consMaybe)(["Nil"]),

1013+ isJust : function(m) { return m[0] === "Just"; },

1014+ isNothing : function(m) { return m[0] === "Nothing"; },

1015+ fromMaybe : fromMaybe,

1016+ consMaybe : consMaybe,

1017+ mapMaybe : function(f) { return Elm.List.foldr(mapCons(f))(["Nil"]); },

1018+ maybe : maybe

1019+ };

1020+}();

1021+

1022+Elm.Char = function() {

1023+ function isBetween(lo,hi) { return function(chr) {

1024+ var c = chr.charCodeAt(0);

1025+ return lo <= c && c <= hi;

1026+ };

1027+ }

1028+ var isDigit = isBetween('0'.charCodeAt(0),'9'.charCodeAt(0));

1029+ var chk1 = isBetween('a'.charCodeAt(0),'f'.charCodeAt(0));

1030+ var chk2 = isBetween('A'.charCodeAt(0),'F'.charCodeAt(0));

1031+

1032+ return {fromCode : function(c) { return String.fromCharCode(c); },

1033+ toCode : function(c) { return c.charCodeAt(0); },

1034+ toUpper : function(c) { return c.toUpperCase(); },

1035+ toLower : function(c) { return c.toLowerCase(); },

1036+ toLocaleUpper : function(c) { return c.toLocaleUpperCase(); },

1037+ toLocaleLower : function(c) { return c.toLocaleLowerCase(); },

1038+ isLower : isBetween('a'.charCodeAt(0),'z'.charCodeAt(0)),

1039+ isUpper : isBetween('A'.charCodeAt(0),'Z'.charCodeAt(0)),

1040+ isDigit : isDigit,

1041+ isOctDigit : isBetween('0'.charCodeAt(0),'7'.charCodeAt(0)),

1042+ isHexDigit : function(c) { return isDigit(c) || chk1(c) || chk2(c); }

1043+ };

1044+}();

1045+Elm.Color = function() {

1046+

1047+function Color_0(a1) {

1048+ return function(a2) {

1049+ return function(a3) {

1050+ return function(a4) {

1051+ return["Color", a1, a2, a3, a4]

1052+ }

1053+ }

1054+ }

1055+}

1056+var rgba_1 = Color_0;

1057+var red_3 = ["Color",255,0,0,1];

1058+var green_4 = ["Color",0,255,0,1];

1059+var blue_5 = ["Color",0,0,255,1];

1060+var yellow_6 = ["Color",255,255,0,1];

1061+var cyan_7 = ["Color",0,255,255,1];

1062+var magenta_8 = ["Color",255,0,255,1];

1063+var black_9 = ["Color",0,0,0,1];

1064+var white_10 = ["Color",255,255,255,1];

1065+var gray_11 = ["Color",128,128,128,1];

1066+var grey_12 = ["Color",128,128,128,1];

1067+function rgb_2(r_13) {

1068+ return function(g_14) {

1069+ return function(b_15) {

1070+ return ["Color",r_13,g_14,b_15,1]

1071+ }

1072+ }

1073+}

1074+function extract(c) {

1075+ if (c[4] === 1) { return 'rgb(' + c[1] + ',' + c[2] + ',' + c[3] + ')'; }

1076+ return 'rgba(' + c[1] + ',' + c[2] + ',' + c[3] + ',' + c[4] + ')';

1077+}

1078+function complement(rgb) {

1079+ var hsv = toHSV(rgb);

1080+ hsv.hue = (hsv.hue + 180) % 360;

1081+ return toRGB(hsv);

1082+}

1083+

1084+function hsva(h) { return function(s) { return function(v) { return function(a) {

1085+ var clr = toRGB({hue:h, saturation:s, value:v});

1086+ clr[4] = a;

1087+ return clr;

1088+ }; }; };

1089+}

1090+

1091+function hsv(h) { return function(s) { return function(v) {

1092+ return toRGB({hue:h, saturation:s, value:v}); }; }; }

1093+

1094+function toHSV(rgb) {

1095+ var hsv = {};

1096+ var r = rgb[1] / 255.0, g = rgb[2] / 255.0, b = rgb[3] / 255.0;

1097+ var M = Math.max(r,g,b);

1098+ var m = Math.min(r,g,b);

1099+ var c = M - m;

1100+

1101+ var h = 0;

1102+ if (c === 0) { h = 0; }

1103+ else if (M === r) { h = ((g - b) / c) % 6; }

1104+ else if (M === g) { h = ((b - r) / c) + 2; }

1105+ else if (M === b) { h = ((r - g) / c) + 4; }

1106+ h *= 60;

1107+

1108+ return { value : M, hue : h, saturation : (M === 0 ? 0 : c / M) };

1109+}

1110+

1111+function between(lo,hi,x) { return lo <= x && x < hi; }

1112+function norm(n) { return Math.round(n*255); }

1113+

1114+function toRGB(hsv) {

1115+ var c = hsv.value * hsv.saturation;

1116+ var hue = hsv.hue / 60;

1117+ var x = c * (1 - Math.abs((hue % 2) - 1));

1118+ var r = 0, g = 0, b = 0;

1119+ if (between(0,1,hue)) { r = c; g = x; b = 0; }

1120+ else if (between(1,2,hue)) { r = x; g = c; b = 0; }

1121+ else if (between(2,3,hue)) { r = 0; g = c; b = x; }

1122+ else if (between(3,4,hue)) { r = 0; g = x; b = c; }

1123+ else if (between(4,5,hue)) { r = x; g = 0; b = c; }

1124+ else if (between(5,6,hue)) { r = c; g = 0; b = x; }

1125+

1126+ var m = hsv.value - c;

1127+ return ["Color", norm(r+m), norm(g+m), norm(b+m), 1 ];

1128+}

1129+ return{rgba:rgba_1, rgb:rgb_2, hsva:hsva, hsv:hsv, red:red_3, green:green_4, blue:blue_5, yellow:yellow_6, cyan:cyan_7, magenta:magenta_8, black:black_9, white:white_10, gray:gray_11, grey:grey_12,complement:complement,extract:extract}

1130+}();

1131+var Collage = function() {

1132+

1133+var JS = Elm.JavaScript;

1134+

1135+function tracePoints(ctx,points) {

1136+ var i = points.length - 1;

1137+ if (i <= 0) return;

1138+ ctx.moveTo(points[i][1], points[i][2]);

1139+ while (i--) { ctx.lineTo(points[i][1], points[i][2]); }

1140+}

1141+

1142+function solid(ctx,color,points) {

1143+ tracePoints(ctx,points);

1144+ ctx.strokeStyle = Elm.Color.extract(color);

1145+ ctx.stroke();

1146+};

1147+

1148+function filled(ctx,color,points) {

1149+ tracePoints(ctx,points);

1150+ ctx.fillStyle = Elm.Color.extract(color);

1151+ ctx.fill();

1152+}

1153+

1154+function textured(redo,ctx,src,points) {

1155+ var img = new Image();

1156+ img.src = JS.castStringToJSString(src);

1157+ img.onload = redo;

1158+

1159+ tracePoints(ctx,points);

1160+ ctx.fillStyle = ctx.createPattern(img,'repeat');

1161+ ctx.fill();

1162+}

1163+

1164+function customLine(pattern,ctx,color,points) {

1165+ if (pattern.length === 0) { pattern = [8,4]; }

1166+ customLineHelp(ctx, pattern, points);

1167+ ctx.strokeStyle = Elm.Color.extract(color);

1168+ ctx.stroke();

1169+};

1170+

1171+var customLineHelp = function(ctx, pattern, points) {

1172+ var i = points.length - 1;

1173+ if (i <= 0) return;

1174+ var x0 = points[i][1], y0 = points[i][2];

1175+ var x1=0, y1=0, dx=0, dy=0, remaining=0, nx=0, ny=0;

1176+ var pindex = 0, plen = pattern.length;

1177+ var draw = true, segmentLength = pattern[0];

1178+ ctx.moveTo(x0,y0);

1179+ while (i--) {

1180+ x1 = points[i][1]; y1 = points[i][2];

1181+ dx = x1 - x0; dy = y1 - y0;

1182+ remaining = Math.sqrt(dx * dx + dy * dy);

1183+ while (segmentLength <= remaining) {

1184+ x0 += dx * segmentLength / remaining;

1185+ y0 += dy * segmentLength / remaining;

1186+ ctx[draw ? 'lineTo' : 'moveTo'](x0, y0);

1187+ // update starting position

1188+ dx = x1 - x0; dy = y1 - y0;

1189+ remaining = Math.sqrt(dx * dx + dy * dy);

1190+ // update pattern

1191+ draw = !draw;

1192+ pindex = (pindex + 1) % plen;

1193+ segmentLength = pattern[pindex];

1194+ }

1195+ if (remaining > 0) {

1196+ ctx[draw ? 'lineTo' : 'moveTo'](x1, y1);

1197+ segmentLength -= remaining;

1198+ }

1199+ x0 = x1; y0 = y1;

1200+ }

1201+};

1202+

1203+function drawLine(ctx,form) {

1204+ var points = form[3][1];

1205+ switch(form[1][0]) {

1206+ case "Solid" : return solid(ctx,form[2],points);

1207+ case "Dotted": return customLine([3,3],ctx,form[2],points);

1208+ case "Dashed": return customLine([8,4],ctx,form[2],points);

1209+ case "Custom": return customLine(form[1][1],ctx,form[2],points);

1210+ }

1211+};

1212+

1213+function drawShape(redo,ctx,shapeStyle,color,points) {

1214+ switch(shapeStyle[0]) {

1215+ case "Filled": return filled(ctx,color,points);

1216+ case "Outlined": return solid(ctx,color,points);

1217+ case "Textured": return textured(redo,ctx,shapeStyle[1],points);

1218+ case "CustomOutline":

1219+ return customLine(shapeStyle[1],ctx,color,points);

1220+ }

1221+};

1222+

1223+function drawImage(redo,ctx,w,h,src) {

1224+ var img = new Image();

1225+ img.onload = redo;

1226+ img.src = JS.castStringToJSString(src);

1227+ ctx.drawImage(img,-w/2,-h/2,w,h);

1228+}

1229+

1230+function renderForm(redo,ctx,theta,scale,x,y,form) {

1231+ ctx.save();

1232+ if (x !== 0 || y !== 0) ctx.translate(x,y);

1233+ if (theta !== ~~theta) ctx.rotate(2*Math.PI*theta);

1234+ if (scale !== 1) ctx.scale(scale,scale);

1235+ ctx.beginPath();

1236+ switch(form[0]) {

1237+ case "FLine": drawLine(ctx,form); break;

1238+ case "FShape": drawShape(redo,ctx,form[1],form[2],form[3][1]); break;

1239+ case "FImage": drawImage(redo,ctx,form[1],form[2],form[3]); break;

1240+ }

1241+ ctx.restore();

1242+};

1243+

1244+function renderForms(redo,ctx,w,h,forms) {

1245+ ctx.clearRect(0,0,w,h);

1246+ for (var i = forms.length; i--; ) {

1247+ var f = forms[i];

1248+ renderForm(redo,ctx,f[1],f[2],f[3][1],f[3][2],f[4]);

1249+ }

1250+}

1251+

1252+function collageForms(w,h,forms) {

1253+ var canvas = Render.newElement('canvas');

1254+ w = ~~w;

1255+ h = ~~h;

1256+ canvas.style.width = w + 'px';

1257+ canvas.style.height = h + 'px';

1258+ canvas.style.display = "block";

1259+ canvas.width = w;

1260+ canvas.height = h;

1261+ if (canvas.getContext) {

1262+ var ctx = canvas.getContext('2d');

1263+ function redo() { renderForms(this,ctx,w,h,forms); }

1264+ renderForms(redo,ctx,w,h,forms);

1265+ return canvas;

1266+ }

1267+ canvas.innerHTML = "Your browser does not support the canvas element.";

1268+ return canvas;

1269+};

1270+

1271+function collageElement(w,h,theta,scale,x,y,elem) {

1272+ var e = Render.render(elem);

1273+ var t = "translate(" + (x - elem[3] / 2) + "px,"+ (y - elem[4] / 2) + "px)";

1274+ var r = theta === (~~theta) ? "" : "rotate(" + theta*360 + "deg)";

1275+ var s = scale === 1 ? "" : "scale(" + scale + "," + scale + ")";

1276+ var transforms = t + " " + s + " " + r;

1277+ e.style.transform = transforms;

1278+ e.style.msTransform = transforms;

1279+ e.style.MozTransform = transforms;

1280+ e.style.webkitTransform = transforms;

1281+ e.style.OTransform = transforms;

1282+ var div = Render.newElement('div');

1283+ Render.addTo(div,e);

1284+ div.style.width = (~~w) + "px";

1285+ div.style.height = (~~h) + "px";

1286+ div.style.overflow = "hidden";

1287+ return div;

1288+}

1289+

1290+function collage(w,h,formss) {

1291+ if (formss.length === 0) { return collageForms(w,h,[]); }

1292+ var elems = new Array(formss.length);

1293+ for (var i = formss.length; i--; ) {

1294+ var f = formss[i];

1295+ if (typeof f[0] === "string") {

1296+ elems[i] = collageElement(w,h,f[1],f[2],f[3][1],f[3][2],f[4][1]);

1297+ } else {

1298+ elems[i] = collageForms(w,h,f);

1299+ }

1300+ }

1301+ if (formss.length === 1) { return elems[0]; }

1302+ return Render.flowWith(Render.goIn,function(x){return x},elems);

1303+}

1304+

1305+function updateFormSet(node,currSet,nextSet) {

1306+ if (Value.eq(nextSet,currSet)) return;

1307+ var w = node.style.width.slice(0,-2) - 0;

1308+ var h = node.style.height.slice(0,-2) - 0;

1309+ if (typeof nextSet[0] === "object") {

1310+ if (typeof currSet[0] === "object") {

1311+ if (node.getContext) {

1312+ var ctx = node.getContext('2d');

1313+ function redo() { renderForms(this,ctx,w,h,nextSet); }

1314+ return renderForms(redo,ctx,w,h,nextSet);

1315+ }

1316+ }

1317+ var newNode = collageForms(w,h,nextSet);

1318+ newNode.style.position = 'absolute';

1319+ return node.parentNode.replaceChild(newNode,node);

1320+ }

1321+ var f = nextSet;

1322+ var newNode = collageElement(w,h,f[1],f[2],f[3][1],f[3][2],f[4][1]);

1323+ newNode.style.position = 'absolute';

1324+ return node.parentNode.replaceChild(newNode,node);

1325+}

1326+

1327+// assumes that the form sets are the same length.

1328+function updateCollage(node,currs,nexts) {

1329+ if (nexts.length === 1) {

1330+ return updateFormSet(node,currs[0],nexts[0]);

1331+ }

1332+ var kids = node.childNodes;

1333+ var len = kids.length;

1334+ for (var i = len; i--; ) {

1335+ updateFormSet(kids[len-i-1], currs[i], nexts[i]);

1336+ }

1337+}

1338+

1339+function style(clr,n,list) {

1340+ return ["Tuple2",

1341+ '' + n + '',

1342+ list];

1343+}

1344+

1345+function insideForm(point) { return function(form) {

1346+ if (!inBoundsOf(point[1],point[2],form)) return false;

1347+ var hw, hh;

1348+ switch (form[4][0]) {

1349+ case "FShape": return insideShape(point,form[1],form[2],form[3],form[4][3][1]);

1350+ case "FLine": return false;

1351+ case "FImage":

1352+ hw = form[4][1] / 2;

1353+ hh = form[4][2] / 2;

1354+ break;

1355+ case "FElement":

1356+ hw = form[4][1][3] / 2;

1357+ hh = form[4][1][4] / 2;

1358+ break;

1359+ }

1360+ return insideShape(point,form[1],form[2],form[3],

1361+ [ [null, hw, hh],

1362+ [null,-hw, hh],

1363+ [null,-hw,-hh],

1364+ [null, hw,-hh],

1365+ [null, hw, hh] ]);

1366+ };

1367+}

1368+

1369+function inBoundsOf(px,py,form) {

1370+ if (form.length < 6) {

1371+ var fx = form[3][1], fy = form[3][2];

1372+ var radiusSquared = 0;

1373+ var scale = form[2];

1374+ switch (form[4][0]) {

1375+ case "FShape":

1376+ var points = form[4][3][1];

1377+ for (var i = points.length; --i; ) {

1378+ var p = points[i];

1379+ radiusSquared = Math.max(radiusSquared, p[1]*p[1] + p[2]*p[2]);

1380+ }

1381+ radiusSquared *= scale * scale;

1382+ break;

1383+ case "FLine":

1384+ break;

1385+ case "FImage":

1386+ var x = scale * form[4][1] / 2;

1387+ var y = scale * form[4][2] / 2;

1388+ radiusSquared = x*x + y*y;

1389+ break;

1390+ case "FElement":

1391+ var x = scale * form[4][1][3] / 2;

1392+ var y = scale * form[4][1][4] / 2;

1393+ radiusSquared = x*x + y*y;

1394+ break;

1395+ }

1396+ form.push(function(px,py) {

1397+ var dx = px - fx;

1398+ var dy = py - fy;

1399+ return dx*dx + dy*dy < radiusSquared + 1;

1400+ });

1401+ }

1402+ return form[5](px,py);

1403+}

1404+

1405+function insideShape(point,theta,scale,pos,points) {

1406+ var counter = 0;

1407+ var list = ["Nil"];

1408+ var p1,p2;

1409+

1410+ var x = (point[1] - pos[1]) / scale;

1411+ var y = (point[2] - pos[2]) / scale;

1412+ if (theta !== 0) {

1413+ var t = -2 * Math.PI * theta;

1414+ var nx = x * Math.cos(t) - y * Math.sin(t);

1415+ y = x * Math.sin(t) + y * Math.cos(t);

1416+ x = nx;

1417+ }

1418+

1419+ if (points.length === 0) { return false; }

1420+ p1 = points[0];

1421+ for (var i = points.length - 1; i--; ) {

1422+ p2 = points[i];

1423+ var p1x = p1[1], p1y = p1[2], p2x = p2[1], p2y = p2[2];

1424+

1425+ if (p1y < p2y) {var ymin=p1y, ymax=p2y;} else {var ymin=p2y, ymax=p1y;}

1426+ if (p1x < p2x) {var xmin=p1x, xmax=p2x;} else {var xmin=p2x, xmax=p1x;}

1427+

1428+ if (ymin < y && y <= ymax && x <= xmax) {

1429+ if (x <= xmin || x <= ((y-p1y)*(p2x-p1x)/(p2y-p1y)+p1x)) {

1430+ ++counter;

1431+ }

1432+ }

1433+ p1 = p2;

1434+ }

1435+ return (counter % 2) === 1;

1436+}

1437+

1438+return {collage:collage, updateCollage:updateCollage, insideForm:insideForm};

1439+

1440+}();Elm.Graphics = function() {

1441+ for (this['i'] in Elm.List) {

1442+ eval('var ' + this['i'] + ' = Elm.List[this.i];');

1443+ }

1444+ var JS = Elm.JavaScript;

1445+ var DLeft_0 = ["DLeft"];

1446+ var DRight_1 = ["DRight"];

1447+ var DUp_2 = ["DUp"];

1448+ var DDown_3 = ["DDown"];

1449+ var DIn_4 = ["DIn"];

1450+ var DOut_5 = ["DOut"];

1451+ function Absolute_12(a1) {

1452+ return["Absolute", a1]

1453+ }

1454+ function Relative_13(a1) {

1455+ return["Relative", a1]

1456+ }

1457+ var Near_14 = ["Near"];

1458+ var Mid_15 = ["Mid"];

1459+ var Far_16 = ["Far"];

1460+ function Position_17(a1) {

1461+ return function(a2) {

1462+ return["Position", a1, a2]

1463+ }

1464+ }

1465+ function PositionTL_18(a1) {

1466+ return function(a2) {

1467+ return["PositionTL", a1, a2]

1468+ }

1469+ }

1470+ function PositionTR_19(a1) {

1471+ return function(a2) {

1472+ return["PositionTR", a1, a2]

1473+ }

1474+ }

1475+ function PositionBL_20(a1) {

1476+ return function(a2) {

1477+ return["PositionBL", a1, a2]

1478+ }

1479+ }

1480+ function PositionBR_21(a1) {

1481+ return function(a2) {

1482+ return["PositionBR", a1, a2]

1483+ }

1484+ }

1485+ function Element_37(id,e,w,h,o,c,l) {

1486+ return["Element", id, e, w, h, o, c, l ]

1487+ }

1488+ function EText_39(a1) {

1489+ return function(a2) {

1490+ return["EText", a1, a2]

1491+ }

1492+ }

1493+ function EImage_40(a1) {

1494+ return["EImage", JS.castStringToJSString(a1)]

1495+ }

1496+ function EVideo_41(a1) {

1497+ return["EVideo", JS.castStringToJSString(a1)]

1498+ }

1499+ function EFittedImage_42(a1) {

1500+ return["EFittedImage", JS.castStringToJSString(a1)]

1501+ }

1502+ function EFlow_43(a1) {

1503+ return function(a2) {

1504+ return["EFlow", a1, JS.castListToJSArray(a2)]

1505+ }

1506+ }

1507+ function ECollage_44(a1) {

1508+ return function(a2) {

1509+ return function(a3) {

1510+ return["ECollage", a1, a2, Value.groupForms(a3)]

1511+ }

1512+ }

1513+ }

1514+ var EEmpty_45 = ["EEmpty"];

1515+ function EContainer_46(a1) {

1516+ return function(a2) {

1517+ return["EContainer", a1, a2]

1518+ }

1519+ }

1520+ var Solid_68 = ["Solid"];

1521+ var Dotted_69 = ["Dotted"];

1522+ var Dashed_70 = ["Dashed"];

1523+ function Custom_71(a1) {

1524+ return["Custom", JS.castListToJSArray(a1)]

1525+ }

1526+ var Filled_72 = ["Filled"];

1527+ var Outlined_73 = ["Outlined"];

1528+ function CustomOutline_74(a1) {

1529+ return["CustomOutline", JS.castListToJSArray(a1)]

1530+ }

1531+ function Line_75(a1) {

1532+ return["Line", JS.castListToJSArray(a1)]

1533+ }

1534+ function Shape_78(a1) {

1535+ return function(a2) {

1536+ var points = JS.castListToJSArray(a1);

1537+ if (points.length > 0) { points.push(points[0]); }

1538+ return["Shape", points, a2];

1539+ }

1540+ }

1541+ function Form_84(a1) {

1542+ return function(a2) {

1543+ return function(a3) {

1544+ return function(a4) {

1545+ return["Form", a1, a2, a3, a4]

1546+ }

1547+ }

1548+ }

1549+ }

1550+ function FLine_85(a1) {

1551+ return function(a2) {

1552+ return function(a3) {

1553+ return["FLine", a1, a2, a3]

1554+ }

1555+ }

1556+ }

1557+ function FShape_86(a1) {

1558+ return function(a2) {

1559+ return function(a3) {

1560+ return["FShape", a1, a2, a3]

1561+ }

1562+ }

1563+ }

1564+ function FImage_87(a1) {

1565+ return function(a2) {

1566+ return function(a3) {

1567+ return["FImage", a1, a2, JS.castStringToJSString(a3)]

1568+ }

1569+ }

1570+ }

1571+ function FElement_88(a1) {

1572+ return["FElement", a1]

1573+ }

1574+ var left_6 = DLeft_0;

1575+ var right_7 = DRight_1;

1576+ var down_8 = DDown_3;

1577+ var up_9 = DUp_2;

1578+ var inward_10 = DIn_4;

1579+ var outward_11 = DOut_5;

1580+ var topLeft_22 = Position_17(Near_14)(Near_14);

1581+ var topRight_23 = Position_17(Far_16)(Near_14);

1582+ var bottomLeft_24 = Position_17(Near_14)(Far_16);

1583+ var bottomRight_25 = Position_17(Far_16)(Far_16);

1584+ var midLeft_26 = Position_17(Near_14)(Mid_15);

1585+ var midRight_27 = Position_17(Far_16)(Mid_15);

1586+ var midTop_28 = Position_17(Mid_15)(Near_14);

1587+ var midBottom_29 = Position_17(Mid_15)(Far_16);

1588+ var middle_30 = Position_17(Mid_15)(Mid_15);

1589+ function middleAt(a1) {

1590+ return function(a2) {

1591+ return["PositionAt", a1, a2]

1592+ }

1593+ }

1594+ var topLeftAt_31 = PositionTL_18;

1595+ var topRightAt_32 = PositionTR_19;

1596+ var bottomLeftAt_33 = PositionBL_20;

1597+ var bottomRightAt_34 = PositionBR_21;

1598+ var absolute_35 = Absolute_12;

1599+ var relative_36 = Relative_13;

1600+ function newElement_38(e,w,h,o,c,l) { return Element_37(Guid.guid(),e,w,h,o,c,l); }

1601+ function basicNewElement(e,w,h) { return Element_37(Guid.guid(),e,w,h,1,["Nothing"],["Nothing"]); }

1602+ var line_76 = Line_75;

1603+ var polygon_79 = Shape_78;

1604+ function sprite_96(src) {

1605+ return function(w) {

1606+ return function(h) {

1607+ return function(pos) {

1608+ return Form_84(0)(1)(pos)(FImage_87(w)(h)(src))

1609+ }

1610+ }

1611+ }

1612+ }

1613+ function toForm_97(pos) {

1614+ return function(e) {

1615+ return Form_84(0)(1)(pos)(FElement_88(e))

1616+ }

1617+ }

1618+ function width_47(w__101) {

1619+ return function(e) {

1620+ var be = e[2];

1621+ switch(be[0]) {

1622+ case "EImage":

1623+ case "EVideo":

1624+ return newElement_38(e[2],w__101,e[4] * w__101 / e[3], e[5], e[6], e[7]);

1625+ case "EText":

1626+ var p = Value.getTextSize(w__101,e[4],be[2]);

1627+ return newElement_38(e[2], w__101, p[1], e[5], e[6], e[7]);

1628+ }

1629+ return newElement_38(e[2], w__101, e[4], e[5], e[6], e[7]);

1630+ }

1631+ }

1632+ function height_48(h__108) {

1633+ return function(e) {

1634+ var be = e[2];

1635+ switch(be[0]) {

1636+ case "EImage":

1637+ case "EVideo":

1638+ return newElement_38(e[2], e[3] * h__108 / e[4], h__108, e[5], e[6], e[7]);

1639+ }

1640+ return newElement_38(e[2], e[3], h__108, e[5], e[6], e[7]);

1641+ }

1642+ }

1643+ function size_49(w) {

1644+ return function(h) {

1645+ return function(e) {

1646+ return newElement_38(e[2], w, h, e[5], e[6], e[7]);

1647+ }

1648+ }

1649+ }

1650+ function opacity_50(o) {

1651+ return function(e) {

1652+ return newElement_38(e[2], e[3], e[4], o, e[6], e[7]);

1653+ }

1654+ }

1655+ function color_51(c) {

1656+ return function(e) {

1657+ return newElement_38(e[2], e[3], e[4], e[5], ["Just",c], e[7]);

1658+ }

1659+ }

1660+ function link(lnk) {

1661+ return function(e) {

1662+ return newElement_38(e[2], e[3], e[4], e[5], e[6], ["Just", JS.castStringToJSString(lnk)]);

1663+ }

1664+ }

1665+ function widthOf_52(e) { return ~~e[3]; }

1666+ function heightOf_53(e) { return ~~e[4]; }

1667+ function sizeOf_54(e) { return["Tuple2", ~~e[3], ~~e[4]] }

1668+ function text_56(txt) {

1669+ var p = Value.getTextSize(0,0,txt);

1670+ return basicNewElement(EText_39("left")(txt), p[0], p[1])

1671+ }

1672+ function plainText(str) {

1673+ var txt = Value.toText(str);

1674+ var p = Value.getTextSize(0,0,txt);

1675+ return basicNewElement(EText_39("left")(txt),p[0],p[1])

1676+ }

1677+ function asText(v) {

1678+ var txt = Elm.Text.monospace(Value.toText(Value.show(v)));

1679+ var p = Value.getTextSize(0,0,txt);

1680+ return basicNewElement(EText_39("left")(txt),p[0],p[1])

1681+ }

1682+ function centeredText(txt) {

1683+ var p = Value.getTextSize(0,0,txt);

1684+ return basicNewElement(EText_39("center")(txt),p[0],p[1])

1685+ }

1686+ function justifiedText(txt) {

1687+ var p = Value.getTextSize(0,0,txt);

1688+ return basicNewElement(EText_39("justify")(txt),p[0],p[1])

1689+ }

1690+ function rightedText(txt) {

1691+ var p = Value.getTextSize(0,0,txt);

1692+ return basicNewElement(EText_39("right")(txt),p[0],p[1])

1693+ }

1694+ function image_57(w) {

1695+ return function(h) {

1696+ return function(src) {

1697+ return basicNewElement(EImage_40(src),w,h)

1698+ }

1699+ }

1700+ }

1701+ function images(srcs) {

1702+ var pics = Elm.Signal.constant(spacer_66(0)(0));

1703+ var update = Elm.Signal.lift(function(src) {

1704+ src = JS.castStringToJSString(src);

1705+ var img = new Image();

1706+ img.onload = function() {

1707+ Dispatcher.notify(pics.id,

1708+ image_57(this.width)(this.height)(src));

1709+ };

1710+ img.src = src;

1711+ })(srcs);

1712+ function f(x) { return function(y) { return x; } }

1713+ var combine = Elm.Signal.lift2(f)(pics)(update);

1714+ return combine;

1715+ }

1716+ function video_58(w) {

1717+ return function(h) {

1718+ return function(src) {

1719+ return basicNewElement(EVideo_41(src),w,h)

1720+ }

1721+ }

1722+ }

1723+ function fittedImage_59(w_147) {

1724+ return function(h_148) {

1725+ return function(s_149) {

1726+ return basicNewElement(EFittedImage_42(s_149),w_147,h_148)

1727+ }

1728+ }

1729+ }

1730+ function flow_60(dir_150) {

1731+ return function(es_151) {

1732+ return function() {

1733+ var w_152 = function() {

1734+ var ws_154 = map(widthOf_52)(es_151);

1735+ return function(case1) {

1736+ var case0 = case1;

1737+ switch(case0[0]) {

1738+ case "DLeft":

1739+ return sum(ws_154);

1740+ case "DRight":

1741+ return sum(ws_154)

1742+ }

1743+ return maximum(ws_154)

1744+ }(dir_150)

1745+ }();

1746+ var h_153 = function() {

1747+ var hs_155 = map(heightOf_53)(es_151);

1748+ return function(case3) {

1749+ var case2 = case3;

1750+ switch(case2[0]) {

1751+ case "DDown":

1752+ return sum(hs_155);

1753+ case "DUp":

1754+ return sum(hs_155)

1755+ }

1756+ return maximum(hs_155)

1757+ }(dir_150)

1758+ }();

1759+ return basicNewElement(EFlow_43(dir_150)(es_151), w_152, h_153)

1760+ }()

1761+ }

1762+ }

1763+ function above_61(e1_156) {

1764+ return function(e2_157) {

1765+ return basicNewElement(EFlow_43(DDown_3)(["Cons", e1_156, ["Cons", e2_157, ["Nil"]]]), Math.max(widthOf_52(e1_156),widthOf_52(e2_157)), heightOf_53(e1_156) + heightOf_53(e2_157));

1766+ }

1767+ }

1768+ function below_62(e1_158) {

1769+ return function(e2_159) {

1770+ return basicNewElement(EFlow_43(DDown_3)(["Cons", e2_159, ["Cons", e1_158, ["Nil"]]]), Math.max(widthOf_52(e1_158),widthOf_52(e2_159)), heightOf_53(e1_158) + heightOf_53(e2_159));

1771+ }

1772+ }

1773+ function beside_63(e1_160) {

1774+ return function(e2_161) {

1775+ return basicNewElement(EFlow_43(DRight_1)(["Cons", e1_160, ["Cons", e2_161, ["Nil"]]]), widthOf_52(e1_160) + widthOf_52(e2_161), Math.max(heightOf_53(e1_160),heightOf_53(e2_161)));

1776+ }

1777+ }

1778+ function layers_64(es_162) {

1779+ return basicNewElement(EFlow_43(DOut_5)(es_162), maximum(map(widthOf_52)(es_162)), maximum(map(heightOf_53)(es_162)))

1780+ }

1781+ function collage_65(w_163) {

1782+ return function(h_164) {

1783+ return function(forms_165) {

1784+ return basicNewElement(ECollage_44(w_163)(h_164)(forms_165),w_163,h_164)

1785+ }

1786+ }

1787+ }

1788+ function spacer_66(w_166) {

1789+ return function(h_167) {

1790+ return basicNewElement(EEmpty_45,w_166,h_167)

1791+ }

1792+ }

1793+ function container_67(w_169) {

1794+ return function(h_170) {

1795+ return function(pos_168) {

1796+ return function(e_171) {

1797+ return basicNewElement(EContainer_46(pos_168)(e_171),w_169,h_170)

1798+ }

1799+ }

1800+ }

1801+ }

1802+ function segment_77(p1_172) {

1803+ return function(p2_173) {

1804+ return Line_75(["Cons", p1_172, ["Cons", p2_173, ["Nil"]]])

1805+ }

1806+ }

1807+ function rect_80(w_174) {

1808+ return function(h_175) {

1809+ return function(pos_176) {

1810+ return Shape_78(["Cons", ["Tuple2", 0 - w_174 / 2, 0 - h_175 / 2],

1811+ ["Cons", ["Tuple2", 0 - w_174 / 2, h_175 / 2],

1812+ ["Cons", ["Tuple2", w_174 / 2, h_175 / 2],

1813+ ["Cons", ["Tuple2", w_174 / 2, 0 - h_175 / 2], ["Nil"]]]]])(pos_176)

1814+ }

1815+ }

1816+ }

1817+ function oval_81(w_177) {

1818+ return function(h_178) {

1819+ return function(pos_179) {

1820+ return function() {

1821+ var n_180 = 50;

1822+ return function() {

1823+ function f_181(i_182) {

1824+ return["Tuple2", w_177 / 2 * Math.cos(2 * (Math.PI / n_180) * i_182), h_178 / 2 * Math.sin(2 * (Math.PI / n_180) * i_182)];

1825+ }

1826+ return Shape_78(map(f_181)(function() {

1827+ var lo = 0;

1828+ var hi = n_180 - 1;

1829+ var lst = ["Nil"];

1830+ if(lo <= hi) {

1831+ do {

1832+ lst = ["Cons", hi, lst]

1833+ }while(hi-- > lo)

1834+ }

1835+ return lst

1836+ }()))(pos_179)

1837+ }()

1838+ }()

1839+ }

1840+ }

1841+ }

1842+ function circle_82(r_183) {

1843+ return oval_81(2 * r_183)(2 * r_183)

1844+ }

1845+ function ngon_83(n_184) {

1846+ return function(r_185) {

1847+ return function(pos_186) {

1848+ return function() {

1849+ var m_187 = n_184;

1850+ return function() {

1851+ function f_188(i_189) {

1852+ return["Tuple2", r_185 * Math.cos(2 * (Math.PI / m_187) * i_189), r_185 * Math.sin(2 * (Math.PI / m_187) * i_189)];

1853+ }

1854+ return Shape_78(map(f_188)(function() {

1855+ var lo = 0;

1856+ var hi = n_184 - 1;

1857+ var lst = ["Nil"];

1858+ if(lo <= hi) {

1859+ do {

1860+ lst = ["Cons", hi, lst]

1861+ }while(hi-- > lo)

1862+ }

1863+ return lst

1864+ }()))(pos_186)

1865+ }()

1866+ }()

1867+ }

1868+ }

1869+ }

1870+ function solid_89(clr_190) {

1871+ return function(ln_191) {

1872+ return Form_84(0)(1)(["Tuple2", 0, 0])(FLine_85(Solid_68)(clr_190)(ln_191))

1873+ }

1874+ }

1875+ function dotted_90(clr_192) {

1876+ return function(ln_193) {

1877+ return Form_84(0)(1)(["Tuple2", 0, 0])(FLine_85(Dotted_69)(clr_192)(ln_193))

1878+ }

1879+ }

1880+ function dashed_91(clr_194) {

1881+ return function(ln_195) {

1882+ return Form_84(0)(1)(["Tuple2", 0, 0])(FLine_85(Dashed_70)(clr_194)(ln_195))

1883+ }

1884+ }

1885+ function customLine_92(pattern_196) {

1886+ return function(clr_197) {

1887+ return function(ln_198) {

1888+ return Form_84(0)(1)(["Tuple2", 0, 0])(FLine_85(Custom_71(pattern_196))(clr_197)(ln_198))

1889+ }

1890+ }

1891+ }

1892+ function filled_93(clr) {

1893+ return function(shape) {

1894+ return Form_84(0)(1)(shape[2])(FShape_86(Filled_72)(clr)(shape));

1895+ }

1896+ }

1897+ function outlined_94(clr) {

1898+ return function(shape) {

1899+ return Form_84(0)(1)(shape[2])(FShape_86(Outlined_73)(clr)(shape));

1900+ }

1901+ }

1902+ function customOutline_95(pattern) {

1903+ return function(clr) {

1904+ return function(shape) {

1905+ return Form_84(0)(1)(shape[2])(FShape_86(CustomOutline_74(pattern))(clr)(shape));

1906+ }

1907+ }

1908+ }

1909+ function textured(src) {

1910+ return function(shape) {

1911+ return Form_84(0)(1)(shape[2])(FShape_86(["Textured",src])(null)(shape));

1912+ }

1913+ }

1914+ function rotate_98(t_212) {

1915+ return function(Form$thetascaleposform_213) {

1916+ return function(case5) {

1917+ var case0 = case5;

1918+ switch(case0[0]) {

1919+ case "Form":

1920+ var case1 = case0[1], case2 = case0[2], case3 = case0[3], case4 = case0[4];

1921+ return Form_84(t_212 + case1)(case2)(case3)(case4)

1922+ }

1923+ throw"Non-exhaustive pattern match in case";

1924+ }(Form$thetascaleposform_213)

1925+ }

1926+ }

1927+ function scale_99(s) {

1928+ return function(form) {

1929+ return Form_84(form[1])(s * form[2])(form[3])(form[4])

1930+ }

1931+ }

1932+ function move_100(x_224) {

1933+ return function(y_225) {

1934+ return function(Form$thetascaleTuple2$pxpyform_226) {

1935+ return function(case7) {

1936+ var case0 = case7;

1937+ switch(case0[0]) {

1938+ case "Form":

1939+ var case1 = case0[1], case2 = case0[2], case3 = case0[3], case4 = case0[4];

1940+ switch(case3[0]) {

1941+ case "Tuple2":

1942+ var case5 = case3[1], case6 = case3[2];

1943+ return Form_84(case1)(case2)(["Tuple2", x_224 + case5, y_225 + case6])(case4)

1944+ }

1945+ break

1946+ }

1947+ throw"Non-exhaustive pattern match in case";

1948+ }(Form$thetascaleTuple2$pxpyform_226)

1949+ }

1950+ }

1951+ }

1952+ return{left:left_6, right:right_7, down:down_8, up:up_9, inward:inward_10, outward:outward_11, topLeft:topLeft_22, topRight:topRight_23, bottomLeft:bottomLeft_24, bottomRight:bottomRight_25, midLeft:midLeft_26, midRight:midRight_27, midTop:midTop_28, midBottom:midBottom_29, middle:middle_30, middleAt:middleAt, topLeftAt:topLeftAt_31, topRightAt:topRightAt_32, bottomLeftAt:bottomLeftAt_33, bottomRightAt:bottomRightAt_34, absolute:absolute_35, relative:relative_36, width:width_47, height:height_48, size:size_49, opacity:opacity_50,

1953+ color:color_51, link:link, widthOf:widthOf_52, heightOf:heightOf_53, sizeOf:sizeOf_54, text:text_56, asText:asText, plainText:plainText, centeredText:centeredText, justifiedText:justifiedText, rightedText:rightedText, image:image_57, images:images, video:video_58, fittedImage:fittedImage_59, flow:flow_60, above:above_61, below:below_62, beside:beside_63, layers:layers_64, collage:collage_65, spacer:spacer_66, container:container_67, line:line_76, segment:segment_77, polygon:polygon_79, rect:rect_80, oval:oval_81, circle:circle_82, ngon:ngon_83, solid:solid_89, dotted:dotted_90, dashed:dashed_91, customLine:customLine_92, filled:filled_93,

1954+ outlined:outlined_94, customOutline:customOutline_95, textured:textured, sprite:sprite_96, toForm:toForm_97, rotate:rotate_98, scale:scale_99, move:move_100,

1955+ isWithin: Collage.insideForm}

1956+}();

1957+Elm.Text = function() {

1958+ function fromString(s) { return Value.toText(s); }

1959+

1960+ var addTag = function(tag) { return function(text) {

1961+ return '<' + tag + ' style="padding:0;margin:0">' + text + '</' + tag + '>';

1962+ };

1963+ };

1964+ var addStyle = function(style, value) { return function(text) {

1965+ return "" + text + "";

1966+ };

1967+ };

1968+

1969+ var typeface = function(name) {

1970+ name = Elm.JavaScript.castStringToJSString(name);

1971+ return addStyle('font-family', name);

1972+ };

1973+ var size = function(px) {

1974+ return addStyle('font-size', px + 'px');

1975+ };

1976+ var header = addTag('h1');

1977+ var height = function(h) { return addStyle('font-size', h+'em'); }

1978+ var italic = addStyle('font-style', 'italic');

1979+ var bold = addTag('b');

1980+ var color = function(c) {

1981+ return addStyle('color', Elm.Color.extract(c));

1982+ };

1983+ var underline = addStyle('text-decoration', 'underline');

1984+ var overline = addStyle('text-decoration', 'overline');

1985+ var strikeThrough = addStyle('text-decoration', 'line-through');

1986+ var link = function(href) { return function(text) {

1987+ return "<a href='" + fromString(href) + "'>" + text + "</a>";

1988+ };

1989+ };

1990+

1991+ return {fromString : fromString,

1992+ toText: fromString,

1993+ header : header,

1994+ height : height,

1995+ italic : italic,

1996+ bold : bold,

1997+ underline : underline,

1998+ overline : overline,

1999+ strikeThrough : strikeThrough,

2000+ monospace : typeface('monospace'),

2001+ typeface : typeface,

2002+ color : color,

2003+ link : link };

2004+}();

2005+

2006+var Render = function(){

2007+

2008+function newElement(elementType) {

2009+ var e = document.createElement(elementType);

2010+ e.style.padding = "0";

2011+ e.style.margin = "0";

2012+ return e;

2013+};

2014+

2015+function addTo(container, elem) {

2016+ container.appendChild(elem);

2017+};

2018+

2019+function makeText(pos,txt) {

2020+ var e = newElement('div');

2021+ e.innerHTML = txt;

2022+ e.style.textAlign = pos;

2023+ return e;

2024+};

2025+

2026+function image(src) {

2027+ var img = newElement('img');

2028+ img.src = src;

2029+ img.name = src;

2030+ img.style.display = "block";

2031+ return img;

2032+}

2033+

2034+function fittedImage(w,h,src) {

2035+ var e = newElement('div');

2036+ e.style.width = w + 'px';

2037+ e.style.height = h + 'px';

2038+ e.style.position = "relative";

2039+ e.style.overflow = "hidden";

2040+

2041+ var img = newElement('img');

2042+ img.onload = function() {

2043+ img.style.position = 'absolute';

2044+ img.style.margin = 'auto';

2045+

2046+ var sw = w, sh = h;

2047+ if (w / h > this.width / this.height) {

2048+ sh = Math.round(this.height * w / this.width);

2049+ } else {

2050+ sw = Math.round(this.width * h / this.height);

2051+ }

2052+ img.style.width = sw + 'px';

2053+ img.style.height = sh + 'px';

2054+ img.style.left = ((w - sw) / 2) + 'px';

2055+ img.style.top = ((h - sh) / 2) + 'px';

2056+ };

2057+ img.src = src;

2058+ img.name = src;

2059+ addTo(e,img);

2060+ return e;

2061+};

2062+

2063+var video = function(src) {

2064+ var e = newElement('video');

2065+ e.controls = "controls";

2066+ var source = newElement('source');

2067+ source.src = src;

2068+ var segs = src.split('.');

2069+ source.type = "video/" + segs[segs.length-1];

2070+ addTo(e, source);

2071+ e.style.display = "block";

2072+ return e;

2073+};

2074+

2075+function divify(e) {

2076+ var div = newElement('div');

2077+ addTo(div, e);

2078+ return div;

2079+};

2080+function goDown(e) {

2081+ return e //.tagName === "DIV" ? e : divify(e);

2082+};

2083+function goRight(e) {

2084+ e.style.styleFloat = "left";

2085+ e.style.cssFloat = "left";

2086+ return e;

2087+};

2088+function goIn(e) {

2089+ e.style.position = 'absolute';

2090+ return e;

2091+};

2092+function flowWith(f, prep, elist) {

2093+ var container = newElement('div');

2094+ for (var i = elist.length; i--; ) {

2095+ addTo(container, f(prep(elist[i])));

2096+ }

2097+ return container;

2098+};

2099+

2100+function flow(dir,elist) {

2101+ switch(dir) {

2102+ case "DDown": elist = elist.slice(0).reverse();

2103+ case "DUp": return flowWith(goDown,render,elist);

2104+ case "DRight": elist = elist.slice(0).reverse();

2105+ case "DLeft": return flowWith(goRight,render,elist);

2106+ case "DOut": elist = elist.slice(0).reverse();

2107+ case "DIn": return flowWith(goIn,render,elist);

2108+ };

2109+};

2110+

2111+function toPos(pos) {

2112+ switch(pos[0]) {

2113+ case "Absolute": return pos[1] + "px";

2114+ case "Relative": return (pos[1] * 100) + "%";

2115+ }

2116+}

2117+

2118+function setPos(pos,e) {

2119+ e.style.position = 'absolute';

2120+ e.style.margin = 'auto';

2121+ switch(pos[0]) {

2122+ case "Position":

2123+ if (pos[1][0] !== "Far") e.style.left = 0;

2124+ if (pos[1][0] !== "Near") e.style.right = 0;

2125+ if (pos[2][0] !== "Far") e.style.top = 0;

2126+ if (pos[2][0] !== "Near") e.style.bottom = 0;

2127+ break;

2128+ case "PositionAt":

2129+ e.style.top = toPos(pos[2]);

2130+ e.style.left = toPos(pos[1]);

2131+ var shift = "translate(" + (-elem[3]/2) + "px," + (-elem[4]/2) + "px)";

2132+ e.style.transform = shift;

2133+ e.style.msTransform = shift;

2134+ e.style.MozTransform = shift;

2135+ e.style.webkitTransform = shift;

2136+ e.style.OTransform = shift;

2137+ break;

2138+ default:

2139+ var p = pos[0].slice(-2);

2140+ e.style[p[0] === "T" ? 'top' : 'bottom'] = toPos(pos[2]);

2141+ e.style[p[1] === "L" ? 'left' : 'right'] = toPos(pos[1]);

2142+ }

2143+}

2144+

2145+function container(pos,elem) {

2146+ var e = render(elem);

2147+ setPos(pos,e);

2148+ var div = newElement('div');

2149+ div.style.position = "relative";

2150+ div.style.overflow = "hidden";

2151+ addTo(div,e);

2152+ return div;

2153+};

2154+

2155+function render(elem) {

2156+ var e = {};

2157+ switch(elem[2][0]) {

2158+ case "EText": e = makeText(elem[2][1],elem[2][2]); break;

2159+ case "EImage": e = image(elem[2][1]); break;

2160+ case "EVideo": e = video(elem[2][1]); break;

2161+ case "EFittedImage": e = fittedImage(elem[3],elem[4],elem[2][1]); break;

2162+ case "EFlow": e = flow(elem[2][1][0],elem[2][2]); break;

2163+ case "ECollage": e = Collage.collage(elem[2][1],elem[2][2],elem[2][3]); break;

2164+ case "EEmpty": e = newElement('div'); break;

2165+ case "EContainer": e = container(elem[2][1],elem[2][2]); break;

2166+ case "EHtml":

2167+ e = elem[2][1];

2168+ if (e.type !== 'button') {

2169+ var p = Value.getExcess(e);

2170+ elem[3] -= p[0];

2171+ elem[4] -= p[1];

2172+ }

2173+ break;

2174+ case "EExternalHtml":

2175+ e = newElement('div');

2176+ addTo(e, elem[2][1]);

2177+ break;

2178+ }

2179+ e.id = elem[1];

2180+ e.style.width = (~~elem[3]) + 'px';

2181+ e.style.height = (~~elem[4]) + 'px';

2182+ if (elem[5] !== 1) { e.style.opacity = elem[5]; }

2183+ if (elem[6][0] === "Just") {

2184+ e.style.backgroundColor = Elm.Color.extract(elem[6][1]);

2185+ }

2186+ if (elem[7][0] === "Just") {

2187+ var a = newElement('a');

2188+ a.href = elem[7][1];

2189+ addTo(a,e);

2190+ return a;

2191+ }

2192+ return e;

2193+};

2194+

2195+function update(node,curr,next) {

2196+ if (node.tagName === 'A') { node = node.firstChild; }

2197+ if (curr[1] === next[1]) return;

2198+ if (curr[2][0] !== next[2][0]) {

2199+ return node.parentNode.replaceChild(render(next),node);

2200+ }

2201+ var nextE = next[2], currE = curr[2];

2202+ switch(nextE[0]) {

2203+ case "EText":

2204+ if (nextE[1] !== currE[1]) node.style.textAlign = nextE[1];

2205+ if (nextE[2] !== currE[2]) node.innerHTML = nextE[2];

2206+ break;

2207+ case "EImage":

2208+ if (nextE[1] !== currE[1]) node.src = nextE[1];

2209+ break;

2210+ case "EVideo":

2211+ case "EFittedImage":

2212+ if (!Value.eq(nextE,currE) || next[3]!==curr[3] || next[4]!==curr[4]) {

2213+ return node.parentNode.replaceChild(render(next),node);

2214+ }

2215+ break;

2216+ case "ECollage":

2217+ if (nextE[1] !== currE[1] || nextE[2] !== currE[2] || nextE[3].length !== currE[3].length) {

2218+ return node.parentNode.replaceChild(render(next),node);

2219+ }

2220+ Collage.updateCollage(node,currE[3],nextE[3]);

2221+ break;

2222+ case "EFlow":

2223+ if (nextE[1] !== currE[1]) {

2224+ return node.parentNode.replaceChild(render(next),node);

2225+ }

2226+ var nexts = nextE[2];

2227+ var kids = node.childNodes;

2228+ if (nexts.length !== kids.length) {

2229+ return node.parentNode.replaceChild(render(next),node);

2230+ }

2231+ var currs = currE[2];

2232+ var goDir = function(x) { return x; };

2233+ switch(nextE[1][0]) {

2234+ case "DDown": case "DUp": goDir = goDown; break;

2235+ case "DRight": case "DLeft": goDir = goRight; break;

2236+ case "DOut": case "DIn": goDir = goIn; break;

2237+ }

2238+ for (var i = kids.length; i-- ;) {

2239+ update(kids[i],currs[i],nexts[i]);

2240+ goDir(kids[i]);

2241+ }

2242+ break;

2243+ case "EContainer":

2244+ update(node.childNodes[0],currE[2],nextE[2]);

2245+ setPos(nextE[1],node.childNodes[0]);

2246+ break;

2247+ case "EEmpty":

2248+ break;

2249+ case "EHtml":

2250+ if (next[1] !== curr[1]) {

2251+ var e = render(next);

2252+ node.parentNode.replaceChild(e,node);

2253+ node = e;

2254+ }

2255+ if (e.type !== 'button') {

2256+ var p = Value.getExcess(node);

2257+ next[3] -= p[0];

2258+ next[4] -= p[1];

2259+ }

2260+ break;

2261+ case "EExternalHtml":

2262+ if (next[1] !== curr[1])

2263+ node.parentNode.replaceChild(render(next),node);

2264+ break;

2265+ }

2266+ if (next[3] !== curr[3]) node.style.width = (~~next[3]) + 'px';

2267+ if (next[4] !== curr[4]) node.style.height = (~~next[4]) + 'px';

2268+ if (next[5] !== curr[5]) node.style.opacity = next[5];

2269+ if (next[6].length === 2) {

2270+ var clr = Elm.Color.extract(next[6][1]);

2271+ if (clr !== node.style.backgroundColor) node.style.backgroundColor = clr;

2272+ }

2273+ if (next[7].length === 2) {

2274+ if (curr[7].length === 1 || next[7][1] !== curr[7][1]) node.parentNode.href = next[7][1];

2275+ }

2276+ next[1] = curr[1];

2277+}

2278+

2279+return {render:render,update:update,addTo:addTo,newElement:newElement,flowWith:flowWith,goIn:goIn};

2280+

2281+}();

2282+Elm.Signal = function() {

2283+ var send = function(node, timestep, changed) {

2284+ var kids = node.kids;

2285+ for (var i = kids.length; i--; ) {

2286+ kids[i].recv(timestep, changed, node.id);

2287+ }

2288+ };

2289+ /**

2290+ * @constructor

2291+ */

2292+ function input(base) {

2293+ this.id = Guid.guid();

2294+ this.value = base;

2295+ this.kids = [];

2296+ this.defaultNumberOfKids = 0;

2297+ this.recv = function(timestep, eid, v) {

2298+ var changed = eid === this.id;

2299+ if (changed) { this.value = v; }

2300+ send(this, timestep, changed);

2301+ return changed;

2302+ };

2303+ Dispatcher.inputs.push(this);

2304+ };

2305+ /**

2306+ * @constructor

2307+ */

2308+ function lift(func,args) {

2309+ this.id = Guid.guid();

2310+ this.value = null;

2311+ this.kids = [];

2312+ this.count = 0;

2313+ this.changed = false;

2314+

2315+ args.reverse();

2316+ this.recalc = function() {

2317+ var f = func;

2318+ for (var i = args.length; i--; ) {

2319+ f = f(args[i].value);

2320+ }

2321+ this.value = f;

2322+ };

2323+ this.recalc();

2324+

2325+ this.recv = function(timestep, changed, parentID) {

2326+ this.count += 1;

2327+ if (changed) { this.changed = true; }

2328+ if (this.count == args.length) {

2329+ if (this.changed) { this.recalc() }

2330+ send(this, timestep, this.changed);

2331+ this.changed = false;

2332+ this.count = 0;

2333+ }

2334+ };

2335+ for (var i = args.length; i--; ) {

2336+ args[i].kids.push(this);

2337+ }

2338+ };

2339+ /**

2340+ * @constructor

2341+ */

2342+ function fold(func,base,baseIsFunc,input) {

2343+ this.id = Guid.guid();

2344+ this.value = baseIsFunc ? base(input.value) : base;

2345+ this.kids = [];

2346+ this.recv = function(timestep, changed, parentID) {

2347+ if (changed) { this.value = func(input.value)(this.value); }

2348+ send(this, timestep, changed);

2349+ };

2350+ input.kids.push(this);

2351+ };

2352+

2353+ /**

2354+ * @constructor

2355+ */

2356+ function dropIf(pred,base,input) {

2357+ this.id = Guid.guid();

2358+ this.value = pred(input.value) ? base : input.value;

2359+ this.kids = [];

2360+ this.recv = function(timestep, changed, parentID) {

2361+ var chng = changed && !pred(input.value);

2362+ if (chng) { this.value = input.value; }

2363+ send(this, timestep, chng);

2364+ };

2365+ input.kids.push(this);

2366+ };

2367+

2368+ /**

2369+ * @constructor

2370+ */

2371+ function dropRepeats(input) {

2372+ this.id = Guid.guid();

2373+ this.value = input.value;

2374+ this.kids = [];

2375+ this.recv = function(timestep, changed, parentID) {

2376+ var chng = changed && !Value.eq(this.value,input.value);

2377+ if (chng) { this.value = input.value; }

2378+ send(this, timestep, chng);

2379+ };

2380+ input.kids.push(this);

2381+ };

2382+

2383+ var dropWhen = function(s1) { return function(b) { return function(s2) {

2384+ var pairs = new lift(function(x){return function(y){return [x,y];};},[s1,s2]);

2385+ var dropped = new dropIf(function(p){return p[0];},[true,b],pairs);

2386+ return new lift(function(p){return p[1];},[dropped]); }; };

2387+ };

2388+

2389+ /**

2390+ * @constructor

2391+ */

2392+ function sampleOn(s1,s2) {

2393+ this.id = Guid.guid();

2394+ this.value = s2.value;

2395+ this.kids = [];

2396+ this.count = 0;

2397+ this.changed = false;

2398+

2399+ this.recv = function(timestep, changed, parentID) {

2400+ if (parentID === s1.id) this.changed = changed;

2401+ this.count += 1;

2402+ if (this.count == 2) {

2403+ if (this.changed) { this.value = s2.value; }

2404+ send(this, timestep, this.changed);

2405+ this.count = 0;

2406+ this.changed = false;

2407+ }

2408+ };

2409+ s1.kids.push(this);

2410+ s2.kids.push(this);

2411+ };

2412+

2413+ function delay(t) { return function(s) {

2414+ var delayed = new input(s.value);

2415+ function update(v) {

2416+ setTimeout(function() { Dispatcher.notify(delayed.id,v); },t*1000);

2417+ }

2418+ function first(a) { return function(b) { return a; }; }

2419+ return new lift(first, [delayed, new lift(update,[s])]);

2420+ };

2421+ }

2422+

2423+ /**

2424+ * @constructor

2425+ */

2426+ function merge(s1,s2) {

2427+ this.id = Guid.guid();

2428+ this.value = s1.value;

2429+ this.kids = [];

2430+ this.next = null;

2431+ this.count = 0;

2432+ this.changed = false;

2433+

2434+ this.recv = function(timestep, changed, parentID) {

2435+ this.count += 1;

2436+ if (changed) {

2437+ this.changed = true;

2438+ if (parentID == s2.id && this.next === null) { this.next = s2.value; }

2439+ if (parentID == s1.id) { this.next = s1.value; }

2440+ }

2441+

2442+ if (this.count == 2) {

2443+ if (this.changed) {

2444+ this.value = this.next;

2445+ this.next = null;

2446+ }

2447+ send(this, timestep, this.changed);

2448+ this.changed = false;

2449+ this.count = 0;

2450+ }

2451+ };

2452+ s1.kids.push(this);

2453+ s2.kids.push(this);

2454+ };

2455+

2456+ return {

2457+ constant : function(v) { return new input(v); },

2458+ lift : function(f){return function(e){return new lift(f,[e]);};},

2459+ lift2 : function(f) { return function(e1) { return function(e2) {

2460+ return new lift(f, [e1,e2]); }; }; },

2461+ lift3 : function(f) { return function(e1) { return function(e2) {

2462+ return function(e3){return new lift(f,[e1,e2,e3]);};};};},

2463+ lift4 : function(f) { return function(e1) { return function(e2) {

2464+ return function(e3) { return function(e4) {

2465+ return new lift(f, [e1,e2,e3,e4]); }; }; }; }; },

2466+ foldp : function(f) { return function(b) { return function(e) {

2467+ return new fold(f,b,false,e); }; }; },

2468+ foldp_ : function(f) { return function(b) { return function(e) {

2469+ return new fold(f,b,true,e); }; }; },

2470+ foldp1 : function(f) { return function(e) {

2471+ return new fold(f,function(x){return x;},true,e); }; },

2472+ delay : delay,

2473+ merge : function(s1) { return function(s2) { return new merge(s1,s2)}; },

2474+ count : function(sig) {

2475+ var incr = function(_){return function(c){return c+1;};};

2476+ return new fold(incr,0,false,sig) },

2477+ countIf : function(pred) { return function(sig) {

2478+ var incr = function(x){return function(c){return pred(x) ? c+1 : c;};};

2479+ return new fold(incr,0,false,sig) }; },

2480+ keepIf : function(pred) { return function(base) { return function(sig) {

2481+ return new dropIf(function(x) { return !pred(x)},base,sig); }; }; },

2482+ dropIf : function(pred) { return function(base) { return function(sig) {

2483+ return new dropIf(pred,base,sig); }; }; },

2484+ keepWhen : function(s) { return dropWhen(new lift(function(b){return !b;},[s])); },

2485+ dropWhen : dropWhen,

2486+ dropRepeats : function(s) { return new dropRepeats(s);},

2487+ sampleOn : function(s1){return function(s2){return new sampleOn(s1,s2);};}

2488+ };

2489+}();

2490+var Dispatcher = function() {

2491+ var program = null;

2492+ var timestep = 0;

2493+ var inputs = [];

2494+ var currentElement = null;

2495+

2496+ var initialize = function() {

2497+ program = Elm.main();

2498+ if (!program.hasOwnProperty('recv')) {

2499+ program = Elm.Signal.constant(program);

2500+ }

2501+

2502+ currentElement = program.value;

2503+ filterDeadInputs();

2504+

2505+ var content = document.getElementById('content');

2506+ content.appendChild(Render.render(currentElement));

2507+ var w = document.getElementById('widthChecker').offsetWidth;

2508+ if (w !== window.innerWidth) {

2509+ Dispatcher.notify(Elm.Window.dimensions.id, Value.Tuple(w, window.innerHeight));

2510+ }

2511+ program = Elm.Signal.lift(function(value) {

2512+ var content = document.getElementById('content');

2513+ Render.update(content.firstChild,currentElement,value);

2514+ currentElement = value;

2515+ return value;

2516+ })(program);

2517+ };

2518+ var notify = function(id, v) {

2519+ timestep += 1;

2520+ var hasListener = false;

2521+ for (var i = inputs.length; i--; ) {

2522+ hasListener = inputs[i].recv(timestep, id, v) || hasListener;

2523+ }

2524+ return hasListener;

2525+ };

2526+

2527+ function isAlive(input) {

2528+ if (!input.hasOwnProperty('defaultNumberOfKids')) return true;

2529+ var len = input.kids.length;

2530+ if (len == 0) return false;

2531+ if (len > input.defaultNumberOfKids) return true;

2532+ var alive = false;

2533+ for (var i = len; i--; ) {

2534+ alive = alive || isAlive(input.kids[i]);

2535+ }

2536+ return alive;

2537+ }

2538+ function filterDeadInputs() {

2539+ var temp = [];

2540+ for (var i = inputs.length; i--; ) {

2541+ if (isAlive(inputs[i])) temp.push(inputs[i]);

2542+ }

2543+ inputs = temp;

2544+ }

2545+

2546+ return {initialize:initialize, notify:notify, inputs:inputs};

2547+}();Elm.HTTP = function() {

2548+ var JS = Elm.JavaScript;

2549+ var toElmString = Elm.JavaScript.castJSStringToString;

2550+ function request(verb) { return function(url) { return function(data) {

2551+ return function(headers) {

2552+ return {0 : "Request",

2553+ length : 1,

2554+ verb : JS.castStringToJSString(verb),

2555+ url : JS.castStringToJSString(url),

2556+ data : data === null ? null : JS.castStringToJSString(data),

2557+ headers : headers }; }; }; };

2558+ }

2559+ function get(url) { return request("GET")(url)(null)(["Nil"]); }

2560+ function post(url) { return function(data) {

2561+ return request("POST")(url)(data)(["Nil"]); }; }

2562+

2563+ function registerReq(queue,responses) { return function(req) {

2564+ if (req.url !== "") { sendReq(queue,responses,req); }

2565+ };

2566+ }

2567+

2568+ function updateQueue(queue,responses) {

2569+ if (queue.length > 0) {

2570+ Dispatcher.notify(responses.id, queue[0].value);

2571+ if (queue[0].value[0] !== "Waiting") {

2572+ queue.shift();

2573+ setTimeout(function() { updateQueue(queue,responses); }, 0);

2574+ }

2575+ }

2576+ }

2577+

2578+ function sendReq(queue,responses,req) {

2579+ var response = { value: ["Waiting"] };

2580+ queue.push(response);

2581+

2582+ var request = null;

2583+ if (window.ActiveXObject) { request = new ActiveXObject("Microsoft.XMLHTTP"); }

2584+ if (window.XMLHttpRequest) { request = new XMLHttpRequest(); }

2585+ request.onreadystatechange = function(e) {

2586+ if (request.readyState === 4) {

2587+ response.value = (request.status === 200

2588+ ? ["Success", toElmString(request.responseText)]

2589+ : ["Failure", request.status,

2590+ toElmString(request.statusText)]);

2591+ setTimeout(function() { updateQueue(queue,responses); }, 0);

2592+ }

2593+ };

2594+ request.open(req.verb, req.url, true);

2595+ Elm.List.map(function(pair) {

2596+ request.setRequestHeader(

2597+ JS.castStringToJSString(pair[1]),

2598+ JS.castStringToJSString(pair[2]));

2599+ })(req.headers);

2600+ request.send(req.data);

2601+ return null;

2602+ }

2603+

2604+ function send(requests) {

2605+ var responses = Elm.Signal.constant(["Waiting"]);

2606+ var sender = Elm.Signal.lift(registerReq([],responses))(requests);

2607+ function f(x) { return function(y) { return x; } }

2608+ var combine = Elm.Signal.lift2(f)(responses)(sender);

2609+ return combine;

2610+ }

2611+

2612+ return {get : get,

2613+ post : post,

2614+ request : request,

2615+ send : send,

2616+ sendGet : function(urls){return send(Elm.Signal.lift(get)(urls));}

2617+ };

2618+}();

2619+

2620+Elm.Input = function() {

2621+ var JS = Elm.JavaScript;

2622+ var toElmString = Elm.JavaScript.castJSStringToString;

2623+ var newTextInput = function(elem, ghostText) {

2624+ elem.placeholder = JS.castStringToJSString(ghostText);

2625+ var str = Elm.Signal.constant(["Nil"]);

2626+ Value.addListener(elem, 'keyup', function(e) {

2627+ Dispatcher.notify(str.id, toElmString(elem.value));

2628+ elem.focus();

2629+ });

2630+ elem.style.padding = "1px";

2631+ return Value.Tuple(Value.wrap(elem), str);

2632+ };

2633+ var newElement = function(name) {

2634+ var e = document.createElement(name);

2635+ e.style.padding = "0";

2636+ e.style.margin = "0";

2637+ return e;

2638+ };

2639+ var textArea = function(cols) { return function(rows) {

2640+ var textarea = newElement('textarea');

2641+ textarea.rows = rows;

2642+ textarea.cols = cols;

2643+ return newTextInput(textarea, "");

2644+ };

2645+ };

2646+ var textField = function(ghostText) {

2647+ var field = newElement('input');

2648+ field.type = 'text';

2649+ return newTextInput(field, ghostText);

2650+ };

2651+ var password = function(ghostText) {

2652+ var field = newElement('input');

2653+ field.type = 'password';

2654+ return newTextInput(field, ghostText);

2655+ };

2656+ var checkbox = function(checked) {

2657+ var box = newElement('input');

2658+ box.type = 'checkbox';

2659+ box.checked = checked;

2660+ var status = Elm.Signal.constant(checked);

2661+ Value.addListener(box, 'change', function(e) {

2662+ Dispatcher.notify(status.id, box.checked);

2663+ });

2664+ return Value.Tuple(Value.wrap(box), status);

2665+ };

2666+ var dropDown = function(options) {

2667+ var slct = newElement('select');

2668+ var opts = [];

2669+ while (options[0] === "Cons") {

2670+ var opt = newElement('option');

2671+ var str = Value.toText(options[1][1]);

2672+ opt.value = str;

2673+ opt.innerHTML = str;

2674+ slct.appendChild(opt);

2675+ opts.push(options[1][2]);

2676+ options = options[2];

2677+ }

2678+ var status = Elm.Signal.constant(opts[0]);

2679+ Value.addListener(slct, 'change', function(e) {

2680+ Dispatcher.notify(status.id, opts[slct.selectedIndex]);

2681+ });

2682+ return Value.Tuple(Value.wrap(slct), status);

2683+ };

2684+ var stringDropDown = function(opts) {

2685+ return dropDown(Elm.List.map (function(x) {return Value.Tuple(x,x);}) (opts));

2686+ };

2687+ var button = function(name) {

2688+ var b = newElement('input');

2689+ b.type = "button";

2690+ b.value = JS.castStringToJSString(name);

2691+ var press = Elm.Signal.constant(false);

2692+ Value.addListener(b, 'click', function(e) {

2693+ Dispatcher.notify(press.id, true);

2694+ Dispatcher.notify(press.id, false);

2695+ });

2696+ return Value.Tuple(Value.wrap(b),press);

2697+ };

2698+ return {textArea:textArea, textField:textField,

2699+ password:password, checkbox:checkbox,

2700+ dropDown:dropDown, stringDropDown:stringDropDown,

2701+ button:button};

2702+}();

2703+

2704+Elm.Keyboard = { Raw : function() {

2705+ var keysDown = Elm.Signal.constant(["Nil"]);

2706+ var charPressed = Elm.Signal.constant(["Nothing"]);

2707+ function remove(x,xs) {

2708+ if (xs[0] === "Nil") return xs;

2709+ if (xs[1] === x) return xs[2];

2710+ return ["Cons", xs[1], remove(x,xs[2])];

2711+ }

2712+ function has(x,xs) {

2713+ while (xs[0] !== "Nil") {

2714+ if (xs[1] === x) return true;

2715+ xs = xs[2];

2716+ }

2717+ return false;

2718+ }

2719+ Value.addListener(document, 'keydown', function(e) {

2720+ if (has(e.keyCode, keysDown.value)) return;

2721+ var hasListener = Dispatcher.notify(keysDown.id, ["Cons", e.keyCode, keysDown.value]);

2722+ if (!hasListener)

2723+ this.removeEventListener('keydown',arguments.callee,false);

2724+ });

2725+ Value.addListener(document, 'keyup', function(e) {

2726+ var codes = remove(e.keyCode, keysDown.value);

2727+ var hasListener = Dispatcher.notify(keysDown.id, codes);

2728+ if (!hasListener)

2729+ this.removeEventListener('keyup',arguments.callee,false);

2730+ });

2731+ Value.addListener(window, 'blur', function(e) {

2732+ var hasListener = Dispatcher.notify(keysDown.id, ["Nil"]);

2733+ if (!hasListener)

2734+ this.removeEventListener('blur',arguments.callee,false);

2735+ });

2736+ Value.addListener(document, 'keypress', function(e) {

2737+ var hasListener = Dispatcher.notify(charPressed.id, ["Just",e.charCode || e.keyCode]);

2738+ Dispatcher.notify(charPressed.id, ["Nothing"]);

2739+ if (!hasListener)

2740+ this.removeEventListener('keypress',arguments.callee,false);

2741+ });

2742+ return {keysDown:keysDown,

2743+ charPressed:charPressed};

2744+ }()

2745+};

2746+Elm.Mouse = function() {

2747+ var position = Elm.Signal.constant(Value.Tuple(0,0));

2748+ position.defaultNumberOfKids = 2;

2749+

2750+ var x = Elm.Signal.lift(function(p){return p[1];})(position);

2751+ x.defaultNumberOfKids = 0;

2752+ var y = Elm.Signal.lift(function(p){return p[2];})(position);

2753+ y.defaultNumberOfKids = 0;

2754+

2755+ var isDown = Elm.Signal.constant(false);

2756+ var isClicked = Elm.Signal.constant(false);

2757+ var clicks = Elm.Signal.constant(Value.Tuple());

2758+

2759+ function getXY(e) {

2760+ var posx = 0;

2761+ var posy = 0;

2762+ if (!e) e = window.event;

2763+ if (e.pageX || e.pageY) {

2764+ posx = e.pageX;

2765+ posy = e.pageY;

2766+ } else if (e.clientX || e.clientY) {

2767+ posx = e.clientX + document.body.scrollLeft +

2768+ document.documentElement.scrollLeft;

2769+ posy = e.clientY + document.body.scrollTop +

2770+ document.documentElement.scrollTop;

2771+ }

2772+ return Value.Tuple(posx, posy);

2773+ }

2774+

2775+ Value.addListener(document, 'click', function(e) {

2776+ var hasListener1 = Dispatcher.notify(isClicked.id, true);

2777+ var hasListener2 = Dispatcher.notify(clicks.id, Value.Tuple());

2778+ Dispatcher.notify(isClicked.id, false);

2779+ if (!hasListener1 && !hasListener2)

2780+ this.removeEventListener('click',arguments.callee,false);

2781+ });

2782+ Value.addListener(document, 'mousedown', function(e) {

2783+ var hasListener = Dispatcher.notify(isDown.id, true);

2784+ if (!hasListener)

2785+ this.removeEventListener('mousedown',arguments.callee,false);

2786+ });

2787+ Value.addListener(document, 'mouseup', function(e) {

2788+ var hasListener = Dispatcher.notify(isDown.id, false);

2789+ if (!hasListener)

2790+ this.removeEventListener('mouseup',arguments.callee,false);

2791+ });

2792+ Value.addListener(document, 'mousemove', function(e) {

2793+ var hasListener = Dispatcher.notify(position.id, getXY(e));

2794+ if (!hasListener)

2795+ this.removeEventListener('mousemove',arguments.callee,false);

2796+ });

2797+ var clickedOn = function(elem) {

2798+ var node = Render.render(elem);

2799+ var click = Elm.Signal.constant(false);

2800+ Value.addListener(node, 'click', function(e) {

2801+ Dispatcher.notify(click.id, true);

2802+ Dispatcher.notify(click.id, false);

2803+ });

2804+ return Value.Tuple(Value.wrap(node), click);

2805+ };

2806+ return {position: position,

2807+ x:x,

2808+ y:y,

2809+ isClicked: isClicked,

2810+ isDown: isDown,

2811+ clicks: clicks,

2812+ isClickedOn: clickedOn

2813+ };

2814+ }();

2815+Elm.Random = function() {

2816+ var inRange = function(min) { return function(max) {

2817+ return Elm.Signal.constant(Math.floor(Math.random() * (max-min+1)) + min);

2818+ };

2819+ };

2820+ var randomize = function(min) { return function(max) { return function(signal) {

2821+ function f(x) { return Math.floor(Math.random() * (max-min+1)) + min; }

2822+ return Elm.Signal.lift(f)(signal);

2823+ };

2824+ };

2825+ };

2826+ return { inRange:inRange, randomize:randomize };

2827+}();Elm.Time = function() {

2828+ function timeNow() { return (new window.Date).getTime(); }

2829+ var now = function(t) {

2830+ var clock = Elm.Signal.constant(timeNow());

2831+ function tellTime() { Dispatcher.notify(clock.id, timeNow()); }

2832+ setInterval(tellTime, t);

2833+ return clock;

2834+ };

2835+ function fps(desiredFPS) {

2836+ var msPerFrame = 1000 / desiredFPS;

2837+ var ticker = Elm.Signal.constant(timeNow());

2838+ function tick() { Dispatcher.notify(ticker.id, timeNow()); }

2839+ function f(t) { setTimeout(tick, msPerFrame); return t; }

2840+ return Elm.Signal.lift(f)(ticker);

2841+ }

2842+ var every = function(t) {

2843+ t *= 1000;

2844+ var clock = Elm.Signal.constant(0);

2845+ var time = 0;

2846+ setInterval(function() {

2847+ time += t;

2848+ Dispatcher.notify(clock.id, time/1000);

2849+ }, t);

2850+ return clock;

2851+ };

2852+ var after = function(t) {

2853+ t *= 1000;

2854+ var thread = Elm.Signal.constant(false);

2855+ setTimeout(function() { Dispatcher.notify(thread.id, true); }, t);

2856+ return thread;

2857+ };

2858+ var before = function(t) {

2859+ t *= 1000;

2860+ var thread = Elm.Signal.constant(true);

2861+ setTimeout(function() { Dispatcher.notify(thread.id, false); }, t);

2862+ return thread;

2863+ };

2864+ function read(s) {

2865+ var t = window.Date.parse(s);

2866+ return isNaN(t) ? ["Nothing"] : ["Just",t];

2867+ }

2868+ return {now:now,

2869+ fps:fps,

2870+ every:every,

2871+ after:after,

2872+ before:before,

2873+ hours : function(n) { return n * 3600000; },

2874+ minutes : function(n) { return n * 60000; },

2875+ seconds : function(n) { return n * 1000; },

2876+ millis : function(n) { return n; },

2877+ inHours : function(t) { return ~~(t / 3600000); },

2878+ inMinutes : function(t) { return ~~(t / 60000); },

2879+ inSeconds : function(t) { return ~~(t / 1000); },

2880+ inMillis : function(t) { return t; },

2881+ toDate : function(t) { return new window.Date(t); },

2882+ read : read

2883+ };

2884+

2885+}();Elm.Window = function() {

2886+ var dimensions = Elm.Signal.constant(Value.Tuple(window.innerWidth,

2887+ window.innerHeight));

2888+ dimensions.defaultNumberOfKids = 2;

2889+

2890+ var width = Elm.Signal.lift(function(p){return p[1];})(dimensions);

2891+ width.defaultNumberOfKids = 0;

2892+ var height = Elm.Signal.lift(function(p){return p[2];})(dimensions);

2893+ height.defaultNumberOfKids = 0;

2894+

2895+ Value.addListener(window, 'resize', function(e) {

2896+ var w = document.getElementById('widthChecker').offsetWidth;

2897+ var hasListener = Dispatcher.notify(dimensions.id,

2898+ Value.Tuple(w, window.innerHeight));

2899+ if (!hasListener)

2900+ this.removeEventListener('resize',arguments.callee,false);

2901+ });

2902+ return {dimensions:dimensions,width:width,height:height};

2903+}();

2904+

2905+Elm.Date = function() {

2906+

2907+ function dateNow() { return new window.Date; }

2908+ function now(t) {

2909+ var clock = Elm.Signal.constant(dateNow());

2910+ function tellTime() { Dispatcher.notify(clock.id, dateNow()); }

2911+ setInterval(tellTime, t);

2912+ return clock;

2913+ }

2914+ function readDate(str) {

2915+ var d = new window.Date(Elm.JavaScript.castStringToJSString(str));

2916+ if (isNaN(d.getTime())) return ["Nothing"];

2917+ return ["Just",d];

2918+ }

2919+

2920+ var dayTable = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];

2921+ var monthTable = ["Jan", "Feb", "Mar", "Apr", "May", "Jun",

2922+ "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];

2923+

2924+ return {

2925+ now : now,

2926+ read : readDate,

2927+ year : function(d) { return d.getFullYear(); },

2928+ month : function(d) { return [monthTable[d.getMonth()]]; },

2929+ day : function(d) { return d.getDate(); },

2930+ hour : function(d) { return d.getHours(); },

2931+ minute : function(d) { return d.getMinutes(); },

2932+ second : function(d) { return d.getSeconds(); },

2933+ weekday : function(d) { return [dayTable[d.getDay()]]; },

2934+ toTime : function(d) { return d.getTime(); },

2935+ Mon : ["Mon"], Tue : ["Tue"], Wed : ["Wed"],

2936+ Thu : ["Thu"], Fri : ["Fri"], Sat : ["Sat"], Sun : ["Sun"],

2937+ Jan : ["Jan"], Feb : ["Feb"], Mar : ["Mar"], Apr : ["Apr"],

2938+ May : ["May"], Jun : ["Jun"], Jul : ["Jul"], Aug : ["Aug"],

2939+ Sep : ["Sep"], Oct : ["Oct"], Nov : ["Nov"], Dec : ["Dec"]

2940+ };

2941+

2942+}();

2943+

2944+Value.addListener(document, 'elm_log', function(e) { console.log(e.value); });

2945+Value.addListener(document, 'elm_title', function(e) {document.title = e.value;});

2946+Value.addListener(document, 'elm_redirect', function(e) {

2947+ if (e.value.length > 0) { window.location = e.value; }

2948+ });

2949+

2950+Elm.Prelude = function() {

2951+ var mod = function(x) { return function(y) {

2952+ var r = x % y;

2953+ var m = x==0 ? 0 : (y>0 ? (x>=0 ? r : r+y) : -mod(-x)(-y));

2954+ return m == y ? 0 : m;

2955+ }; };

2956+

2957+ var min = function(x) { return function(y) { return Math.min(x,y); }; };

2958+ var max = function(x) { return function(y) { return Math.max(x,y); }; };

2959+

2960+ var flip=function(f){return function(x){return function(y){return f(y)(x);};};};

2961+ var clamp = function(lo) { return function(hi) {

2962+ return function(x) { return Math.min(hi, Math.max(lo, x)); };

2963+ };

2964+ };

2965+ var curry = function(f) { return function(x) { return function(y) {

2966+ return f(["Tuple2",x,y]); }; };

2967+ };

2968+ var uncurry = function(f) { return function(p) {

2969+ if (p[0] !== "Tuple2") {

2970+ throw "Function was uncurry'd but was not given a pair.";

2971+ }

2972+ return f(p[1])(p[2]); };

2973+ };

2974+

2975+ var logBase=function(b){return function(x){return Math.log(x)/Math.log(b);};};

2976+

2977+ function readInt(str) {

2978+ var s = JavaScript.castStringToJSString(str);

2979+ var len = s.length;

2980+ if (len === 0) { return Nothing; }

2981+ var start = 0;

2982+ if (s[0] == '-') {

2983+ if (len === 1) { return Nothing; }

2984+ start = 1;

2985+ }

2986+ for (var i = start; i < len; ++i) {

2987+ if (!Char.isDigit(s[i])) { return Nothing; }

2988+ }

2989+ return ["Just", parseInt(s)];

2990+ }

2991+

2992+ function readFloat(str) {

2993+ var s = JavaScript.castStringToJSString(str);

2994+ var len = s.length;

2995+ if (len === 0) { return Nothing; }

2996+ var start = 0;

2997+ if (s[0] == '-') {

2998+ if (len === 1) { return Nothing; }

2999+ start = 1;

3000+ }

3001+ var dotCount = 0;

3002+ for (var i = start; i < len; ++i) {

3003+ if (Char.isDigit(s[i])) { continue; }

3004+ if (s[i] === '.') {

3005+ dotCount += 1;

3006+ if (dotCount <= 1) { continue; }

3007+ }

3008+ return Nothing;

3009+ }

3010+ return ["Just", parseFloat(s)];

3011+ }

3012+

3013+ return {eq : Value.eq,

3014+ id : function(x) { return x; },

3015+ not : function(b) { return !b; },

3016+ fst : function(p) { return p[1]; },

3017+ snd : function(p) { return p[2]; },

3018+ rem : function(x) { return function(y) { return x % y; }; },

3019+ div : function(x) { return function(y) { return ~~(x / y); }; },

3020+ otherwise : true,

3021+ compare : function(x) { return function (y) {

3022+ x = (typeof x === "object") ? toText(x) : x;

3023+ y = (typeof y === "object") ? toText(y) : y;

3024+ return [ x === y ? 'EQ' : (x < y ? 'LT' : 'GT') ];

3025+ };

3026+ },

3027+ toFloat : function(x) { return x; },

3028+ round : function(n) { return Math.round(n); },

3029+ floor : function(n) { return Math.floor(n); },

3030+ ceiling : function(n) { return Math.ceil(n); },

3031+ truncate : function(n) { return ~~n; },

3032+ readInt : readInt,

3033+ readFloat : readFloat,

3034+ sqrt : Math.sqrt,

3035+ abs : Math.abs,

3036+ pi : Math.PI,

3037+ e : Math.E,

3038+ sin : Math.sin,

3039+ cos : Math.cos,

3040+ tan : Math.tan,

3041+ asin : Math.asin,

3042+ acos : Math.acos,

3043+ atan : Math.atan,

3044+ atan2 : function(y) { return function(x) { return Math.atan2(y,x); }; },

3045+ mod : mod,

3046+ min : min,

3047+ max : max,

3048+ flip : flip,

3049+ clamp : clamp,

3050+ curry : curry,

3051+ uncurry : uncurry,

3052+ logBase : logBase,

3053+ Just : Elm.Maybe.Just,

3054+ Nothing : Elm.Maybe.Nothing,

3055+ maybe : Elm.Maybe.maybe,

3056+ map : Elm.List.map,

3057+ zip : Elm.List.zip,

3058+ zipWith : Elm.List.zipWith,

3059+ filter : Elm.List.filter,

3060+ head : Elm.List.head,

3061+ tail : Elm.List.tail,

3062+ last : Elm.List.last,

3063+ length : Elm.List.length,

3064+ reverse : Elm.List.reverse,

3065+ foldr : Elm.List.foldr,

3066+ foldr1 : Elm.List.foldr1,

3067+ foldl : Elm.List.foldl,

3068+ foldl1 : Elm.List.foldl1,

3069+ and : Elm.List.and,

3070+ or : Elm.List.or,

3071+ all : Elm.List.all,

3072+ any : Elm.List.any,

3073+ sum : Elm.List.sum,

3074+ product : Elm.List.product,

3075+ concat : Elm.List.concat,

3076+ concatMap : Elm.List.concatMap,

3077+ maximum : Elm.List.maximum,

3078+ minimum : Elm.List.minimum,

3079+ scanl : Elm.List.scanl,

3080+ scanl1 : Elm.List.scanl1,

3081+ take : Elm.List.take,

3082+ drop : Elm.List.drop,

3083+ zip : Elm.List.zip,

3084+ unzip : Elm.List.unzip,

3085+ lift : Elm.Signal.lift,

3086+ lift2 : Elm.Signal.lift2,

3087+ lift3 : Elm.Signal.lift3,

3088+ lift4 : Elm.Signal.lift4,

3089+ foldp : Elm.Signal.foldp,

3090+ foldp1 : Elm.Signal.foldp1,

3091+ foldp_ : Elm.Signal.foldp_,

3092+ constant : Elm.Signal.constant,

3093+ delay : Elm.Signal.delay,

3094+ merge : Elm.Signal.merge,

3095+ count : Elm.Signal.count,

3096+ countIf : Elm.Signal.countIf,

3097+ keepIf : Elm.Signal.keepIf,

3098+ dropIf : Elm.Signal.dropIf,

3099+ keepWhen : Elm.Signal.keepWhen,

3100+ dropWhen : Elm.Signal.dropWhen,

3101+ dropRepeats : Elm.Signal.dropRepeats,

3102+ sampleOn : Elm.Signal.sampleOn

3103+ };

3104+

3105+}();

3106+

3107+(function() {

3108+ var include = function(library) {

3109+ for (var i in library) {

3110+ Elm.Prelude[i] = library[i];

3111+ }

3112+ };

3113+ include (Elm.Color);

3114+ include (Elm.Text);

3115+ include (Elm.Graphics);

3116+

3117+ show = Value.show;

3118+

3119+}());

3120+

3121+Elm.Dict=function(){

3122+ for(this['i'] in Elm.Prelude){

3123+ eval('var ' + this['i'] + '=Elm.Prelude[this.i];'); }

3124+ var isJust=Elm.Maybe.isJust;

3125+ var Red_0=["Red"];

3126+ var Black_1=["Black"];

3127+ function RBNode_2(a1){

3128+ return function(a2){

3129+ return function(a3){

3130+ return function(a4){

3131+ return function(a5){

3132+ return ["RBNode",a1,a2,a3,a4,a5];};};};};};

3133+ var RBEmpty_3=["RBEmpty"];

3134+ var empty_4=RBEmpty_3;

3135+ var raise_5=function(x){return x;};

3136+ function min_6(t_43){

3137+ return function(){

3138+ switch(t_43[0]){

3139+ case "RBEmpty":

3140+ return raise_5(Value.str("(min RBEmpty) is not defined"));

3141+ case "RBNode":

3142+ switch(t_43[4][0]){

3143+ case "RBEmpty":

3144+ return ["Tuple2",t_43[2],t_43[3]];

3145+ }

3146+ return min_6(t_43[4]);

3147+ }

3148+ throw "Non-exhaustive pattern match in case";}();};

3149+ function lookup_7(k_47){

3150+ return function(t_48){

3151+ return function(){

3152+ switch(t_48[0]){

3153+ case "RBEmpty":

3154+ return Nothing;

3155+ case "RBNode":

3156+ return function(){

3157+ var case6=compare(k_47)(t_48[2]);

3158+ switch(case6[0]){

3159+ case "EQ":

3160+ return Just(t_48[3]);

3161+ case "GT":

3162+ return lookup_7(k_47)(t_48[5]);

3163+ case "LT":

3164+ return lookup_7(k_47)(t_48[4]);

3165+ }

3166+ throw "Non-exhaustive pattern match in case";}();

3167+ }

3168+ throw "Non-exhaustive pattern match in case";}();};};

3169+ function findWithDefault_8(base_53){

3170+ return function(k_54){

3171+ return function(t_55){

3172+ return function(){

3173+ switch(t_55[0]){

3174+ case "RBEmpty":

3175+ return base_53;

3176+ case "RBNode":

3177+ return function(){

3178+ var case6=compare(k_54)(t_55[2]);

3179+ switch(case6[0]){

3180+ case "EQ":

3181+ return t_55[3];

3182+ case "GT":

3183+ return findWithDefault_8(base_53)(k_54)(t_55[5]);

3184+ case "LT":

3185+ return findWithDefault_8(base_53)(k_54)(t_55[4]);

3186+ }

3187+ throw "Non-exhaustive pattern match in case";}();

3188+ }

3189+ throw "Non-exhaustive pattern match in case";}();};};};

3190+ function member_10(k_66){

3191+ return function(t_67){

3192+ return isJust(lookup_7(k_66)(t_67));};};

3193+ function rotateLeft_11(t_68){

3194+ return function(){

3195+ switch(t_68[0]){

3196+ case "RBNode":

3197+ switch(t_68[5][0]){

3198+ case "RBNode":

3199+ return RBNode_2(t_68[1])(t_68[5][2])(t_68[5][3])(RBNode_2(Red_0)(t_68[2])(t_68[3])(t_68[4])(t_68[5][4]))(t_68[5][5]);

3200+ }break;

3201+ }

3202+ return raise_5(Value.str("rotateLeft of a node without enough children"));}();};

3203+ function rotateRight_12(t_78){

3204+ return function(){

3205+ switch(t_78[0]){

3206+ case "RBNode":

3207+ switch(t_78[4][0]){

3208+ case "RBNode":

3209+ return RBNode_2(t_78[1])(t_78[4][2])(t_78[4][3])(t_78[4][4])(RBNode_2(Red_0)(t_78[2])(t_78[3])(t_78[4][5])(t_78[5]));

3210+ }break;

3211+ }

3212+ return raise_5(Value.str("rotateRight of a node without enough children"));}();};

3213+ function rotateLeftIfNeeded_13(t_88){

3214+ return function(){

3215+ switch(t_88[0]){

3216+ case "RBNode":

3217+ switch(t_88[5][0]){

3218+ case "RBNode":

3219+ switch(t_88[5][1][0]){

3220+ case "Red":

3221+ return rotateLeft_11(t_88);

3222+ }break;

3223+ }break;

3224+ }

3225+ return t_88;}();};

3226+ function rotateRightIfNeeded_14(t_89){

3227+ return function(){

3228+ switch(t_89[0]){

3229+ case "RBNode":

3230+ switch(t_89[4][0]){

3231+ case "RBNode":

3232+ switch(t_89[4][1][0]){

3233+ case "Red":

3234+ switch(t_89[4][4][0]){

3235+ case "RBNode":

3236+ switch(t_89[4][4][1][0]){

3237+ case "Red":

3238+ return rotateRight_12(t_89);

3239+ }break;

3240+ }break;

3241+ }break;

3242+ }break;

3243+ }

3244+ return t_89;}();};

3245+ function otherColor_15(c_90){

3246+ return function(){

3247+ switch(c_90[0]){

3248+ case "Black":

3249+ return Red_0;

3250+ case "Red":

3251+ return Black_1;

3252+ }

3253+ throw "Non-exhaustive pattern match in case";}();};

3254+ function color_flip_16(t_91){

3255+ return function(){

3256+ switch(t_91[0]){

3257+ case "RBNode":

3258+ switch(t_91[4][0]){

3259+ case "RBNode":

3260+ switch(t_91[5][0]){

3261+ case "RBNode":

3262+ return RBNode_2(otherColor_15(t_91[1]))(t_91[2])(t_91[3])(RBNode_2(otherColor_15(t_91[4][1]))(t_91[4][2])(t_91[4][3])(t_91[4][4])(t_91[4][5]))(RBNode_2(otherColor_15(t_91[5][1]))(t_91[5][2])(t_91[5][3])(t_91[5][4])(t_91[5][5]));

3263+ }break;

3264+ }break;

3265+ }

3266+ return raise_5(Value.str("color_flip called on a RBEmpty or RBNode with a RBEmpty child"));}();};

3267+ function color_flipIfNeeded_17(t_105){

3268+ return function(){

3269+ switch(t_105[0]){

3270+ case "RBNode":

3271+ switch(t_105[4][0]){

3272+ case "RBNode":

3273+ switch(t_105[4][1][0]){

3274+ case "Red":

3275+ switch(t_105[5][0]){

3276+ case "RBNode":

3277+ switch(t_105[5][1][0]){

3278+ case "Red":

3279+ return color_flip_16(t_105);

3280+ }break;

3281+ }break;

3282+ }break;

3283+ }break;

3284+ }

3285+ return t_105;}();};

3286+ function fixUp_18(t_106){

3287+ return color_flipIfNeeded_17(rotateRightIfNeeded_14(rotateLeftIfNeeded_13(t_106)));};

3288+ function ensureBlackRoot_19(t_107){

3289+ return function(){

3290+ switch(t_107[0]){

3291+ case "RBNode":

3292+ switch(t_107[1][0]){

3293+ case "Red":

3294+ return RBNode_2(Black_1)(t_107[2])(t_107[3])(t_107[4])(t_107[5]);

3295+ }break;

3296+ }

3297+ return t_107;}();};

3298+ function insert_20(k_112){

3299+ return function(v_113){

3300+ return function(t_114){

3301+ return function(){

3302+ function ins_115(t_116){

3303+ return function(){

3304+ switch(t_116[0]){

3305+ case "RBEmpty":

3306+ return RBNode_2(Red_0)(k_112)(v_113)(RBEmpty_3)(RBEmpty_3);

3307+ case "RBNode":

3308+ return function(){

3309+ var h_122=function(){

3310+ var case6=compare(k_112)(t_116[2]);

3311+ switch(case6[0]){

3312+ case "EQ":

3313+ return RBNode_2(t_116[1])(t_116[2])(v_113)(t_116[4])(t_116[5]);

3314+ case "GT":

3315+ return RBNode_2(t_116[1])(t_116[2])(t_116[3])(t_116[4])(ins_115(t_116[5]));

3316+ case "LT":

3317+ return RBNode_2(t_116[1])(t_116[2])(t_116[3])(ins_115(t_116[4]))(t_116[5]);

3318+ }

3319+ throw "Non-exhaustive pattern match in case";}();

3320+ return fixUp_18(h_122);}();

3321+ }

3322+ throw "Non-exhaustive pattern match in case";}();};

3323+ return ensureBlackRoot_19(ins_115(t_114));}();};};};

3324+ function singleton_21(k_123){

3325+ return function(v_124){

3326+ return insert_20(k_123)(v_124)(RBEmpty_3);};};

3327+ function isRed_22(t_125){

3328+ return function(){

3329+ switch(t_125[0]){

3330+ case "RBNode":

3331+ switch(t_125[1][0]){

3332+ case "Red":

3333+ return true;

3334+ }break;

3335+ }

3336+ return false;}();};

3337+ function isRedLeft_23(t_126){

3338+ return function(){

3339+ switch(t_126[0]){

3340+ case "RBNode":

3341+ switch(t_126[4][0]){

3342+ case "RBNode":

3343+ switch(t_126[4][1][0]){

3344+ case "Red":

3345+ return true;

3346+ }break;

3347+ }break;

3348+ }

3349+ return false;}();};

3350+ function isRedLeftLeft_24(t_127){

3351+ return function(){

3352+ switch(t_127[0]){

3353+ case "RBNode":

3354+ switch(t_127[4][0]){

3355+ case "RBNode":

3356+ switch(t_127[4][4][0]){

3357+ case "RBNode":

3358+ switch(t_127[4][4][1][0]){

3359+ case "Red":

3360+ return true;

3361+ }break;

3362+ }break;

3363+ }break;

3364+ }

3365+ return false;}();};

3366+ function isRedRight_25(t_128){

3367+ return function(){

3368+ switch(t_128[0]){

3369+ case "RBNode":

3370+ switch(t_128[5][0]){

3371+ case "RBNode":

3372+ switch(t_128[5][1][0]){

3373+ case "Red":

3374+ return true;

3375+ }break;

3376+ }break;

3377+ }

3378+ return false;}();};

3379+ function isRedRightLeft_26(t_129){

3380+ return function(){

3381+ switch(t_129[0]){

3382+ case "RBNode":

3383+ switch(t_129[5][0]){

3384+ case "RBNode":

3385+ switch(t_129[5][4][0]){

3386+ case "RBNode":

3387+ switch(t_129[5][4][1][0]){

3388+ case "Red":

3389+ return true;

3390+ }break;

3391+ }break;

3392+ }break;

3393+ }

3394+ return false;}();};

3395+ function moveRedLeft_27(t_130){

3396+ return function(){

3397+ var t__131=color_flip_16(t_130);

3398+ return function(){

3399+ switch(t__131[0]){

3400+ case "RBNode":

3401+ return function(){

3402+ switch(t__131[5][0]){

3403+ case "RBNode":

3404+ switch(t__131[5][4][0]){

3405+ case "RBNode":

3406+ switch(t__131[5][4][1][0]){

3407+ case "Red":

3408+ return color_flip_16(rotateLeft_11(RBNode_2(t__131[1])(t__131[2])(t__131[3])(t__131[4])(rotateRight_12(t__131[5]))));

3409+ }break;

3410+ }break;

3411+ }

3412+ return t__131;}();

3413+ }

3414+ return t__131;}();}();};

3415+ function moveRedRight_28(t_137){

3416+ return function(){

3417+ var t__138=color_flip_16(t_137);

3418+ return (isRedLeftLeft_24(t__138)?color_flip_16(rotateRight_12(t__138)):t__138);}();};

3419+ function moveRedLeftIfNeeded_29(t_139){

3420+ return ((not(isRedLeft_23(t_139))&&not(isRedLeftLeft_24(t_139)))?moveRedLeft_27(t_139):t_139);};

3421+ function moveRedRightIfNeeded_30(t_140){

3422+ return ((not(isRedRight_25(t_140))&&not(isRedRightLeft_26(t_140)))?moveRedRight_28(t_140):t_140);};

3423+ function deleteMin_31(t_141){

3424+ return function(){

3425+ function del_142(t_143){

3426+ return function(){

3427+ switch(t_143[0]){

3428+ case "RBNode":

3429+ switch(t_143[4][0]){

3430+ case "RBEmpty":

3431+ return RBEmpty_3;

3432+ }break;

3433+ }

3434+ return function(){

3435+ var t__144=moveRedLeftIfNeeded_29(t_143);

3436+ return function(){

3437+ switch(t__144[0]){

3438+ case "RBEmpty":

3439+ return RBEmpty_3;

3440+ case "RBNode":

3441+ return fixUp_18(RBNode_2(t__144[1])(t__144[2])(t__144[3])(del_142(t__144[4]))(t__144[5]));

3442+ }

3443+ throw "Non-exhaustive pattern match in case";}();}();}();};

3444+ return ensureBlackRoot_19(del_142(t_141));}();};

3445+ function remove_32(k_150){

3446+ return function(t_151){

3447+ return function(){

3448+ function eq_and_noRightNode_152(t_153){

3449+ return function(){

3450+ switch(t_153[0]){

3451+ case "RBNode":

3452+ switch(t_153[5][0]){

3453+ case "RBEmpty":

3454+ return eq(k_150,t_153[2]);

3455+ }break;

3456+ }

3457+ return false;}();};

3458+ return function(){

3459+ function eq_155(t_156){

3460+ return function(){

3461+ switch(t_156[0]){

3462+ case "RBNode":

3463+ return eq(k_150,t_156[2]);

3464+ }

3465+ return false;}();};

3466+ return function(){

3467+ function delLT_158(t_159){

3468+ return function(){

3469+ var t__160=moveRedLeftIfNeeded_29(t_159);

3470+ return function(){

3471+ switch(t__160[0]){

3472+ case "RBEmpty":

3473+ return raise_5(Value.str("delLT on RBEmpty"));

3474+ case "RBNode":

3475+ return fixUp_18(RBNode_2(t__160[1])(t__160[2])(t__160[3])(del(t__160[4]))(t__160[5]));

3476+ }

3477+ throw "Non-exhaustive pattern match in case";}();}();};

3478+ return function(){

3479+ function delEQ_166(t_167){

3480+ return function(){

3481+ switch(t_167[0]){

3482+ case "RBEmpty":

3483+ return raise_5(Value.str("delEQ called on a RBEmpty"));

3484+ case "RBNode":

3485+ return function(){

3486+ var Tuple2$k_v__171=min_6(t_167[5]);

3487+ var k__172=function(){

3488+ switch(Tuple2$k_v__171[0]){

3489+ case "Tuple2":

3490+ return Tuple2$k_v__171[1];

3491+ }

3492+ throw "Non-exhaustive pattern match in case";}();

3493+ var v__173=function(){

3494+ switch(Tuple2$k_v__171[0]){

3495+ case "Tuple2":

3496+ return Tuple2$k_v__171[2];

3497+ }

3498+ throw "Non-exhaustive pattern match in case";}();

3499+ return fixUp_18(RBNode_2(t_167[1])(k__172)(v__173)(t_167[4])(deleteMin_31(t_167[5])));}();

3500+ }

3501+ throw "Non-exhaustive pattern match in case";}();};

3502+ return function(){

3503+ function delGT_178(t_179){

3504+ return function(){

3505+ switch(t_179[0]){

3506+ case "RBEmpty":

3507+ return raise_5(Value.str("delGT called on a RBEmpty"));

3508+ case "RBNode":

3509+ return fixUp_18(RBNode_2(t_179[1])(t_179[2])(t_179[3])(t_179[4])(del(t_179[5])));

3510+ }

3511+ throw "Non-exhaustive pattern match in case";}();};

3512+ return function(){

3513+ function del_185(t_186){

3514+ return function(){

3515+ switch(t_186[0]){

3516+ case "RBEmpty":

3517+ return RBEmpty_3;

3518+ case "RBNode":

3519+ return ((compare(k_150)(t_186[2])[0] === 'LT')?delLT_158(t_186):function(){

3520+ var t__188=(isRedLeft_23(t_186)?rotateRight_12(t_186):t_186);

3521+ return (eq_and_noRightNode_152(t__188)?RBEmpty_3:function(){

3522+ var t_189=moveRedRightIfNeeded_30(t_189);

3523+ return (eq_155(t_189)?delEQ_166(t_189):delGT_178(t_189));}());}());

3524+ }

3525+ throw "Non-exhaustive pattern match in case";}();};

3526+ return ensureBlackRoot_19(del_185(t_151));}();}();}();}();}();}();};};

3527+ function map_33(f_190){

3528+ return function(t_191){

3529+ return function(){

3530+ switch(t_191[0]){

3531+ case "RBEmpty":

3532+ return RBEmpty_3;

3533+ case "RBNode":

3534+ return RBNode_2(t_191[1])(t_191[2])(f_190(t_191[3]))(map_33(f_190)(t_191[4]))(map_33(f_190)(t_191[5]));

3535+ }

3536+ throw "Non-exhaustive pattern match in case";}();};};

3537+ function foldl_34(f_197){

3538+ return function(acc_198){

3539+ return function(t_199){

3540+ return function(){

3541+ switch(t_199[0]){

3542+ case "RBEmpty":

3543+ return acc_198;

3544+ case "RBNode":

3545+ return foldl_34(f_197)(f_197(t_199[2])(t_199[3])(foldl_34(f_197)(acc_198)(t_199[4])))(t_199[5]);

3546+ }

3547+ throw "Non-exhaustive pattern match in case";}();};};};

3548+ function foldr_35(f_204){

3549+ return function(acc_205){

3550+ return function(t_206){

3551+ return function(){

3552+ switch(t_206[0]){

3553+ case "RBEmpty":

3554+ return acc_205;

3555+ case "RBNode":

3556+ return foldr_35(f_204)(f_204(t_206[2])(t_206[3])(foldr_35(f_204)(acc_205)(t_206[5])))(t_206[4]);

3557+ }

3558+ throw "Non-exhaustive pattern match in case";}();};};};

3559+ function union_36(t1_211){

3560+ return function(t2_212){

3561+ return foldl_34(insert_20)(t2_212)(t1_211);};};

3562+ function intersect_37(t1_213){

3563+ return function(t2_214){

3564+ return foldl_34(function(k_215){

3565+ return function(v_216){

3566+ return function(t_217){

3567+ return (member_10(k_215)(t2_214)?insert_20(k_215)(v_216)(t_217):t_217);};};})(empty_4)(t1_213);};};

3568+ function diff_38(t1_218){

3569+ return function(t2_219){

3570+ return foldl_34(function(k_220){

3571+ return function(__221){

3572+ return function(t_222){

3573+ return remove_32(k_220)(t_222);};};})(t1_218)(t2_219);};};

3574+ function keys_39(t_223){

3575+ return foldl_34(function(k_224){

3576+ return function(__225){

3577+ return function(acc_226){

3578+ return ["Cons",k_224,acc_226];};};})(["Nil"])(t_223);};

3579+ function values_40(t_227){

3580+ return foldl_34(function(__228){

3581+ return function(x_229){

3582+ return function(y_230){

3583+ return ["Cons",x_229,y_230];};};})(["Nil"])(t_227);};

3584+ function toList_41(t_231){

3585+ return foldl_34(function(k_232){

3586+ return function(v_233){

3587+ return function(acc_234){

3588+ return ["Cons",["Tuple2",k_232,v_233],acc_234];};};})(["Nil"])(t_231);};

3589+ function fromList_42(assocs_235){

3590+ return List.foldl(uncurry(insert_20))(empty_4)(assocs_235);};

3591+ return {empty:empty_4,lookup:lookup_7,findWithDefault:findWithDefault_8,member:member_10,insert:insert_20,singleton:singleton_21,remove:remove_32,map:map_33,foldl:foldl_34,foldr:foldr_35,union:union_36,intersect:intersect_37,diff:diff_38,keys:keys_39,values:values_40,toList:toList_41,fromList:fromList_42};}();

3592+

3593+Elm.Set=function(){

3594+ var empty_0=Elm.Dict.empty;

3595+ var remove_3=Elm.Dict.remove;

3596+ var member_4=Elm.Dict.member;

3597+ var union_5=Elm.Dict.union;

3598+ var intersect_6=Elm.Dict.intersect;

3599+ var diff_7=Elm.Dict.diff;

3600+ var toList_8=Elm.Dict.keys;

3601+ var fromList_9=Elm.List.foldl(function(k_15){

3602+ return function(t_16){

3603+ return Elm.Dict.insert(k_15)(["Tuple0"])(t_16);};})(empty_0);

3604+ function singleton_1(k_13){

3605+ return Elm.Dict.singleton(k_13)(["Tuple0"]);};

3606+ function insert_2(k_14){

3607+ return Elm.Dict.insert(k_14)(["Tuple0"]);};

3608+ function foldl_10(f_17){

3609+ return Elm.Dict.foldl(function(k_18){

3610+ return function(v_19){

3611+ return function(b_20){

3612+ return f_17(k_18)(b_20);};};});};

3613+ function foldr_11(f_21){

3614+ return Elm.Dict.foldr(function(k_22){

3615+ return function(v_23){

3616+ return function(b_24){

3617+ return f_21(k_22)(b_24);};};});};

3618+ function map_12(f_25){

3619+ return function(t_26){

3620+ return function(x){

3621+ return fromList_9(Elm.List.map(f_25)(x));}(toList_8(t_26));};};

3622+ return {empty:empty_0,singleton:singleton_1,insert:insert_2,remove:remove_3,member:member_4,union:union_5,intersect:intersect_6,diff:diff_7,toList:toList_8,fromList:fromList_9,foldl:foldl_10,foldr:foldr_11,map:map_12};}();

3623+

3624+(function() {

3625+try{

3626+

3627+var $op={};

3628+for(this['i'] in Elm){eval('var '+this['i']+'=Elm[this.i];');}

3629+if (Elm.Automaton) throw "Module name collision, 'Automaton' is already defined.";

3630+Elm.Automaton=function(){

3631+ try{

3632+ if (!(Elm.Prelude instanceof Object)) throw 'module not found';

3633+ } catch(e) {

3634+ throw ("Module 'Prelude' is missing. Compile with --make flag or load missing module in a separate JavaScript file.");

3635+ }

3636+ var hiddenVars={};

3637+ for (this['i'] in Elm.Prelude) {

3638+ if (hiddenVars[this['i']]) continue;

3639+ eval('var ' + this['i'] + ' = Elm.Prelude[this.i];');}

3640+ function Automaton_0(a1){

3641+ return ["Automaton",a1];}

3642+ var Listen_8=["Listen"];

3643+ var Ignore_9=["Ignore"];

3644+ function DragFrom_10(a1){

3645+ return ["DragFrom",a1];}

3646+ $op['>>>'] = function(a1_24){

3647+ return function(a2_25){

3648+ return function(){

3649+ var Automaton$m1_26=a1_24;

3650+ var m1_27=function(){

3651+ switch(Automaton$m1_26[0]){

3652+ case "Automaton":

3653+ return Automaton$m1_26[1];

3654+ }

3655+ throw "Non-exhaustive pattern match in case";}();

3656+ var Automaton$m2_28=a2_25;

3657+ var m2_29=function(){

3658+ switch(Automaton$m2_28[0]){

3659+ case "Automaton":

3660+ return Automaton$m2_28[1];

3661+ }

3662+ throw "Non-exhaustive pattern match in case";}();

3663+ return Automaton_0(function(a_32){

3664+ return function(){

3665+ var Tuple2$bm1__33=m1_27(a_32);

3666+ var b_34=function(){

3667+ switch(Tuple2$bm1__33[0]){

3668+ case "Tuple2":

3669+ return Tuple2$bm1__33[1];

3670+ }

3671+ throw "Non-exhaustive pattern match in case";}();

3672+ var m1__35=function(){

3673+ switch(Tuple2$bm1__33[0]){

3674+ case "Tuple2":

3675+ return Tuple2$bm1__33[2];

3676+ }

3677+ throw "Non-exhaustive pattern match in case";}();

3678+ return function(){

3679+ var Tuple2$cm2__40=m2_29(b_34);

3680+ var c_41=function(){

3681+ switch(Tuple2$cm2__40[0]){

3682+ case "Tuple2":

3683+ return Tuple2$cm2__40[1];

3684+ }

3685+ throw "Non-exhaustive pattern match in case";}();

3686+ var m2__42=function(){

3687+ switch(Tuple2$cm2__40[0]){

3688+ case "Tuple2":

3689+ return Tuple2$cm2__40[2];

3690+ }

3691+ throw "Non-exhaustive pattern match in case";}();

3692+ return ["Tuple2",c_41,$op['>>>'](m1__35)(m2__42)];}();}();});}();};};

3693+ $op['<<<'] = function(a2_47){

3694+ return function(a1_48){

3695+ return $op['>>>'](a1_48)(a2_47);};};

3696+ $op['^>>'] = function(f_49){

3697+ return function(a_50){

3698+ return $op['>>>'](pure_4(f_49))(a_50);};};

3699+ $op['>>^'] = function(a_51){

3700+ return function(f_52){

3701+ return $op['>>>'](a_51)(pure_4(f_52));};};

3702+ $op['^<<'] = function(f_53){

3703+ return function(a_54){

3704+ return $op['>>>'](a_54)(pure_4(f_53));};};

3705+ $op['<<^'] = function(a_55){

3706+ return function(f_56){

3707+ return $op['>>>'](pure_4(f_56))(a_55);};};

3708+ var count_7=init_5(0)(function(__84){

3709+ return function(c_85){

3710+ return (1+c_85);};});

3711+ function run_1(Automaton$m0_14){

3712+ return function(input_15){

3713+ return function(){

3714+ switch(Automaton$m0_14[0]){

3715+ case "Automaton":

3716+ return lift(fst)(foldp_(function(a_17){

3717+ return function(Tuple2$bAutomaton$m_18){

3718+ return function(){

3719+ switch(Tuple2$bAutomaton$m_18[0]){

3720+ case "Tuple2":

3721+ switch(Tuple2$bAutomaton$m_18[2][0]){

3722+ case "Automaton":

3723+ return Tuple2$bAutomaton$m_18[2][1](a_17);

3724+ }break;

3725+ }

3726+ throw "Non-exhaustive pattern match in case";}();};})(Automaton$m0_14[1])(input_15));

3727+ }

3728+ throw "Non-exhaustive pattern match in case";}();};}

3729+ function step_2(Automaton$m_21){

3730+ return function(a_22){

3731+ return function(){

3732+ switch(Automaton$m_21[0]){

3733+ case "Automaton":

3734+ return Automaton$m_21[1](a_22);

3735+ }

3736+ throw "Non-exhaustive pattern match in case";}();};}

3737+ function combine_3(autos_57){

3738+ return Automaton_0(function(a_58){

3739+ return function(){

3740+ var Tuple2$bsautos__59=unzip(map(function(Automaton$m_62){

3741+ return function(){

3742+ switch(Automaton$m_62[0]){

3743+ case "Automaton":

3744+ return Automaton$m_62[1](a_58);

3745+ }

3746+ throw "Non-exhaustive pattern match in case";}();})(autos_57));

3747+ var bs_60=function(){

3748+ switch(Tuple2$bsautos__59[0]){

3749+ case "Tuple2":

3750+ return Tuple2$bsautos__59[1];

3751+ }

3752+ throw "Non-exhaustive pattern match in case";}();

3753+ var autos__61=function(){

3754+ switch(Tuple2$bsautos__59[0]){

3755+ case "Tuple2":

3756+ return Tuple2$bsautos__59[2];

3757+ }

3758+ throw "Non-exhaustive pattern match in case";}();

3759+ return ["Tuple2",bs_60,combine_3(autos__61)];}();});}

3760+ function pure_4(f_68){

3761+ return Automaton_0(function(x_69){

3762+ return ["Tuple2",f_68(x_69),pure_4(f_68)];});}

3763+ function init_5(s_70){

3764+ return function(step_71){

3765+ return Automaton_0(function(a_72){

3766+ return function(){

3767+ var s__73=step_71(a_72)(s_70);

3768+ return ["Tuple2",s__73,init_5(s__73)(step_71)];}();});};}

3769+ function init__6(s_74){

3770+ return function(step_75){

3771+ return Automaton_0(function(a_76){

3772+ return function(){

3773+ var Tuple2$bs__77=step_75(a_76)(s_74);

3774+ var b_78=function(){

3775+ switch(Tuple2$bs__77[0]){

3776+ case "Tuple2":

3777+ return Tuple2$bs__77[1];

3778+ }

3779+ throw "Non-exhaustive pattern match in case";}();

3780+ var s__79=function(){

3781+ switch(Tuple2$bs__77[0]){

3782+ case "Tuple2":

3783+ return Tuple2$bs__77[2];

3784+ }

3785+ throw "Non-exhaustive pattern match in case";}();

3786+ return ["Tuple2",b_78,init__6(s__79)(step_75)];}();});};}

3787+ function vecSub_11(Tuple2$x1y1_86){

3788+ return function(Tuple2$x2y2_87){

3789+ return function(){

3790+ switch(Tuple2$x1y1_86[0]){

3791+ case "Tuple2":

3792+ return function(){

3793+ switch(Tuple2$x2y2_87[0]){

3794+ case "Tuple2":

3795+ return ["Tuple2",(Tuple2$x1y1_86[1]-Tuple2$x2y2_87[1]),(Tuple2$x1y1_86[2]-Tuple2$x2y2_87[2])];

3796+ }

3797+ throw "Non-exhaustive pattern match in case";}();

3798+ }

3799+ throw "Non-exhaustive pattern match in case";}();};}

3800+ function stepDrag_12(Tuple2$presspos_92){

3801+ return function(Tuple2$dsform_93){

3802+ return function(){

3803+ switch(Tuple2$presspos_92[0]){

3804+ case "Tuple2":

3805+ return function(){

3806+ switch(Tuple2$dsform_93[0]){

3807+ case "Tuple2":

3808+ return function(){

3809+ function wrap_98(ds__99){

3810+ return ["Tuple2",Tuple2$dsform_93[2],["Tuple2",ds__99,Tuple2$dsform_93[2]]];}

3811+ return function(){

3812+ switch(Tuple2$dsform_93[1][0]){

3813+ case "DragFrom":

3814+ return (Tuple2$presspos_92[1]?["Tuple2",uncurry(move)(vecSub_11(Tuple2$presspos_92[2])(Tuple2$dsform_93[1][1]))(Tuple2$dsform_93[2]),["Tuple2",DragFrom_10(Tuple2$dsform_93[1][1]),Tuple2$dsform_93[2]]]:function(){

3815+ var form__101=uncurry(move)(vecSub_11(Tuple2$presspos_92[2])(Tuple2$dsform_93[1][1]))(Tuple2$dsform_93[2]);

3816+ return ["Tuple2",form__101,["Tuple2",Listen_8,form__101]];}());

3817+ case "Ignore":

3818+ return wrap_98((Tuple2$presspos_92[1]?Ignore_9:Listen_8));

3819+ case "Listen":

3820+ return wrap_98((not(Tuple2$presspos_92[1])?Listen_8:(isWithin(Tuple2$presspos_92[2])(Tuple2$dsform_93[2])?DragFrom_10(Tuple2$presspos_92[2]):Ignore_9)));

3821+ }

3822+ throw "Non-exhaustive pattern match in case";}();}();

3823+ }

3824+ throw "Non-exhaustive pattern match in case";}();

3825+ }

3826+ throw "Non-exhaustive pattern match in case";}();};}

3827+ function draggable_13(form_102){

3828+ return init__6(["Tuple2",Listen_8,form_102])(stepDrag_12);}

3829+ return {$op : {'>>>' : $op['>>>'], '<<<' : $op['<<<'], '^>>' : $op['^>>'], '>>^' : $op['>>^'], '^<<' : $op['^<<'], '<<^' : $op['<<^']},

3830+ run:run_1,

3831+ step:step_2,

3832+ combine:combine_3,

3833+ pure:pure_4,

3834+ init:init_5,

3835+ init_:init__6,

3836+ count:count_7,

3837+ draggable:draggable_13};}();

3838+Elm.main=function(){

3839+ return Elm.Automaton.main;};

3840+} catch (e) {

3841+Elm.main=function() {

3842+var msg = (' <h2>Your browser may not be supported. Are you using a modern browser?</h2>' + ' Runtime Error in Automaton module: ' + e + '');

3843+document.body.innerHTML = Elm.Text.monospace(msg);throw e;};}}());

elm/src/Types/Constrain.hs+5−1

@@ -113,7 +113,11 @@ gen e@(If e1 e2 e3) =

113

114gen (Data name es) = gen $ foldl' App (Var name) es

115gen (Binop op e1 e2) = gen (Var op `App` e1 `App` e2)

116+

116−gen (Access (Var x) y) = gen . Var $ x ++ "." ++ y

117+gen (Access (Var a) b) = gen . Var $ a ++ "." ++ b

118+gen (Access (Access (Var a) b) c) = gen . Var $ intercalate "." [a, b, c]

119+gen (Access (Access (Access (Var a) b) c) d) = gen . Var $ intercalate "." [a, b, c, d]

120+

117gen (Range e1 e2) =

121gen (Range e1 e2) =

118 do (a1,c1,t1) <- gen e1

122 do (a1,c1,t1) <- gen e1

119 (a2,c2,t2) <- gen e2

123 (a2,c2,t2) <- gen e2