diff --git a/.gitignore b/.gitignore index 4d058db..73db0c5 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,8 @@ # Devenv .devenv* devenv.local.nix +db +datasets # direnv .direnv diff --git a/data/data.db b/data/data.db deleted file mode 100644 index 041c4f2..0000000 Binary files a/data/data.db and /dev/null differ diff --git a/data/data.db-shm b/data/data.db-shm deleted file mode 100644 index fe9ac28..0000000 Binary files a/data/data.db-shm and /dev/null differ diff --git a/data/schema.sql b/data/schema.sql deleted file mode 100644 index 210c59a..0000000 --- a/data/schema.sql +++ /dev/null @@ -1,167 +0,0 @@ --- Enable foreign key support -PRAGMA foreign_keys = ON; -PRAGMA journal_mode = WAL; -PRAGMA cache_size = -2000; -PRAGMA mmap_size = 30000000000; - - --- Words table -CREATE TABLE words ( - id INTEGER PRIMARY KEY AUTOINCREMENT, - spelling TEXT NOT NULL, - ipa TEXT NOT NULL, - language_id INTEGER NOT NULL, - frequency INTEGER, - FOREIGN KEY (language_id) REFERENCES languages(id) -); -CREATE INDEX idx_words_spelling ON words(spelling); -CREATE INDEX idx_words_language_id ON words(language_id); - - --- Languages table -CREATE TABLE languages ( - id INTEGER PRIMARY KEY AUTOINCREMENT, - name TEXT NOT NULL -); - --- Parts of Speech table -CREATE TABLE parts_of_speech ( - id INTEGER PRIMARY KEY AUTOINCREMENT, - name TEXT NOT NULL -); - --- Categories table (for noun and verb categories) -CREATE TABLE categories ( - id INTEGER PRIMARY KEY AUTOINCREMENT, - name TEXT NOT NULL, - part_of_speech_id INTEGER NOT NULL, - FOREIGN KEY (part_of_speech_id) REFERENCES parts_of_speech(id) -); -CREATE INDEX idx_categories_name ON categories(name); -CREATE INDEX idx_categories_part_of_speech_id ON categories(part_of_speech_id); - --- Word Categories junction table -CREATE TABLE word_categories ( - word_id INTEGER NOT NULL, - category_id INTEGER NOT NULL, - PRIMARY KEY (word_id, category_id), - FOREIGN KEY (word_id) REFERENCES words(id), - FOREIGN KEY (category_id) REFERENCES categories(id) -); -CREATE INDEX idx_word_categories_category_id ON word_categories(category_id); - --- Example data insertion -INSERT INTO languages (name) VALUES ('en-us'); -INSERT INTO languages (name) VALUES ('th'); -INSERT INTO languages (name) VALUES ('zh-cn'); -INSERT INTO languages (name) VALUES ('zh-hk'); -INSERT INTO languages (name) VALUES ('ja-jp'); - -INSERT INTO parts_of_speech (name) VALUES ('noun'), ('verb'), ('adjective'), ('adverb'), ('pronoun'), ('adposition'), ('conjunction'); - -INSERT INTO categories (name, part_of_speech_id) VALUES -('countable', 1), -('uncountable', 1), -('animate', 1), -('inanimate', 1), -('spatial', 1), -('temporal', 1), -('transitive', 2), -('intransitive', 2), -('action', 2), -('mental', 2), -('auxiliar', 2), -('preposition', 6), -('postposition', 6), -('circumposition', 6); - --- Example word insertion -INSERT INTO words (spelling, ipa, language_id) VALUES ('book', 'bʊk', 1); - --- Categorize 'book' as a countable, inanimate noun -INSERT INTO word_categories (word_id, category_id) -SELECT - (SELECT id FROM words WHERE spelling = 'book'), - id -FROM categories -WHERE name IN ('countable', 'inanimate'); - --- Example verb insertion -INSERT INTO words (spelling, ipa, language_id) VALUES ('think','θɪŋk', 1); - --- Categorize 'think' as an intransitive, mental verb -INSERT INTO word_categories (word_id, category_id) -SELECT - (SELECT id FROM words WHERE spelling = 'think'), - id -FROM categories -WHERE name IN ('intransitive', 'mental'); - --- multi word stuff -CREATE TABLE idioms( - id INTEGER PRIMARY KEY AUTOINCREMENT, - text TEXT NOT NULL, - language_id INTEGER NOT NULL, - frequency INTEGER, - FOREIGN KEY (language_id) REFERENCES languages(id) -); -CREATE TABLE idioms_words( - idiom_id INTEGER NOT NULL, - word_id INTEGER NOT NULL, - PRIMARY KEY (idiom_id, word_id), - FOREIGN KEY (word_id) REFERENCES words(id), - FOREIGN KEY (idiom_id) REFERENCES idioms(id) -); - --- phrasal verbs, other sui generis stuff -CREATE TABLE expressions( - id INTEGER PRIMARY KEY AUTOINCREMENT, - text TEXT NOT NULL, - type TEXT NOT NULL, -- phrasal-verb, result-complement etc. - language_id INTEGER NOT NULL, - FOREIGN KEY (language_id) REFERENCES languages(id) -); -CREATE TABLE expression_words( - expression_id INTEGER NOT NULL, - word_id INTEGER NOT NULL, - PRIMARY KEY (expression_id, word_id), - FOREIGN KEY (expression_id) REFERENCES expressions(id), - FOREIGN KEY (word_id) REFERENCES words(id) -); - - --- Progress -CREATE TABLE users( - id INTEGER PRIMARY KEY AUTOINCREMENT, - name TEXT NOT NULL, - creds TEXT NOT NULL -); -CREATE TABLE attempts( - id INTEGER PRIMARY KEY AUTOINCREMENT, - user_id INTEGER NOT NULL, - timestamp INTEGER NOT NULL, - resource_id INTEGER NOT NULL, - resources_type TEXT NOT NULL, -- name of the table, words, expressions, lessons etc. - good INTEGER NOT NULL, -- 0 or 1 - FOREIGN KEY (user_id) REFERENCES users(id) -); - --- Index to query attempts on a specific resource -CREATE INDEX idx_attempts_resource ON attempts(resource_id, resources_type); - --- Index to query attempts for a specific user -CREATE INDEX idx_attempts_user ON attempts(user_id); - --- (Optional) Index to query attempts by user and resource (useful if you often query by both) -CREATE INDEX idx_attempts_user_resource ON attempts(user_id, resource_id, resources_type); --- Lessons -CREATE TABLE lessons( - id INTEGER PRIMARY KEY AUTOINCREMENT, - text TEXT NOT NULL -); -CREATE TABLE lessons_resources( - resource_id INTEGER NOT NULL, - resources_type TEXT NOT NULL, -- name of the table, words, expressions etc. - lesson_id INTEGER NOT NULL, - FOREIGN KEY (lesson_id) REFERENCES lessons(id) -); diff --git a/devenv.lock b/devenv.lock index 600f644..df43b2f 100644 --- a/devenv.lock +++ b/devenv.lock @@ -53,16 +53,16 @@ }, "nixpkgs": { "locked": { - "lastModified": 1716977621, - "owner": "cachix", - "repo": "devenv-nixpkgs", - "rev": "4267e705586473d3e5c8d50299e71503f16a6fb6", + "lastModified": 1729265718, + "owner": "nixos", + "repo": "nixpkgs", + "rev": "ccc0c2126893dd20963580b6478d1a10a4512185", "type": "github" }, "original": { - "owner": "cachix", - "ref": "rolling", - "repo": "devenv-nixpkgs", + "owner": "nixos", + "ref": "nixpkgs-unstable", + "repo": "nixpkgs", "type": "github" } }, diff --git a/devenv.yaml b/devenv.yaml index 116a2ad..7e8f409 100644 --- a/devenv.yaml +++ b/devenv.yaml @@ -1,7 +1,8 @@ # yaml-language-server: $schema=https://devenv.sh/devenv.schema.json inputs: nixpkgs: - url: github:cachix/devenv-nixpkgs/rolling + # url: github:cachix/devenv-nixpkgs/rolling + url: github:nixos/nixpkgs/nixpkgs-unstable # If you're using non-OSS software, you can set allowUnfree to true. # allowUnfree: true diff --git a/server/db.ts b/server/db.ts new file mode 100644 index 0000000..059d877 --- /dev/null +++ b/server/db.ts @@ -0,0 +1,242 @@ +import { Database } from 'bun:sqlite'; +import { wordFactorial } from './utils'; + +// read + +export function fetchResource(db: Database, spelling: string) { + const query = db.query(` + SELECT + spelling, + ipa, + frequency, + type, + subtype, + GROUP_CONCAT(c.name, ',') AS category, + FROM expressions + JOIN word_categories wc ON wc.word_id = words.id + JOIN categories c ON c.id = wc.category_id + WHERE spelling = $spelling + GROUP BY words.id + `); + return query.get({ spelling }); +} +export function fetchFrequent(db: Database, count: number, page: number) { + const offset = (page - 1) * count; + const query = db.query(` + SELECT + spelling, + ipa, + frequency, + GROUP_CONCAT(c.name, ',') AS category, + FROM expressions e + JOIN word_categories wc ON wc.word_id = e.id + JOIN categories c ON c.id = wc.category_id + ORDER BY e.frequency DESC + LIMIT $count + OFFSET $offset + `); + return query.get({ count, offset }); +} +export function fetchLessons(db: Database, count: number, page: number) { + const p = page < 1 ? 1 : page; + const offset = (p - 1) * count; + const queryString = ` + SELECT + l.id, l.text as ltext, cards.text as ctext, cards.note as cnote, cards.id as cid + FROM cards_lessons cl + JOIN lessons l ON l.id = cl.lesson_id + JOIN cards ON cards.id = cl.card_id + LIMIT $count + OFFSET $offset + `; + const query = db.query(queryString); + const res = query.all({ count, offset }); + return res; +} + +// SELECT l.id, l.text, cards.text, cards.note FROM cards_lessons cl LEFT JOIN lessons l ON l.id = cl.lesson_id LEFT JOIN cards ON cards.id = cl.card_id ORDER BY l.id ASC LIMIT 20 OFFSET 0; +export function fetchLesson(db: Database, lesson: number) { + const queryString = ` + SELECT + l.id, l.text, cards.text, cards.note, cards.id as cid + FROM cards_lessons cl + JOIN lessons l ON l.id = cl.lesson_id + JOIN cards ON cards.id = lc.card_id + WHERE l.id = $lesson + `; + const query = db.query(queryString); + return query.all({ lesson }); +} +export function fetchCard(db: Database, cid: number, userid: number) { + const query = db.query(` + SELECT + l.id, l.text, cards.text, cards.note + FROM cards_lessons cl + JOIN lessons l ON l.id = cl.lesson_id + JOIN cards ON cards.id = lc.card_id + JOIN attempts a ON a.card_id = cards.id AND a.user_id = $userid + WHERE cards.id = $cid + `); + return query.all({ cid, userid }); +} + +// write +export function addLesson(db: Database, text: string) { + const query = db.query(` + INSERT + INTO lessons(text) + VALUES($text) + `); + const res = query.run({ text }); + return res.lastInsertRowid; +} +export function addCard( + db: Database, + lesson_id: number | bigint | null, + text: string, + mnote?: string, +) { + const note = mnote ? mnote : null; + const query = db.query(` + INSERT + INTO cards(text, note) + VALUES($text, $note) + `); + const params = { text, note }; + const res = query.run(params); + const cid = res.lastInsertRowid; + const wquery = db.query(` + INSERT OR IGNORE + INTO cards_expressions(card_id, expression_id) + VALUES($cid, ( + SELECT id FROM expressions e + WHERE e.spelling LIKE $spelling + )) + `); + const wtr = db.transaction((pairs) => { + for (const pair of pairs) wquery.run(pair); + }); + const words = text + .replace(/[^\w\s]/g, '') + .replace(/\s+/g, ' ') + .trim() + .split(' '); + const combinations = wordFactorial(words); + const richWords = combinations.map((spelling) => { + return { spelling, cid }; + }); + wtr(richWords); + if (lesson_id) { + const query = db.query(` + INSERT INTO cards_lessons(card_id, lesson_id) + VALUES($cid, $lesson_id) + `); + query.run({ lesson_id, cid }); + } +} + +export function addUser(db: Database, name: string, creds: string) { + const query = db.query(` + INSERT + INTO users(name, creds) + VALUES($name, $creds) + `); + query.run({ $name: name, $creds: creds }); +} + +export function addWord( + db: Database, + spelling: string, + ipa: string, + language: string, + type: string, + subtype: string | null, +) { + const queryString = ` + INSERT + INTO expressions(spelling, ipa, type, subtype, frequency, language_id) + VALUES($spelling, $ipa, $type, $subtype, 0, ( + SELECT id FROM languages + WHERE name = $language + )) + `; + const query = db.prepare(queryString); + const res = query.run({ spelling, ipa, language, type, subtype }); + return res.lastInsertRowid; +} +export function addCat(db: Database, wordId: number | bigint, domain: string) { + const queryString = ` + INSERT + INTO word_categories(word_id, category_id) + VALUES($wordId, ( + SELECT id FROM categories + WHERE name = $category + )) + `; + const category = domains[domain] || 'unknown'; + const query = db.query(queryString); + const res = query.run({ wordId, category }); + return res.lastInsertRowid; +} + +const domains: Record = { + 'adj.all': 'adjective', + 'adj.pert': 'adjective', + 'adj.ppl': 'adjective', + 'adv.all': 'adverb', + 'noun.Tops': '', + 'noun.act': 'abstract', + 'noun.animal': 'animate', + 'noun.artifact': 'inanimate', + 'noun.attribute': 'abstract', + 'noun.body': 'inanimate', + 'noun.cognition': 'abstract', + 'noun.communication': 'abstract', + 'noun.event': 'abstract', + 'noun.feeling': 'abstract', + 'noun.food': 'inanimate', + 'noun.group': 'noun', + 'noun.location': 'spatial', + 'noun.motive': 'abstract', + 'noun.object': 'inanimate', + 'noun.person': 'animate', + 'noun.phenomenon': 'abstract', + 'noun.plant': 'noun', + 'noun.possession': 'noun', + 'noun.process': 'noun', + 'noun.quantity': 'uncountable', + 'noun.relation': 'noun', + 'noun.shape': 'noun', + 'noun.state': 'noun', + 'noun.substance': 'uncountable', + 'noun.time': 'temporal', + 'verb.body': 'verb', + 'verb.change': 'verb', + 'verb.cognition': 'verb', + 'verb.communication': 'verb', + 'verb.competition': 'verb', + 'verb.consumption': 'verb', + 'verb.contact': 'verb', + 'verb.creation': 'verb', + 'verb.emotion': 'mental', + 'verb.motion': 'verb', + 'verb.perception': 'mental', + 'verb.possession': 'verb', + 'verb.social': 'verb', + 'verb.stative': 'verb', + 'verb.weather': 'verb', +}; +export function addFrequency( + db: Database, + spelling: string, + frequency: number, +) { + const queryString = ` + UPDATE expressions + SET frequency = $frequency + WHERE expressions.spelling = $spelling + `; + const query = db.query(queryString); + const res = query.run({ spelling, frequency }); + console.log(res, 'added frequency'); +} diff --git a/server/hanchu.d.ts b/server/hanchu.d.ts new file mode 100644 index 0000000..028d342 --- /dev/null +++ b/server/hanchu.d.ts @@ -0,0 +1,4 @@ +declare module 'wordnet' { + const value: any; + export default value; +} diff --git a/server/package.json b/server/package.json index deb94fd..a042899 100644 --- a/server/package.json +++ b/server/package.json @@ -7,5 +7,7 @@ }, "peerDependencies": { "typescript": "^5.0.0" + }, + "dependencies": { } } diff --git a/server/seeding.ts b/server/seeding.ts new file mode 100644 index 0000000..d9d6533 --- /dev/null +++ b/server/seeding.ts @@ -0,0 +1,143 @@ +import { Database } from 'bun:sqlite'; +import { addCard, addCat, addFrequency, addLesson, addWord } from './db'; +import Wordnet from 'en-wordnet'; + +// const db = new Database('../db/data.db'); +const db = new Database('../db/data.db', { strict: true }); +const wndb = new Database('../datasets/en-wordnet/data.sqlite'); +db.exec('PRAGMA journal_mode = WAL;'); + +const SYMBOL_REGEX = new RegExp(/[\W\d]/); + +// async function englishIPA() { +// const file = Bun.file('ipa/en-us/ipadict.txt'); +// const s = file.stream(); +// const reader = s.getReader(); +// const decoder = new TextDecoder(); +// let leftover = ''; +// while (true) { +// const { value, done } = await reader.read(); +// if (done) break; +// const chunk = decoder.decode(value, { stream: true }); +// const lines = (leftover + chunk).split('\n'); + +// // Process each line except the last (which might be incomplete) +// for (const line of lines.slice(0, -1)) saveLine(line); + +// // Save the last incomplete line to process in the next iteration +// leftover = lines[lines.length - 1]; +// } + +// // Handle any remaining content after reading all chunks +// if (leftover) saveLine(leftover); +// } + +async function englishFreq() { + const file = Bun.file('../datasets/unigram_freq.csv'); + const s = file.stream(); + const reader = s.getReader(); + const decoder = new TextDecoder(); + let leftover = ''; + let lineCount = 0; + while (true) { + const { value, done } = await reader.read(); + if (done) break; + const chunk = decoder.decode(value, { stream: true }); + const lines = (leftover + chunk).split('\n'); + + // Process each line except the last (which might be incomplete) + for (const line of lines.slice(0, -1)) { + lineCount++; + const [spelling, _frequency] = line.split(','); + addFrequency(db, spelling, lineCount); + } + + // Save the last incomplete line to process in the next iteration + leftover = lines[lines.length - 1]; + } + + // Handle any remaining content after reading all chunks + if (leftover) addFrequency(db, leftover, lineCount + 1); +} +// TODO no conjunctions or adpositions in Wordnet!! +function englishIPA() { + const queryString = ` + SELECT words.wordid, word, pronunciation, domainname FROM words + JOIN lexes_pronunciations lp ON lp.wordid = words.wordid + JOIN pronunciations pr ON pr.pronunciationid = lp.pronunciationid + JOIN senses ON senses.wordid = words.wordid + JOIN synsets ON synsets.synsetid = senses.synsetid + JOIN domains ON domains.domainid = synsets.domainid + GROUP BY words.wordid + `; + const query = wndb.query(queryString); + const res: Array<{ + word: string; + pronunciation: string; + domainname: string; + }> = query.all() as any; + for (const r of res) { + console.log('adding word', r); + // if (r.word === 'abrasive') throw new Error('stop right here'); + const split = r.word.split(' '); + const type = split.length > 1 ? 'expression' : 'word'; + const subtype = null; + const wordid = addWord(db, r.word, r.pronunciation, 'en-us', type, subtype); + addCat(db, wordid, r.domainname); + } +} +// function saveLine(line: string) { +// const [spelling, ipa] = line.split(/\s+/); +// if (!spelling || !ipa) return; +// const hasSymbols = spelling.match(SYMBOL_REGEX); +// if (hasSymbols) return; +// const isWord = checkWordNet(spelling); +// console.log(spelling, isWord); +// if (!isWord) return; +// const split = spelling.split(' '); +// const type = split.length > 1 ? 'expression' : 'word'; +// const subtype = null; +// addWord(db, spelling, ipa, 'en-us', type, subtype); +// } + +// function checkWordNet(word: string) { +// const query = wndb.query(`SELECT * FROM words WHERE word = $word`); +// const res = query.get({ $word: word }); +// return !!res; +// } + +function englishCards() { + const lesson_id = addLesson(db, 'First Lesson, some easy stuff'); + const texts = [ + 'I', + 'friend', + 'my friend', + 'you', + 'your friend', + "my friends' friend", + 'you are my friend', + 'I am your friend', + 'your friend is my friend', + 'my friend is your friend', + 'he is my friend', + 'this is mine', + 'this is yours', + "this is my friends'", + 'no', + 'you are not my friend', + 'this is not yours', + 'your friend is not my friend', + 'that is mine', + 'this is mine, that is yours', + 'he is not your friend', + 'no, I am not', + 'that is not me', + "that is not mine, that is my friends'", + ]; + for (const text of texts) { + addCard(db, lesson_id, text); + } +} +englishIPA(); +englishFreq(); +englishCards(); diff --git a/server/server.ts b/server/server.ts index 6be80ad..f2fc5a4 100644 --- a/server/server.ts +++ b/server/server.ts @@ -1,35 +1,103 @@ import { Database } from 'bun:sqlite'; +import { + addUser, + fetchCard, + fetchLesson, + fetchLessons, + fetchResource, +} from './db'; -const db = new Database('../data/data.db'); +const db = new Database('../db/data.db', { strict: true }); db.exec('PRAGMA journal_mode = WAL;'); Bun.serve({ fetch(req) { - console.log('req object', req); const url = new URL(req.url); - if (url.pathname === '/') return new Response('Home page!'); + console.log(url.pathname, 'url'); + const user = parseUser(req); if (req.method === 'POST' && url.pathname === '/api') - return handlePost(req, url); + return handlePost(req, user, url); if (req.method === 'GET' && url.pathname.startsWith('/api')) - return handleGet(req, url); - return new Response('404!'); + return handleGet(req, user, url); + return serveStatic(url); }, }); -async function handleGet(_req: Request, url: URL) { - if (url.pathname === '/api/resource') return handleGetResource(url); - else return new Response('huh'); -} -function handleGetResource(url: URL) { - const params = new URLSearchParams(url.search); - console.log(params); - const type = params.get('type'); - const resource = params.get('res'); - const data = fetchResource(type!, resource!); - return Response.json({ ok: true, data }); +function parseUser(req: Request): number { + // console.log(req, 'request'); + return 0; } -async function handlePost(req: Request, url: URL) { +async function serveStatic(url: URL) { + const filename = url.pathname === '/' ? '/index.html' : url.pathname; + const headers = { 'Content-type': 'text/html' }; + const opts = { headers }; + try { + const file = await Bun.file(`../ui/${filename}`).bytes(); + return new Response(file, opts); + } catch (_) { + return new Response('404!'); + } +} + +async function handleGet(_req: Request, user: number, url: URL) { + if (url.pathname === '/api/resource') return handleGetExpresion(user, url); + if (url.pathname === '/api/card') return handleGetCard(user, url); + if (url.pathname === '/api/lesson') return handleGetLesson(user, url); + if (url.pathname === '/api/lessons') return handleGetLessons(user, url); + else return new Response('huh'); +} +function handleGetExpresion(user: number, url: URL) { + const params = new URLSearchParams(url.search); + const expression = params.get('exp'); + const data = fetchResource(db, expression!); + return Response.json({ ok: data }); +} +type LessonsType = Record< + number, + { + id: number; + text: string; + cards: Array<{ text: string; note: string | null; id: number }>; + } +>; +type LessonsDBType = { + id: number; + ltext: string; + ctext: string; + cnote: string | null; + cid: number; +}; +function handleGetLesson(user: number, url: URL) { + const params = new URLSearchParams(url.search); + const lesson = params.get('lesson'); + const data = fetchLesson(db, Number(lesson!)); + return Response.json({ ok: data }); +} +function handleGetCard(user: number, url: URL) { + const params = new URLSearchParams(url.search); + const card = params.get('card'); + const data = fetchCard(db, Number(card), user); + return Response.json({ ok: data }); +} +function handleGetLessons(user: number, url: URL) { + const params = new URLSearchParams(url.search); + const page = params.get('page') || '0'; + const data: LessonsDBType[] = fetchLessons(db, 20, Number(page)) as any; + const lessons = data.reduce((acc: LessonsType, item: LessonsDBType) => { + let cur = acc[item.id] || { id: item.id, text: item.ltext, cards: [] }; + const cards = [ + ...cur.cards, + { text: item.ctext, note: item.cnote, id: item.cid }, + ]; + const def = { ...cur, cards }; + return { ...acc, [item.id]: def }; + }, {} as LessonsType); + console.log(lessons, 'lesons'); + return Response.json({ ok: lessons }); +} + +async function handlePost(req: Request, user: number, url: URL) { const data = await req.json(); if (url.pathname === '/api/user') return handlePostUser(data); else return new Response('huh'); @@ -37,38 +105,6 @@ async function handlePost(req: Request, url: URL) { // https://bun.sh/guides/http/server type PostUser = { name: string; creds: string }; function handlePostUser(user: PostUser) { - addUser(user.name, user.creds); + addUser(db, user.name, user.creds); return new Response('ok'); } - -function addUser(name: string, creds: string) { - const query = db.query(` - INSERT - INTO users(name, creds) - VALUES($name, $creds) - `); - query.run({ $name: name, $creds: creds }); -} - -function fetchResource(type: string, resource: string) { - if (type === 'word') return fetchWord(resource); - else return {}; -} -function fetchWord(word: string) { - const query = db.query(` - SELECT - spelling, - ipa, - languages.name AS language, - GROUP_CONCAT(c.name, ',') AS category, - ps.name AS pos - FROM words - JOIN languages ON languages.id = words.language_id - JOIN word_categories wc ON words.id = wc.word_id - JOIN categories c ON wc.category_id = c.id - JOIN parts_of_speech ps ON ps.id = c.part_of_speech_id - WHERE spelling = $spelling - GROUP BY words.id - `); - return query.get({ $spelling: word }); -} diff --git a/server/utils.ts b/server/utils.ts new file mode 100644 index 0000000..07a9872 --- /dev/null +++ b/server/utils.ts @@ -0,0 +1,11 @@ +export function wordFactorial(words: string[]): string[] { + const combinations: string[] = []; + for (let i = 0; i < words.length; i++) { + let inner = ''; + for (let ii = i; ii < words.length; ii++) { + inner += (ii > i ? ' ' : '') + words[ii]; + combinations.push(inner); + } + } + return combinations; +} diff --git a/ui/elm-stuff/0.19.1/Api.elmi b/ui/elm-stuff/0.19.1/Api.elmi new file mode 100644 index 0000000..2b11aec Binary files /dev/null and b/ui/elm-stuff/0.19.1/Api.elmi differ diff --git a/ui/elm-stuff/0.19.1/Api.elmo b/ui/elm-stuff/0.19.1/Api.elmo new file mode 100644 index 0000000..02eac9b Binary files /dev/null and b/ui/elm-stuff/0.19.1/Api.elmo differ diff --git a/ui/elm-stuff/0.19.1/Main.elmi b/ui/elm-stuff/0.19.1/Main.elmi new file mode 100644 index 0000000..09d55c0 Binary files /dev/null and b/ui/elm-stuff/0.19.1/Main.elmi differ diff --git a/ui/elm-stuff/0.19.1/Main.elmo b/ui/elm-stuff/0.19.1/Main.elmo new file mode 100644 index 0000000..ab65b01 Binary files /dev/null and b/ui/elm-stuff/0.19.1/Main.elmo differ diff --git a/ui/elm-stuff/0.19.1/d.dat b/ui/elm-stuff/0.19.1/d.dat index 565cbee..bfd1d0f 100644 Binary files a/ui/elm-stuff/0.19.1/d.dat and b/ui/elm-stuff/0.19.1/d.dat differ diff --git a/ui/elm-stuff/0.19.1/i.dat b/ui/elm-stuff/0.19.1/i.dat index 5fe8016..e1c3d97 100644 Binary files a/ui/elm-stuff/0.19.1/i.dat and b/ui/elm-stuff/0.19.1/i.dat differ diff --git a/ui/elm-stuff/0.19.1/o.dat b/ui/elm-stuff/0.19.1/o.dat index 1df94ad..c1232ce 100644 Binary files a/ui/elm-stuff/0.19.1/o.dat and b/ui/elm-stuff/0.19.1/o.dat differ diff --git a/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/dependencies.a95cd70c2abd8c0c943f6a7ac7ff0aa84529b418ecc5ef2f663ca83d739dd44c.json b/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/dependencies.a95cd70c2abd8c0c943f6a7ac7ff0aa84529b418ecc5ef2f663ca83d739dd44c.json new file mode 100644 index 0000000..6cc3bba --- /dev/null +++ b/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/dependencies.a95cd70c2abd8c0c943f6a7ac7ff0aa84529b418ecc5ef2f663ca83d739dd44c.json @@ -0,0 +1 @@ +{"direct":{"elm/browser":"1.0.2","elm/core":"1.0.5","elm/html":"1.0.0","elm/http":"2.0.0","elm/json":"1.1.3","elm/random":"1.0.0","elm/time":"1.0.0","mdgriffith/elm-ui":"1.1.8"},"indirect":{"elm/bytes":"1.0.8","elm/file":"1.0.5","elm/url":"1.0.0","elm/virtual-dom":"1.0.3"}} \ No newline at end of file diff --git a/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/dependencies.c7f74a7d6a16fb23c9519e15f0c488cae13be3e1e6b409e2874b4c61dfc2f2e2.json b/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/dependencies.c7f74a7d6a16fb23c9519e15f0c488cae13be3e1e6b409e2874b4c61dfc2f2e2.json new file mode 100644 index 0000000..6cc3bba --- /dev/null +++ b/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/dependencies.c7f74a7d6a16fb23c9519e15f0c488cae13be3e1e6b409e2874b4c61dfc2f2e2.json @@ -0,0 +1 @@ +{"direct":{"elm/browser":"1.0.2","elm/core":"1.0.5","elm/html":"1.0.0","elm/http":"2.0.0","elm/json":"1.1.3","elm/random":"1.0.0","elm/time":"1.0.0","mdgriffith/elm-ui":"1.1.8"},"indirect":{"elm/bytes":"1.0.8","elm/file":"1.0.5","elm/url":"1.0.0","elm/virtual-dom":"1.0.3"}} \ No newline at end of file diff --git a/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/dependencies.f7115c3afa7efad447dfb1fe6db320a9f08def6b31b24b36bc7d0105196c7a92.json b/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/dependencies.f7115c3afa7efad447dfb1fe6db320a9f08def6b31b24b36bc7d0105196c7a92.json new file mode 100644 index 0000000..e25abaf --- /dev/null +++ b/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/dependencies.f7115c3afa7efad447dfb1fe6db320a9f08def6b31b24b36bc7d0105196c7a92.json @@ -0,0 +1 @@ +{"direct":{"elm/browser":"1.0.2","elm/core":"1.0.5","elm/html":"1.0.0","elm/json":"1.1.3","elm/random":"1.0.0","elm/time":"1.0.0","mdgriffith/elm-ui":"1.1.8"},"indirect":{"elm/url":"1.0.0","elm/virtual-dom":"1.0.3"}} \ No newline at end of file diff --git a/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/elm-stuff/0.19.1/Api.elmi b/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/elm-stuff/0.19.1/Api.elmi new file mode 100644 index 0000000..2b11aec Binary files /dev/null and b/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/elm-stuff/0.19.1/Api.elmi differ diff --git a/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/elm-stuff/0.19.1/Api.elmo b/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/elm-stuff/0.19.1/Api.elmo new file mode 100644 index 0000000..02eac9b Binary files /dev/null and b/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/elm-stuff/0.19.1/Api.elmo differ diff --git a/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/elm-stuff/0.19.1/Main.elmi b/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/elm-stuff/0.19.1/Main.elmi new file mode 100644 index 0000000..778e77e Binary files /dev/null and b/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/elm-stuff/0.19.1/Main.elmi differ diff --git a/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/elm-stuff/0.19.1/Main.elmo b/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/elm-stuff/0.19.1/Main.elmo new file mode 100644 index 0000000..00886e6 Binary files /dev/null and b/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/elm-stuff/0.19.1/Main.elmo differ diff --git a/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/elm-stuff/0.19.1/d.dat b/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/elm-stuff/0.19.1/d.dat new file mode 100644 index 0000000..205c9da Binary files /dev/null and b/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/elm-stuff/0.19.1/d.dat differ diff --git a/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/elm-stuff/0.19.1/i.dat b/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/elm-stuff/0.19.1/i.dat new file mode 100644 index 0000000..a41ef65 Binary files /dev/null and b/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/elm-stuff/0.19.1/i.dat differ diff --git a/data/data.db-wal b/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/elm-stuff/0.19.1/lock similarity index 100% rename from data/data.db-wal rename to ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/elm-stuff/0.19.1/lock diff --git a/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/elm-stuff/0.19.1/o.dat b/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/elm-stuff/0.19.1/o.dat new file mode 100644 index 0000000..cddeb26 Binary files /dev/null and b/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/elm-stuff/0.19.1/o.dat differ diff --git a/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/elm.json b/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/elm.json new file mode 100644 index 0000000..9223bfa --- /dev/null +++ b/ui/elm-stuff/generated-code/elm-community/elm-test/0.19.1-revision12/elm.json @@ -0,0 +1,31 @@ +{ + "type": "application", + "source-directories": [ + "src", + "../../../../../../../../../../../nix/store/7c4670wjl90sfwmvd34yz4wi9g2wccgx-elm-test-0.19.1-revision12/lib/node_modules/elm-test/elm/src", + "../../../../../src" + ], + "elm-version": "0.19.1", + "dependencies": { + "direct": { + "elm/browser": "1.0.2", + "elm/core": "1.0.5", + "elm/html": "1.0.0", + "elm/http": "2.0.0", + "elm/json": "1.1.3", + "elm/random": "1.0.0", + "elm/time": "1.0.0", + "mdgriffith/elm-ui": "1.1.8" + }, + "indirect": { + "elm/bytes": "1.0.8", + "elm/file": "1.0.5", + "elm/url": "1.0.0", + "elm/virtual-dom": "1.0.3" + } + }, + "test-dependencies": { + "direct": {}, + "indirect": {} + } +} \ No newline at end of file diff --git a/ui/elm.js b/ui/elm.js new file mode 100644 index 0000000..fb50992 --- /dev/null +++ b/ui/elm.js @@ -0,0 +1,12416 @@ +(function(scope){ +'use strict'; + +function F(arity, fun, wrapper) { + wrapper.a = arity; + wrapper.f = fun; + return wrapper; +} + +function F2(fun) { + return F(2, fun, function(a) { return function(b) { return fun(a,b); }; }) +} +function F3(fun) { + return F(3, fun, function(a) { + return function(b) { return function(c) { return fun(a, b, c); }; }; + }); +} +function F4(fun) { + return F(4, fun, function(a) { return function(b) { return function(c) { + return function(d) { return fun(a, b, c, d); }; }; }; + }); +} +function F5(fun) { + return F(5, fun, function(a) { return function(b) { return function(c) { + return function(d) { return function(e) { return fun(a, b, c, d, e); }; }; }; }; + }); +} +function F6(fun) { + return F(6, fun, function(a) { return function(b) { return function(c) { + return function(d) { return function(e) { return function(f) { + return fun(a, b, c, d, e, f); }; }; }; }; }; + }); +} +function F7(fun) { + return F(7, fun, function(a) { return function(b) { return function(c) { + return function(d) { return function(e) { return function(f) { + return function(g) { return fun(a, b, c, d, e, f, g); }; }; }; }; }; }; + }); +} +function F8(fun) { + return F(8, fun, function(a) { return function(b) { return function(c) { + return function(d) { return function(e) { return function(f) { + return function(g) { return function(h) { + return fun(a, b, c, d, e, f, g, h); }; }; }; }; }; }; }; + }); +} +function F9(fun) { + return F(9, fun, function(a) { return function(b) { return function(c) { + return function(d) { return function(e) { return function(f) { + return function(g) { return function(h) { return function(i) { + return fun(a, b, c, d, e, f, g, h, i); }; }; }; }; }; }; }; }; + }); +} + +function A2(fun, a, b) { + return fun.a === 2 ? fun.f(a, b) : fun(a)(b); +} +function A3(fun, a, b, c) { + return fun.a === 3 ? fun.f(a, b, c) : fun(a)(b)(c); +} +function A4(fun, a, b, c, d) { + return fun.a === 4 ? fun.f(a, b, c, d) : fun(a)(b)(c)(d); +} +function A5(fun, a, b, c, d, e) { + return fun.a === 5 ? fun.f(a, b, c, d, e) : fun(a)(b)(c)(d)(e); +} +function A6(fun, a, b, c, d, e, f) { + return fun.a === 6 ? fun.f(a, b, c, d, e, f) : fun(a)(b)(c)(d)(e)(f); +} +function A7(fun, a, b, c, d, e, f, g) { + return fun.a === 7 ? fun.f(a, b, c, d, e, f, g) : fun(a)(b)(c)(d)(e)(f)(g); +} +function A8(fun, a, b, c, d, e, f, g, h) { + return fun.a === 8 ? fun.f(a, b, c, d, e, f, g, h) : fun(a)(b)(c)(d)(e)(f)(g)(h); +} +function A9(fun, a, b, c, d, e, f, g, h, i) { + return fun.a === 9 ? fun.f(a, b, c, d, e, f, g, h, i) : fun(a)(b)(c)(d)(e)(f)(g)(h)(i); +} + +console.warn('Compiled in DEV mode. Follow the advice at https://elm-lang.org/0.19.1/optimize for better performance and smaller assets.'); + + +// EQUALITY + +function _Utils_eq(x, y) +{ + for ( + var pair, stack = [], isEqual = _Utils_eqHelp(x, y, 0, stack); + isEqual && (pair = stack.pop()); + isEqual = _Utils_eqHelp(pair.a, pair.b, 0, stack) + ) + {} + + return isEqual; +} + +function _Utils_eqHelp(x, y, depth, stack) +{ + if (x === y) + { + return true; + } + + if (typeof x !== 'object' || x === null || y === null) + { + typeof x === 'function' && _Debug_crash(5); + return false; + } + + if (depth > 100) + { + stack.push(_Utils_Tuple2(x,y)); + return true; + } + + /**/ + if (x.$ === 'Set_elm_builtin') + { + x = $elm$core$Set$toList(x); + y = $elm$core$Set$toList(y); + } + if (x.$ === 'RBNode_elm_builtin' || x.$ === 'RBEmpty_elm_builtin') + { + x = $elm$core$Dict$toList(x); + y = $elm$core$Dict$toList(y); + } + //*/ + + /**_UNUSED/ + if (x.$ < 0) + { + x = $elm$core$Dict$toList(x); + y = $elm$core$Dict$toList(y); + } + //*/ + + for (var key in x) + { + if (!_Utils_eqHelp(x[key], y[key], depth + 1, stack)) + { + return false; + } + } + return true; +} + +var _Utils_equal = F2(_Utils_eq); +var _Utils_notEqual = F2(function(a, b) { return !_Utils_eq(a,b); }); + + + +// COMPARISONS + +// Code in Generate/JavaScript.hs, Basics.js, and List.js depends on +// the particular integer values assigned to LT, EQ, and GT. + +function _Utils_cmp(x, y, ord) +{ + if (typeof x !== 'object') + { + return x === y ? /*EQ*/ 0 : x < y ? /*LT*/ -1 : /*GT*/ 1; + } + + /**/ + if (x instanceof String) + { + var a = x.valueOf(); + var b = y.valueOf(); + return a === b ? 0 : a < b ? -1 : 1; + } + //*/ + + /**_UNUSED/ + if (typeof x.$ === 'undefined') + //*/ + /**/ + if (x.$[0] === '#') + //*/ + { + return (ord = _Utils_cmp(x.a, y.a)) + ? ord + : (ord = _Utils_cmp(x.b, y.b)) + ? ord + : _Utils_cmp(x.c, y.c); + } + + // traverse conses until end of a list or a mismatch + for (; x.b && y.b && !(ord = _Utils_cmp(x.a, y.a)); x = x.b, y = y.b) {} // WHILE_CONSES + return ord || (x.b ? /*GT*/ 1 : y.b ? /*LT*/ -1 : /*EQ*/ 0); +} + +var _Utils_lt = F2(function(a, b) { return _Utils_cmp(a, b) < 0; }); +var _Utils_le = F2(function(a, b) { return _Utils_cmp(a, b) < 1; }); +var _Utils_gt = F2(function(a, b) { return _Utils_cmp(a, b) > 0; }); +var _Utils_ge = F2(function(a, b) { return _Utils_cmp(a, b) >= 0; }); + +var _Utils_compare = F2(function(x, y) +{ + var n = _Utils_cmp(x, y); + return n < 0 ? $elm$core$Basics$LT : n ? $elm$core$Basics$GT : $elm$core$Basics$EQ; +}); + + +// COMMON VALUES + +var _Utils_Tuple0_UNUSED = 0; +var _Utils_Tuple0 = { $: '#0' }; + +function _Utils_Tuple2_UNUSED(a, b) { return { a: a, b: b }; } +function _Utils_Tuple2(a, b) { return { $: '#2', a: a, b: b }; } + +function _Utils_Tuple3_UNUSED(a, b, c) { return { a: a, b: b, c: c }; } +function _Utils_Tuple3(a, b, c) { return { $: '#3', a: a, b: b, c: c }; } + +function _Utils_chr_UNUSED(c) { return c; } +function _Utils_chr(c) { return new String(c); } + + +// RECORDS + +function _Utils_update(oldRecord, updatedFields) +{ + var newRecord = {}; + + for (var key in oldRecord) + { + newRecord[key] = oldRecord[key]; + } + + for (var key in updatedFields) + { + newRecord[key] = updatedFields[key]; + } + + return newRecord; +} + + +// APPEND + +var _Utils_append = F2(_Utils_ap); + +function _Utils_ap(xs, ys) +{ + // append Strings + if (typeof xs === 'string') + { + return xs + ys; + } + + // append Lists + if (!xs.b) + { + return ys; + } + var root = _List_Cons(xs.a, ys); + xs = xs.b + for (var curr = root; xs.b; xs = xs.b) // WHILE_CONS + { + curr = curr.b = _List_Cons(xs.a, ys); + } + return root; +} + + + +var _List_Nil_UNUSED = { $: 0 }; +var _List_Nil = { $: '[]' }; + +function _List_Cons_UNUSED(hd, tl) { return { $: 1, a: hd, b: tl }; } +function _List_Cons(hd, tl) { return { $: '::', a: hd, b: tl }; } + + +var _List_cons = F2(_List_Cons); + +function _List_fromArray(arr) +{ + var out = _List_Nil; + for (var i = arr.length; i--; ) + { + out = _List_Cons(arr[i], out); + } + return out; +} + +function _List_toArray(xs) +{ + for (var out = []; xs.b; xs = xs.b) // WHILE_CONS + { + out.push(xs.a); + } + return out; +} + +var _List_map2 = F3(function(f, xs, ys) +{ + for (var arr = []; xs.b && ys.b; xs = xs.b, ys = ys.b) // WHILE_CONSES + { + arr.push(A2(f, xs.a, ys.a)); + } + return _List_fromArray(arr); +}); + +var _List_map3 = F4(function(f, xs, ys, zs) +{ + for (var arr = []; xs.b && ys.b && zs.b; xs = xs.b, ys = ys.b, zs = zs.b) // WHILE_CONSES + { + arr.push(A3(f, xs.a, ys.a, zs.a)); + } + return _List_fromArray(arr); +}); + +var _List_map4 = F5(function(f, ws, xs, ys, zs) +{ + for (var arr = []; ws.b && xs.b && ys.b && zs.b; ws = ws.b, xs = xs.b, ys = ys.b, zs = zs.b) // WHILE_CONSES + { + arr.push(A4(f, ws.a, xs.a, ys.a, zs.a)); + } + return _List_fromArray(arr); +}); + +var _List_map5 = F6(function(f, vs, ws, xs, ys, zs) +{ + for (var arr = []; vs.b && ws.b && xs.b && ys.b && zs.b; vs = vs.b, ws = ws.b, xs = xs.b, ys = ys.b, zs = zs.b) // WHILE_CONSES + { + arr.push(A5(f, vs.a, ws.a, xs.a, ys.a, zs.a)); + } + return _List_fromArray(arr); +}); + +var _List_sortBy = F2(function(f, xs) +{ + return _List_fromArray(_List_toArray(xs).sort(function(a, b) { + return _Utils_cmp(f(a), f(b)); + })); +}); + +var _List_sortWith = F2(function(f, xs) +{ + return _List_fromArray(_List_toArray(xs).sort(function(a, b) { + var ord = A2(f, a, b); + return ord === $elm$core$Basics$EQ ? 0 : ord === $elm$core$Basics$LT ? -1 : 1; + })); +}); + + + +var _JsArray_empty = []; + +function _JsArray_singleton(value) +{ + return [value]; +} + +function _JsArray_length(array) +{ + return array.length; +} + +var _JsArray_initialize = F3(function(size, offset, func) +{ + var result = new Array(size); + + for (var i = 0; i < size; i++) + { + result[i] = func(offset + i); + } + + return result; +}); + +var _JsArray_initializeFromList = F2(function (max, ls) +{ + var result = new Array(max); + + for (var i = 0; i < max && ls.b; i++) + { + result[i] = ls.a; + ls = ls.b; + } + + result.length = i; + return _Utils_Tuple2(result, ls); +}); + +var _JsArray_unsafeGet = F2(function(index, array) +{ + return array[index]; +}); + +var _JsArray_unsafeSet = F3(function(index, value, array) +{ + var length = array.length; + var result = new Array(length); + + for (var i = 0; i < length; i++) + { + result[i] = array[i]; + } + + result[index] = value; + return result; +}); + +var _JsArray_push = F2(function(value, array) +{ + var length = array.length; + var result = new Array(length + 1); + + for (var i = 0; i < length; i++) + { + result[i] = array[i]; + } + + result[length] = value; + return result; +}); + +var _JsArray_foldl = F3(function(func, acc, array) +{ + var length = array.length; + + for (var i = 0; i < length; i++) + { + acc = A2(func, array[i], acc); + } + + return acc; +}); + +var _JsArray_foldr = F3(function(func, acc, array) +{ + for (var i = array.length - 1; i >= 0; i--) + { + acc = A2(func, array[i], acc); + } + + return acc; +}); + +var _JsArray_map = F2(function(func, array) +{ + var length = array.length; + var result = new Array(length); + + for (var i = 0; i < length; i++) + { + result[i] = func(array[i]); + } + + return result; +}); + +var _JsArray_indexedMap = F3(function(func, offset, array) +{ + var length = array.length; + var result = new Array(length); + + for (var i = 0; i < length; i++) + { + result[i] = A2(func, offset + i, array[i]); + } + + return result; +}); + +var _JsArray_slice = F3(function(from, to, array) +{ + return array.slice(from, to); +}); + +var _JsArray_appendN = F3(function(n, dest, source) +{ + var destLen = dest.length; + var itemsToCopy = n - destLen; + + if (itemsToCopy > source.length) + { + itemsToCopy = source.length; + } + + var size = destLen + itemsToCopy; + var result = new Array(size); + + for (var i = 0; i < destLen; i++) + { + result[i] = dest[i]; + } + + for (var i = 0; i < itemsToCopy; i++) + { + result[i + destLen] = source[i]; + } + + return result; +}); + + + +// LOG + +var _Debug_log_UNUSED = F2(function(tag, value) +{ + return value; +}); + +var _Debug_log = F2(function(tag, value) +{ + console.log(tag + ': ' + _Debug_toString(value)); + return value; +}); + + +// TODOS + +function _Debug_todo(moduleName, region) +{ + return function(message) { + _Debug_crash(8, moduleName, region, message); + }; +} + +function _Debug_todoCase(moduleName, region, value) +{ + return function(message) { + _Debug_crash(9, moduleName, region, value, message); + }; +} + + +// TO STRING + +function _Debug_toString_UNUSED(value) +{ + return ''; +} + +function _Debug_toString(value) +{ + return _Debug_toAnsiString(false, value); +} + +function _Debug_toAnsiString(ansi, value) +{ + if (typeof value === 'function') + { + return _Debug_internalColor(ansi, ''); + } + + if (typeof value === 'boolean') + { + return _Debug_ctorColor(ansi, value ? 'True' : 'False'); + } + + if (typeof value === 'number') + { + return _Debug_numberColor(ansi, value + ''); + } + + if (value instanceof String) + { + return _Debug_charColor(ansi, "'" + _Debug_addSlashes(value, true) + "'"); + } + + if (typeof value === 'string') + { + return _Debug_stringColor(ansi, '"' + _Debug_addSlashes(value, false) + '"'); + } + + if (typeof value === 'object' && '$' in value) + { + var tag = value.$; + + if (typeof tag === 'number') + { + return _Debug_internalColor(ansi, ''); + } + + if (tag[0] === '#') + { + var output = []; + for (var k in value) + { + if (k === '$') continue; + output.push(_Debug_toAnsiString(ansi, value[k])); + } + return '(' + output.join(',') + ')'; + } + + if (tag === 'Set_elm_builtin') + { + return _Debug_ctorColor(ansi, 'Set') + + _Debug_fadeColor(ansi, '.fromList') + ' ' + + _Debug_toAnsiString(ansi, $elm$core$Set$toList(value)); + } + + if (tag === 'RBNode_elm_builtin' || tag === 'RBEmpty_elm_builtin') + { + return _Debug_ctorColor(ansi, 'Dict') + + _Debug_fadeColor(ansi, '.fromList') + ' ' + + _Debug_toAnsiString(ansi, $elm$core$Dict$toList(value)); + } + + if (tag === 'Array_elm_builtin') + { + return _Debug_ctorColor(ansi, 'Array') + + _Debug_fadeColor(ansi, '.fromList') + ' ' + + _Debug_toAnsiString(ansi, $elm$core$Array$toList(value)); + } + + if (tag === '::' || tag === '[]') + { + var output = '['; + + value.b && (output += _Debug_toAnsiString(ansi, value.a), value = value.b) + + for (; value.b; value = value.b) // WHILE_CONS + { + output += ',' + _Debug_toAnsiString(ansi, value.a); + } + return output + ']'; + } + + var output = ''; + for (var i in value) + { + if (i === '$') continue; + var str = _Debug_toAnsiString(ansi, value[i]); + var c0 = str[0]; + var parenless = c0 === '{' || c0 === '(' || c0 === '[' || c0 === '<' || c0 === '"' || str.indexOf(' ') < 0; + output += ' ' + (parenless ? str : '(' + str + ')'); + } + return _Debug_ctorColor(ansi, tag) + output; + } + + if (typeof DataView === 'function' && value instanceof DataView) + { + return _Debug_stringColor(ansi, '<' + value.byteLength + ' bytes>'); + } + + if (typeof File !== 'undefined' && value instanceof File) + { + return _Debug_internalColor(ansi, '<' + value.name + '>'); + } + + if (typeof value === 'object') + { + var output = []; + for (var key in value) + { + var field = key[0] === '_' ? key.slice(1) : key; + output.push(_Debug_fadeColor(ansi, field) + ' = ' + _Debug_toAnsiString(ansi, value[key])); + } + if (output.length === 0) + { + return '{}'; + } + return '{ ' + output.join(', ') + ' }'; + } + + return _Debug_internalColor(ansi, ''); +} + +function _Debug_addSlashes(str, isChar) +{ + var s = str + .replace(/\\/g, '\\\\') + .replace(/\n/g, '\\n') + .replace(/\t/g, '\\t') + .replace(/\r/g, '\\r') + .replace(/\v/g, '\\v') + .replace(/\0/g, '\\0'); + + if (isChar) + { + return s.replace(/\'/g, '\\\''); + } + else + { + return s.replace(/\"/g, '\\"'); + } +} + +function _Debug_ctorColor(ansi, string) +{ + return ansi ? '\x1b[96m' + string + '\x1b[0m' : string; +} + +function _Debug_numberColor(ansi, string) +{ + return ansi ? '\x1b[95m' + string + '\x1b[0m' : string; +} + +function _Debug_stringColor(ansi, string) +{ + return ansi ? '\x1b[93m' + string + '\x1b[0m' : string; +} + +function _Debug_charColor(ansi, string) +{ + return ansi ? '\x1b[92m' + string + '\x1b[0m' : string; +} + +function _Debug_fadeColor(ansi, string) +{ + return ansi ? '\x1b[37m' + string + '\x1b[0m' : string; +} + +function _Debug_internalColor(ansi, string) +{ + return ansi ? '\x1b[36m' + string + '\x1b[0m' : string; +} + +function _Debug_toHexDigit(n) +{ + return String.fromCharCode(n < 10 ? 48 + n : 55 + n); +} + + +// CRASH + + +function _Debug_crash_UNUSED(identifier) +{ + throw new Error('https://github.com/elm/core/blob/1.0.0/hints/' + identifier + '.md'); +} + + +function _Debug_crash(identifier, fact1, fact2, fact3, fact4) +{ + switch(identifier) + { + case 0: + throw new Error('What node should I take over? In JavaScript I need something like:\n\n Elm.Main.init({\n node: document.getElementById("elm-node")\n })\n\nYou need to do this with any Browser.sandbox or Browser.element program.'); + + case 1: + throw new Error('Browser.application programs cannot handle URLs like this:\n\n ' + document.location.href + '\n\nWhat is the root? The root of your file system? Try looking at this program with `elm reactor` or some other server.'); + + case 2: + var jsonErrorString = fact1; + throw new Error('Problem with the flags given to your Elm program on initialization.\n\n' + jsonErrorString); + + case 3: + var portName = fact1; + throw new Error('There can only be one port named `' + portName + '`, but your program has multiple.'); + + case 4: + var portName = fact1; + var problem = fact2; + throw new Error('Trying to send an unexpected type of value through port `' + portName + '`:\n' + problem); + + case 5: + throw new Error('Trying to use `(==)` on functions.\nThere is no way to know if functions are "the same" in the Elm sense.\nRead more about this at https://package.elm-lang.org/packages/elm/core/latest/Basics#== which describes why it is this way and what the better version will look like.'); + + case 6: + var moduleName = fact1; + throw new Error('Your page is loading multiple Elm scripts with a module named ' + moduleName + '. Maybe a duplicate script is getting loaded accidentally? If not, rename one of them so I know which is which!'); + + case 8: + var moduleName = fact1; + var region = fact2; + var message = fact3; + throw new Error('TODO in module `' + moduleName + '` ' + _Debug_regionToString(region) + '\n\n' + message); + + case 9: + var moduleName = fact1; + var region = fact2; + var value = fact3; + var message = fact4; + throw new Error( + 'TODO in module `' + moduleName + '` from the `case` expression ' + + _Debug_regionToString(region) + '\n\nIt received the following value:\n\n ' + + _Debug_toString(value).replace('\n', '\n ') + + '\n\nBut the branch that handles it says:\n\n ' + message.replace('\n', '\n ') + ); + + case 10: + throw new Error('Bug in https://github.com/elm/virtual-dom/issues'); + + case 11: + throw new Error('Cannot perform mod 0. Division by zero error.'); + } +} + +function _Debug_regionToString(region) +{ + if (region.start.line === region.end.line) + { + return 'on line ' + region.start.line; + } + return 'on lines ' + region.start.line + ' through ' + region.end.line; +} + + + +// MATH + +var _Basics_add = F2(function(a, b) { return a + b; }); +var _Basics_sub = F2(function(a, b) { return a - b; }); +var _Basics_mul = F2(function(a, b) { return a * b; }); +var _Basics_fdiv = F2(function(a, b) { return a / b; }); +var _Basics_idiv = F2(function(a, b) { return (a / b) | 0; }); +var _Basics_pow = F2(Math.pow); + +var _Basics_remainderBy = F2(function(b, a) { return a % b; }); + +// https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf +var _Basics_modBy = F2(function(modulus, x) +{ + var answer = x % modulus; + return modulus === 0 + ? _Debug_crash(11) + : + ((answer > 0 && modulus < 0) || (answer < 0 && modulus > 0)) + ? answer + modulus + : answer; +}); + + +// TRIGONOMETRY + +var _Basics_pi = Math.PI; +var _Basics_e = Math.E; +var _Basics_cos = Math.cos; +var _Basics_sin = Math.sin; +var _Basics_tan = Math.tan; +var _Basics_acos = Math.acos; +var _Basics_asin = Math.asin; +var _Basics_atan = Math.atan; +var _Basics_atan2 = F2(Math.atan2); + + +// MORE MATH + +function _Basics_toFloat(x) { return x; } +function _Basics_truncate(n) { return n | 0; } +function _Basics_isInfinite(n) { return n === Infinity || n === -Infinity; } + +var _Basics_ceiling = Math.ceil; +var _Basics_floor = Math.floor; +var _Basics_round = Math.round; +var _Basics_sqrt = Math.sqrt; +var _Basics_log = Math.log; +var _Basics_isNaN = isNaN; + + +// BOOLEANS + +function _Basics_not(bool) { return !bool; } +var _Basics_and = F2(function(a, b) { return a && b; }); +var _Basics_or = F2(function(a, b) { return a || b; }); +var _Basics_xor = F2(function(a, b) { return a !== b; }); + + + +var _String_cons = F2(function(chr, str) +{ + return chr + str; +}); + +function _String_uncons(string) +{ + var word = string.charCodeAt(0); + return !isNaN(word) + ? $elm$core$Maybe$Just( + 0xD800 <= word && word <= 0xDBFF + ? _Utils_Tuple2(_Utils_chr(string[0] + string[1]), string.slice(2)) + : _Utils_Tuple2(_Utils_chr(string[0]), string.slice(1)) + ) + : $elm$core$Maybe$Nothing; +} + +var _String_append = F2(function(a, b) +{ + return a + b; +}); + +function _String_length(str) +{ + return str.length; +} + +var _String_map = F2(function(func, string) +{ + var len = string.length; + var array = new Array(len); + var i = 0; + while (i < len) + { + var word = string.charCodeAt(i); + if (0xD800 <= word && word <= 0xDBFF) + { + array[i] = func(_Utils_chr(string[i] + string[i+1])); + i += 2; + continue; + } + array[i] = func(_Utils_chr(string[i])); + i++; + } + return array.join(''); +}); + +var _String_filter = F2(function(isGood, str) +{ + var arr = []; + var len = str.length; + var i = 0; + while (i < len) + { + var char = str[i]; + var word = str.charCodeAt(i); + i++; + if (0xD800 <= word && word <= 0xDBFF) + { + char += str[i]; + i++; + } + + if (isGood(_Utils_chr(char))) + { + arr.push(char); + } + } + return arr.join(''); +}); + +function _String_reverse(str) +{ + var len = str.length; + var arr = new Array(len); + var i = 0; + while (i < len) + { + var word = str.charCodeAt(i); + if (0xD800 <= word && word <= 0xDBFF) + { + arr[len - i] = str[i + 1]; + i++; + arr[len - i] = str[i - 1]; + i++; + } + else + { + arr[len - i] = str[i]; + i++; + } + } + return arr.join(''); +} + +var _String_foldl = F3(function(func, state, string) +{ + var len = string.length; + var i = 0; + while (i < len) + { + var char = string[i]; + var word = string.charCodeAt(i); + i++; + if (0xD800 <= word && word <= 0xDBFF) + { + char += string[i]; + i++; + } + state = A2(func, _Utils_chr(char), state); + } + return state; +}); + +var _String_foldr = F3(function(func, state, string) +{ + var i = string.length; + while (i--) + { + var char = string[i]; + var word = string.charCodeAt(i); + if (0xDC00 <= word && word <= 0xDFFF) + { + i--; + char = string[i] + char; + } + state = A2(func, _Utils_chr(char), state); + } + return state; +}); + +var _String_split = F2(function(sep, str) +{ + return str.split(sep); +}); + +var _String_join = F2(function(sep, strs) +{ + return strs.join(sep); +}); + +var _String_slice = F3(function(start, end, str) { + return str.slice(start, end); +}); + +function _String_trim(str) +{ + return str.trim(); +} + +function _String_trimLeft(str) +{ + return str.replace(/^\s+/, ''); +} + +function _String_trimRight(str) +{ + return str.replace(/\s+$/, ''); +} + +function _String_words(str) +{ + return _List_fromArray(str.trim().split(/\s+/g)); +} + +function _String_lines(str) +{ + return _List_fromArray(str.split(/\r\n|\r|\n/g)); +} + +function _String_toUpper(str) +{ + return str.toUpperCase(); +} + +function _String_toLower(str) +{ + return str.toLowerCase(); +} + +var _String_any = F2(function(isGood, string) +{ + var i = string.length; + while (i--) + { + var char = string[i]; + var word = string.charCodeAt(i); + if (0xDC00 <= word && word <= 0xDFFF) + { + i--; + char = string[i] + char; + } + if (isGood(_Utils_chr(char))) + { + return true; + } + } + return false; +}); + +var _String_all = F2(function(isGood, string) +{ + var i = string.length; + while (i--) + { + var char = string[i]; + var word = string.charCodeAt(i); + if (0xDC00 <= word && word <= 0xDFFF) + { + i--; + char = string[i] + char; + } + if (!isGood(_Utils_chr(char))) + { + return false; + } + } + return true; +}); + +var _String_contains = F2(function(sub, str) +{ + return str.indexOf(sub) > -1; +}); + +var _String_startsWith = F2(function(sub, str) +{ + return str.indexOf(sub) === 0; +}); + +var _String_endsWith = F2(function(sub, str) +{ + return str.length >= sub.length && + str.lastIndexOf(sub) === str.length - sub.length; +}); + +var _String_indexes = F2(function(sub, str) +{ + var subLen = sub.length; + + if (subLen < 1) + { + return _List_Nil; + } + + var i = 0; + var is = []; + + while ((i = str.indexOf(sub, i)) > -1) + { + is.push(i); + i = i + subLen; + } + + return _List_fromArray(is); +}); + + +// TO STRING + +function _String_fromNumber(number) +{ + return number + ''; +} + + +// INT CONVERSIONS + +function _String_toInt(str) +{ + var total = 0; + var code0 = str.charCodeAt(0); + var start = code0 == 0x2B /* + */ || code0 == 0x2D /* - */ ? 1 : 0; + + for (var i = start; i < str.length; ++i) + { + var code = str.charCodeAt(i); + if (code < 0x30 || 0x39 < code) + { + return $elm$core$Maybe$Nothing; + } + total = 10 * total + code - 0x30; + } + + return i == start + ? $elm$core$Maybe$Nothing + : $elm$core$Maybe$Just(code0 == 0x2D ? -total : total); +} + + +// FLOAT CONVERSIONS + +function _String_toFloat(s) +{ + // check if it is a hex, octal, or binary number + if (s.length === 0 || /[\sxbo]/.test(s)) + { + return $elm$core$Maybe$Nothing; + } + var n = +s; + // faster isNaN check + return n === n ? $elm$core$Maybe$Just(n) : $elm$core$Maybe$Nothing; +} + +function _String_fromList(chars) +{ + return _List_toArray(chars).join(''); +} + + + + +function _Char_toCode(char) +{ + var code = char.charCodeAt(0); + if (0xD800 <= code && code <= 0xDBFF) + { + return (code - 0xD800) * 0x400 + char.charCodeAt(1) - 0xDC00 + 0x10000 + } + return code; +} + +function _Char_fromCode(code) +{ + return _Utils_chr( + (code < 0 || 0x10FFFF < code) + ? '\uFFFD' + : + (code <= 0xFFFF) + ? String.fromCharCode(code) + : + (code -= 0x10000, + String.fromCharCode(Math.floor(code / 0x400) + 0xD800, code % 0x400 + 0xDC00) + ) + ); +} + +function _Char_toUpper(char) +{ + return _Utils_chr(char.toUpperCase()); +} + +function _Char_toLower(char) +{ + return _Utils_chr(char.toLowerCase()); +} + +function _Char_toLocaleUpper(char) +{ + return _Utils_chr(char.toLocaleUpperCase()); +} + +function _Char_toLocaleLower(char) +{ + return _Utils_chr(char.toLocaleLowerCase()); +} + + + +/**/ +function _Json_errorToString(error) +{ + return $elm$json$Json$Decode$errorToString(error); +} +//*/ + + +// CORE DECODERS + +function _Json_succeed(msg) +{ + return { + $: 0, + a: msg + }; +} + +function _Json_fail(msg) +{ + return { + $: 1, + a: msg + }; +} + +function _Json_decodePrim(decoder) +{ + return { $: 2, b: decoder }; +} + +var _Json_decodeInt = _Json_decodePrim(function(value) { + return (typeof value !== 'number') + ? _Json_expecting('an INT', value) + : + (-2147483647 < value && value < 2147483647 && (value | 0) === value) + ? $elm$core$Result$Ok(value) + : + (isFinite(value) && !(value % 1)) + ? $elm$core$Result$Ok(value) + : _Json_expecting('an INT', value); +}); + +var _Json_decodeBool = _Json_decodePrim(function(value) { + return (typeof value === 'boolean') + ? $elm$core$Result$Ok(value) + : _Json_expecting('a BOOL', value); +}); + +var _Json_decodeFloat = _Json_decodePrim(function(value) { + return (typeof value === 'number') + ? $elm$core$Result$Ok(value) + : _Json_expecting('a FLOAT', value); +}); + +var _Json_decodeValue = _Json_decodePrim(function(value) { + return $elm$core$Result$Ok(_Json_wrap(value)); +}); + +var _Json_decodeString = _Json_decodePrim(function(value) { + return (typeof value === 'string') + ? $elm$core$Result$Ok(value) + : (value instanceof String) + ? $elm$core$Result$Ok(value + '') + : _Json_expecting('a STRING', value); +}); + +function _Json_decodeList(decoder) { return { $: 3, b: decoder }; } +function _Json_decodeArray(decoder) { return { $: 4, b: decoder }; } + +function _Json_decodeNull(value) { return { $: 5, c: value }; } + +var _Json_decodeField = F2(function(field, decoder) +{ + return { + $: 6, + d: field, + b: decoder + }; +}); + +var _Json_decodeIndex = F2(function(index, decoder) +{ + return { + $: 7, + e: index, + b: decoder + }; +}); + +function _Json_decodeKeyValuePairs(decoder) +{ + return { + $: 8, + b: decoder + }; +} + +function _Json_mapMany(f, decoders) +{ + return { + $: 9, + f: f, + g: decoders + }; +} + +var _Json_andThen = F2(function(callback, decoder) +{ + return { + $: 10, + b: decoder, + h: callback + }; +}); + +function _Json_oneOf(decoders) +{ + return { + $: 11, + g: decoders + }; +} + + +// DECODING OBJECTS + +var _Json_map1 = F2(function(f, d1) +{ + return _Json_mapMany(f, [d1]); +}); + +var _Json_map2 = F3(function(f, d1, d2) +{ + return _Json_mapMany(f, [d1, d2]); +}); + +var _Json_map3 = F4(function(f, d1, d2, d3) +{ + return _Json_mapMany(f, [d1, d2, d3]); +}); + +var _Json_map4 = F5(function(f, d1, d2, d3, d4) +{ + return _Json_mapMany(f, [d1, d2, d3, d4]); +}); + +var _Json_map5 = F6(function(f, d1, d2, d3, d4, d5) +{ + return _Json_mapMany(f, [d1, d2, d3, d4, d5]); +}); + +var _Json_map6 = F7(function(f, d1, d2, d3, d4, d5, d6) +{ + return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6]); +}); + +var _Json_map7 = F8(function(f, d1, d2, d3, d4, d5, d6, d7) +{ + return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6, d7]); +}); + +var _Json_map8 = F9(function(f, d1, d2, d3, d4, d5, d6, d7, d8) +{ + return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6, d7, d8]); +}); + + +// DECODE + +var _Json_runOnString = F2(function(decoder, string) +{ + try + { + var value = JSON.parse(string); + return _Json_runHelp(decoder, value); + } + catch (e) + { + return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, 'This is not valid JSON! ' + e.message, _Json_wrap(string))); + } +}); + +var _Json_run = F2(function(decoder, value) +{ + return _Json_runHelp(decoder, _Json_unwrap(value)); +}); + +function _Json_runHelp(decoder, value) +{ + switch (decoder.$) + { + case 2: + return decoder.b(value); + + case 5: + return (value === null) + ? $elm$core$Result$Ok(decoder.c) + : _Json_expecting('null', value); + + case 3: + if (!_Json_isArray(value)) + { + return _Json_expecting('a LIST', value); + } + return _Json_runArrayDecoder(decoder.b, value, _List_fromArray); + + case 4: + if (!_Json_isArray(value)) + { + return _Json_expecting('an ARRAY', value); + } + return _Json_runArrayDecoder(decoder.b, value, _Json_toElmArray); + + case 6: + var field = decoder.d; + if (typeof value !== 'object' || value === null || !(field in value)) + { + return _Json_expecting('an OBJECT with a field named `' + field + '`', value); + } + var result = _Json_runHelp(decoder.b, value[field]); + return ($elm$core$Result$isOk(result)) ? result : $elm$core$Result$Err(A2($elm$json$Json$Decode$Field, field, result.a)); + + case 7: + var index = decoder.e; + if (!_Json_isArray(value)) + { + return _Json_expecting('an ARRAY', value); + } + if (index >= value.length) + { + return _Json_expecting('a LONGER array. Need index ' + index + ' but only see ' + value.length + ' entries', value); + } + var result = _Json_runHelp(decoder.b, value[index]); + return ($elm$core$Result$isOk(result)) ? result : $elm$core$Result$Err(A2($elm$json$Json$Decode$Index, index, result.a)); + + case 8: + if (typeof value !== 'object' || value === null || _Json_isArray(value)) + { + return _Json_expecting('an OBJECT', value); + } + + var keyValuePairs = _List_Nil; + // TODO test perf of Object.keys and switch when support is good enough + for (var key in value) + { + if (value.hasOwnProperty(key)) + { + var result = _Json_runHelp(decoder.b, value[key]); + if (!$elm$core$Result$isOk(result)) + { + return $elm$core$Result$Err(A2($elm$json$Json$Decode$Field, key, result.a)); + } + keyValuePairs = _List_Cons(_Utils_Tuple2(key, result.a), keyValuePairs); + } + } + return $elm$core$Result$Ok($elm$core$List$reverse(keyValuePairs)); + + case 9: + var answer = decoder.f; + var decoders = decoder.g; + for (var i = 0; i < decoders.length; i++) + { + var result = _Json_runHelp(decoders[i], value); + if (!$elm$core$Result$isOk(result)) + { + return result; + } + answer = answer(result.a); + } + return $elm$core$Result$Ok(answer); + + case 10: + var result = _Json_runHelp(decoder.b, value); + return (!$elm$core$Result$isOk(result)) + ? result + : _Json_runHelp(decoder.h(result.a), value); + + case 11: + var errors = _List_Nil; + for (var temp = decoder.g; temp.b; temp = temp.b) // WHILE_CONS + { + var result = _Json_runHelp(temp.a, value); + if ($elm$core$Result$isOk(result)) + { + return result; + } + errors = _List_Cons(result.a, errors); + } + return $elm$core$Result$Err($elm$json$Json$Decode$OneOf($elm$core$List$reverse(errors))); + + case 1: + return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, decoder.a, _Json_wrap(value))); + + case 0: + return $elm$core$Result$Ok(decoder.a); + } +} + +function _Json_runArrayDecoder(decoder, value, toElmValue) +{ + var len = value.length; + var array = new Array(len); + for (var i = 0; i < len; i++) + { + var result = _Json_runHelp(decoder, value[i]); + if (!$elm$core$Result$isOk(result)) + { + return $elm$core$Result$Err(A2($elm$json$Json$Decode$Index, i, result.a)); + } + array[i] = result.a; + } + return $elm$core$Result$Ok(toElmValue(array)); +} + +function _Json_isArray(value) +{ + return Array.isArray(value) || (typeof FileList !== 'undefined' && value instanceof FileList); +} + +function _Json_toElmArray(array) +{ + return A2($elm$core$Array$initialize, array.length, function(i) { return array[i]; }); +} + +function _Json_expecting(type, value) +{ + return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, 'Expecting ' + type, _Json_wrap(value))); +} + + +// EQUALITY + +function _Json_equality(x, y) +{ + if (x === y) + { + return true; + } + + if (x.$ !== y.$) + { + return false; + } + + switch (x.$) + { + case 0: + case 1: + return x.a === y.a; + + case 2: + return x.b === y.b; + + case 5: + return x.c === y.c; + + case 3: + case 4: + case 8: + return _Json_equality(x.b, y.b); + + case 6: + return x.d === y.d && _Json_equality(x.b, y.b); + + case 7: + return x.e === y.e && _Json_equality(x.b, y.b); + + case 9: + return x.f === y.f && _Json_listEquality(x.g, y.g); + + case 10: + return x.h === y.h && _Json_equality(x.b, y.b); + + case 11: + return _Json_listEquality(x.g, y.g); + } +} + +function _Json_listEquality(aDecoders, bDecoders) +{ + var len = aDecoders.length; + if (len !== bDecoders.length) + { + return false; + } + for (var i = 0; i < len; i++) + { + if (!_Json_equality(aDecoders[i], bDecoders[i])) + { + return false; + } + } + return true; +} + + +// ENCODE + +var _Json_encode = F2(function(indentLevel, value) +{ + return JSON.stringify(_Json_unwrap(value), null, indentLevel) + ''; +}); + +function _Json_wrap(value) { return { $: 0, a: value }; } +function _Json_unwrap(value) { return value.a; } + +function _Json_wrap_UNUSED(value) { return value; } +function _Json_unwrap_UNUSED(value) { return value; } + +function _Json_emptyArray() { return []; } +function _Json_emptyObject() { return {}; } + +var _Json_addField = F3(function(key, value, object) +{ + object[key] = _Json_unwrap(value); + return object; +}); + +function _Json_addEntry(func) +{ + return F2(function(entry, array) + { + array.push(_Json_unwrap(func(entry))); + return array; + }); +} + +var _Json_encodeNull = _Json_wrap(null); + + + +// TASKS + +function _Scheduler_succeed(value) +{ + return { + $: 0, + a: value + }; +} + +function _Scheduler_fail(error) +{ + return { + $: 1, + a: error + }; +} + +function _Scheduler_binding(callback) +{ + return { + $: 2, + b: callback, + c: null + }; +} + +var _Scheduler_andThen = F2(function(callback, task) +{ + return { + $: 3, + b: callback, + d: task + }; +}); + +var _Scheduler_onError = F2(function(callback, task) +{ + return { + $: 4, + b: callback, + d: task + }; +}); + +function _Scheduler_receive(callback) +{ + return { + $: 5, + b: callback + }; +} + + +// PROCESSES + +var _Scheduler_guid = 0; + +function _Scheduler_rawSpawn(task) +{ + var proc = { + $: 0, + e: _Scheduler_guid++, + f: task, + g: null, + h: [] + }; + + _Scheduler_enqueue(proc); + + return proc; +} + +function _Scheduler_spawn(task) +{ + return _Scheduler_binding(function(callback) { + callback(_Scheduler_succeed(_Scheduler_rawSpawn(task))); + }); +} + +function _Scheduler_rawSend(proc, msg) +{ + proc.h.push(msg); + _Scheduler_enqueue(proc); +} + +var _Scheduler_send = F2(function(proc, msg) +{ + return _Scheduler_binding(function(callback) { + _Scheduler_rawSend(proc, msg); + callback(_Scheduler_succeed(_Utils_Tuple0)); + }); +}); + +function _Scheduler_kill(proc) +{ + return _Scheduler_binding(function(callback) { + var task = proc.f; + if (task.$ === 2 && task.c) + { + task.c(); + } + + proc.f = null; + + callback(_Scheduler_succeed(_Utils_Tuple0)); + }); +} + + +/* STEP PROCESSES + +type alias Process = + { $ : tag + , id : unique_id + , root : Task + , stack : null | { $: SUCCEED | FAIL, a: callback, b: stack } + , mailbox : [msg] + } + +*/ + + +var _Scheduler_working = false; +var _Scheduler_queue = []; + + +function _Scheduler_enqueue(proc) +{ + _Scheduler_queue.push(proc); + if (_Scheduler_working) + { + return; + } + _Scheduler_working = true; + while (proc = _Scheduler_queue.shift()) + { + _Scheduler_step(proc); + } + _Scheduler_working = false; +} + + +function _Scheduler_step(proc) +{ + while (proc.f) + { + var rootTag = proc.f.$; + if (rootTag === 0 || rootTag === 1) + { + while (proc.g && proc.g.$ !== rootTag) + { + proc.g = proc.g.i; + } + if (!proc.g) + { + return; + } + proc.f = proc.g.b(proc.f.a); + proc.g = proc.g.i; + } + else if (rootTag === 2) + { + proc.f.c = proc.f.b(function(newRoot) { + proc.f = newRoot; + _Scheduler_enqueue(proc); + }); + return; + } + else if (rootTag === 5) + { + if (proc.h.length === 0) + { + return; + } + proc.f = proc.f.b(proc.h.shift()); + } + else // if (rootTag === 3 || rootTag === 4) + { + proc.g = { + $: rootTag === 3 ? 0 : 1, + b: proc.f.b, + i: proc.g + }; + proc.f = proc.f.d; + } + } +} + + + +function _Process_sleep(time) +{ + return _Scheduler_binding(function(callback) { + var id = setTimeout(function() { + callback(_Scheduler_succeed(_Utils_Tuple0)); + }, time); + + return function() { clearTimeout(id); }; + }); +} + + + + +// PROGRAMS + + +var _Platform_worker = F4(function(impl, flagDecoder, debugMetadata, args) +{ + return _Platform_initialize( + flagDecoder, + args, + impl.init, + impl.update, + impl.subscriptions, + function() { return function() {} } + ); +}); + + + +// INITIALIZE A PROGRAM + + +function _Platform_initialize(flagDecoder, args, init, update, subscriptions, stepperBuilder) +{ + var result = A2(_Json_run, flagDecoder, _Json_wrap(args ? args['flags'] : undefined)); + $elm$core$Result$isOk(result) || _Debug_crash(2 /**/, _Json_errorToString(result.a) /**/); + var managers = {}; + var initPair = init(result.a); + var model = initPair.a; + var stepper = stepperBuilder(sendToApp, model); + var ports = _Platform_setupEffects(managers, sendToApp); + + function sendToApp(msg, viewMetadata) + { + var pair = A2(update, msg, model); + stepper(model = pair.a, viewMetadata); + _Platform_enqueueEffects(managers, pair.b, subscriptions(model)); + } + + _Platform_enqueueEffects(managers, initPair.b, subscriptions(model)); + + return ports ? { ports: ports } : {}; +} + + + +// TRACK PRELOADS +// +// This is used by code in elm/browser and elm/http +// to register any HTTP requests that are triggered by init. +// + + +var _Platform_preload; + + +function _Platform_registerPreload(url) +{ + _Platform_preload.add(url); +} + + + +// EFFECT MANAGERS + + +var _Platform_effectManagers = {}; + + +function _Platform_setupEffects(managers, sendToApp) +{ + var ports; + + // setup all necessary effect managers + for (var key in _Platform_effectManagers) + { + var manager = _Platform_effectManagers[key]; + + if (manager.a) + { + ports = ports || {}; + ports[key] = manager.a(key, sendToApp); + } + + managers[key] = _Platform_instantiateManager(manager, sendToApp); + } + + return ports; +} + + +function _Platform_createManager(init, onEffects, onSelfMsg, cmdMap, subMap) +{ + return { + b: init, + c: onEffects, + d: onSelfMsg, + e: cmdMap, + f: subMap + }; +} + + +function _Platform_instantiateManager(info, sendToApp) +{ + var router = { + g: sendToApp, + h: undefined + }; + + var onEffects = info.c; + var onSelfMsg = info.d; + var cmdMap = info.e; + var subMap = info.f; + + function loop(state) + { + return A2(_Scheduler_andThen, loop, _Scheduler_receive(function(msg) + { + var value = msg.a; + + if (msg.$ === 0) + { + return A3(onSelfMsg, router, value, state); + } + + return cmdMap && subMap + ? A4(onEffects, router, value.i, value.j, state) + : A3(onEffects, router, cmdMap ? value.i : value.j, state); + })); + } + + return router.h = _Scheduler_rawSpawn(A2(_Scheduler_andThen, loop, info.b)); +} + + + +// ROUTING + + +var _Platform_sendToApp = F2(function(router, msg) +{ + return _Scheduler_binding(function(callback) + { + router.g(msg); + callback(_Scheduler_succeed(_Utils_Tuple0)); + }); +}); + + +var _Platform_sendToSelf = F2(function(router, msg) +{ + return A2(_Scheduler_send, router.h, { + $: 0, + a: msg + }); +}); + + + +// BAGS + + +function _Platform_leaf(home) +{ + return function(value) + { + return { + $: 1, + k: home, + l: value + }; + }; +} + + +function _Platform_batch(list) +{ + return { + $: 2, + m: list + }; +} + + +var _Platform_map = F2(function(tagger, bag) +{ + return { + $: 3, + n: tagger, + o: bag + } +}); + + + +// PIPE BAGS INTO EFFECT MANAGERS +// +// Effects must be queued! +// +// Say your init contains a synchronous command, like Time.now or Time.here +// +// - This will produce a batch of effects (FX_1) +// - The synchronous task triggers the subsequent `update` call +// - This will produce a batch of effects (FX_2) +// +// If we just start dispatching FX_2, subscriptions from FX_2 can be processed +// before subscriptions from FX_1. No good! Earlier versions of this code had +// this problem, leading to these reports: +// +// https://github.com/elm/core/issues/980 +// https://github.com/elm/core/pull/981 +// https://github.com/elm/compiler/issues/1776 +// +// The queue is necessary to avoid ordering issues for synchronous commands. + + +// Why use true/false here? Why not just check the length of the queue? +// The goal is to detect "are we currently dispatching effects?" If we +// are, we need to bail and let the ongoing while loop handle things. +// +// Now say the queue has 1 element. When we dequeue the final element, +// the queue will be empty, but we are still actively dispatching effects. +// So you could get queue jumping in a really tricky category of cases. +// +var _Platform_effectsQueue = []; +var _Platform_effectsActive = false; + + +function _Platform_enqueueEffects(managers, cmdBag, subBag) +{ + _Platform_effectsQueue.push({ p: managers, q: cmdBag, r: subBag }); + + if (_Platform_effectsActive) return; + + _Platform_effectsActive = true; + for (var fx; fx = _Platform_effectsQueue.shift(); ) + { + _Platform_dispatchEffects(fx.p, fx.q, fx.r); + } + _Platform_effectsActive = false; +} + + +function _Platform_dispatchEffects(managers, cmdBag, subBag) +{ + var effectsDict = {}; + _Platform_gatherEffects(true, cmdBag, effectsDict, null); + _Platform_gatherEffects(false, subBag, effectsDict, null); + + for (var home in managers) + { + _Scheduler_rawSend(managers[home], { + $: 'fx', + a: effectsDict[home] || { i: _List_Nil, j: _List_Nil } + }); + } +} + + +function _Platform_gatherEffects(isCmd, bag, effectsDict, taggers) +{ + switch (bag.$) + { + case 1: + var home = bag.k; + var effect = _Platform_toEffect(isCmd, home, taggers, bag.l); + effectsDict[home] = _Platform_insert(isCmd, effect, effectsDict[home]); + return; + + case 2: + for (var list = bag.m; list.b; list = list.b) // WHILE_CONS + { + _Platform_gatherEffects(isCmd, list.a, effectsDict, taggers); + } + return; + + case 3: + _Platform_gatherEffects(isCmd, bag.o, effectsDict, { + s: bag.n, + t: taggers + }); + return; + } +} + + +function _Platform_toEffect(isCmd, home, taggers, value) +{ + function applyTaggers(x) + { + for (var temp = taggers; temp; temp = temp.t) + { + x = temp.s(x); + } + return x; + } + + var map = isCmd + ? _Platform_effectManagers[home].e + : _Platform_effectManagers[home].f; + + return A2(map, applyTaggers, value) +} + + +function _Platform_insert(isCmd, newEffect, effects) +{ + effects = effects || { i: _List_Nil, j: _List_Nil }; + + isCmd + ? (effects.i = _List_Cons(newEffect, effects.i)) + : (effects.j = _List_Cons(newEffect, effects.j)); + + return effects; +} + + + +// PORTS + + +function _Platform_checkPortName(name) +{ + if (_Platform_effectManagers[name]) + { + _Debug_crash(3, name) + } +} + + + +// OUTGOING PORTS + + +function _Platform_outgoingPort(name, converter) +{ + _Platform_checkPortName(name); + _Platform_effectManagers[name] = { + e: _Platform_outgoingPortMap, + u: converter, + a: _Platform_setupOutgoingPort + }; + return _Platform_leaf(name); +} + + +var _Platform_outgoingPortMap = F2(function(tagger, value) { return value; }); + + +function _Platform_setupOutgoingPort(name) +{ + var subs = []; + var converter = _Platform_effectManagers[name].u; + + // CREATE MANAGER + + var init = _Process_sleep(0); + + _Platform_effectManagers[name].b = init; + _Platform_effectManagers[name].c = F3(function(router, cmdList, state) + { + for ( ; cmdList.b; cmdList = cmdList.b) // WHILE_CONS + { + // grab a separate reference to subs in case unsubscribe is called + var currentSubs = subs; + var value = _Json_unwrap(converter(cmdList.a)); + for (var i = 0; i < currentSubs.length; i++) + { + currentSubs[i](value); + } + } + return init; + }); + + // PUBLIC API + + function subscribe(callback) + { + subs.push(callback); + } + + function unsubscribe(callback) + { + // copy subs into a new array in case unsubscribe is called within a + // subscribed callback + subs = subs.slice(); + var index = subs.indexOf(callback); + if (index >= 0) + { + subs.splice(index, 1); + } + } + + return { + subscribe: subscribe, + unsubscribe: unsubscribe + }; +} + + + +// INCOMING PORTS + + +function _Platform_incomingPort(name, converter) +{ + _Platform_checkPortName(name); + _Platform_effectManagers[name] = { + f: _Platform_incomingPortMap, + u: converter, + a: _Platform_setupIncomingPort + }; + return _Platform_leaf(name); +} + + +var _Platform_incomingPortMap = F2(function(tagger, finalTagger) +{ + return function(value) + { + return tagger(finalTagger(value)); + }; +}); + + +function _Platform_setupIncomingPort(name, sendToApp) +{ + var subs = _List_Nil; + var converter = _Platform_effectManagers[name].u; + + // CREATE MANAGER + + var init = _Scheduler_succeed(null); + + _Platform_effectManagers[name].b = init; + _Platform_effectManagers[name].c = F3(function(router, subList, state) + { + subs = subList; + return init; + }); + + // PUBLIC API + + function send(incomingValue) + { + var result = A2(_Json_run, converter, _Json_wrap(incomingValue)); + + $elm$core$Result$isOk(result) || _Debug_crash(4, name, result.a); + + var value = result.a; + for (var temp = subs; temp.b; temp = temp.b) // WHILE_CONS + { + sendToApp(temp.a(value)); + } + } + + return { send: send }; +} + + + +// EXPORT ELM MODULES +// +// Have DEBUG and PROD versions so that we can (1) give nicer errors in +// debug mode and (2) not pay for the bits needed for that in prod mode. +// + + +function _Platform_export_UNUSED(exports) +{ + scope['Elm'] + ? _Platform_mergeExportsProd(scope['Elm'], exports) + : scope['Elm'] = exports; +} + + +function _Platform_mergeExportsProd(obj, exports) +{ + for (var name in exports) + { + (name in obj) + ? (name == 'init') + ? _Debug_crash(6) + : _Platform_mergeExportsProd(obj[name], exports[name]) + : (obj[name] = exports[name]); + } +} + + +function _Platform_export(exports) +{ + scope['Elm'] + ? _Platform_mergeExportsDebug('Elm', scope['Elm'], exports) + : scope['Elm'] = exports; +} + + +function _Platform_mergeExportsDebug(moduleName, obj, exports) +{ + for (var name in exports) + { + (name in obj) + ? (name == 'init') + ? _Debug_crash(6, moduleName) + : _Platform_mergeExportsDebug(moduleName + '.' + name, obj[name], exports[name]) + : (obj[name] = exports[name]); + } +} + + + + +// HELPERS + + +var _VirtualDom_divertHrefToApp; + +var _VirtualDom_doc = typeof document !== 'undefined' ? document : {}; + + +function _VirtualDom_appendChild(parent, child) +{ + parent.appendChild(child); +} + +var _VirtualDom_init = F4(function(virtualNode, flagDecoder, debugMetadata, args) +{ + // NOTE: this function needs _Platform_export available to work + + /**_UNUSED/ + var node = args['node']; + //*/ + /**/ + var node = args && args['node'] ? args['node'] : _Debug_crash(0); + //*/ + + node.parentNode.replaceChild( + _VirtualDom_render(virtualNode, function() {}), + node + ); + + return {}; +}); + + + +// TEXT + + +function _VirtualDom_text(string) +{ + return { + $: 0, + a: string + }; +} + + + +// NODE + + +var _VirtualDom_nodeNS = F2(function(namespace, tag) +{ + return F2(function(factList, kidList) + { + for (var kids = [], descendantsCount = 0; kidList.b; kidList = kidList.b) // WHILE_CONS + { + var kid = kidList.a; + descendantsCount += (kid.b || 0); + kids.push(kid); + } + descendantsCount += kids.length; + + return { + $: 1, + c: tag, + d: _VirtualDom_organizeFacts(factList), + e: kids, + f: namespace, + b: descendantsCount + }; + }); +}); + + +var _VirtualDom_node = _VirtualDom_nodeNS(undefined); + + + +// KEYED NODE + + +var _VirtualDom_keyedNodeNS = F2(function(namespace, tag) +{ + return F2(function(factList, kidList) + { + for (var kids = [], descendantsCount = 0; kidList.b; kidList = kidList.b) // WHILE_CONS + { + var kid = kidList.a; + descendantsCount += (kid.b.b || 0); + kids.push(kid); + } + descendantsCount += kids.length; + + return { + $: 2, + c: tag, + d: _VirtualDom_organizeFacts(factList), + e: kids, + f: namespace, + b: descendantsCount + }; + }); +}); + + +var _VirtualDom_keyedNode = _VirtualDom_keyedNodeNS(undefined); + + + +// CUSTOM + + +function _VirtualDom_custom(factList, model, render, diff) +{ + return { + $: 3, + d: _VirtualDom_organizeFacts(factList), + g: model, + h: render, + i: diff + }; +} + + + +// MAP + + +var _VirtualDom_map = F2(function(tagger, node) +{ + return { + $: 4, + j: tagger, + k: node, + b: 1 + (node.b || 0) + }; +}); + + + +// LAZY + + +function _VirtualDom_thunk(refs, thunk) +{ + return { + $: 5, + l: refs, + m: thunk, + k: undefined + }; +} + +var _VirtualDom_lazy = F2(function(func, a) +{ + return _VirtualDom_thunk([func, a], function() { + return func(a); + }); +}); + +var _VirtualDom_lazy2 = F3(function(func, a, b) +{ + return _VirtualDom_thunk([func, a, b], function() { + return A2(func, a, b); + }); +}); + +var _VirtualDom_lazy3 = F4(function(func, a, b, c) +{ + return _VirtualDom_thunk([func, a, b, c], function() { + return A3(func, a, b, c); + }); +}); + +var _VirtualDom_lazy4 = F5(function(func, a, b, c, d) +{ + return _VirtualDom_thunk([func, a, b, c, d], function() { + return A4(func, a, b, c, d); + }); +}); + +var _VirtualDom_lazy5 = F6(function(func, a, b, c, d, e) +{ + return _VirtualDom_thunk([func, a, b, c, d, e], function() { + return A5(func, a, b, c, d, e); + }); +}); + +var _VirtualDom_lazy6 = F7(function(func, a, b, c, d, e, f) +{ + return _VirtualDom_thunk([func, a, b, c, d, e, f], function() { + return A6(func, a, b, c, d, e, f); + }); +}); + +var _VirtualDom_lazy7 = F8(function(func, a, b, c, d, e, f, g) +{ + return _VirtualDom_thunk([func, a, b, c, d, e, f, g], function() { + return A7(func, a, b, c, d, e, f, g); + }); +}); + +var _VirtualDom_lazy8 = F9(function(func, a, b, c, d, e, f, g, h) +{ + return _VirtualDom_thunk([func, a, b, c, d, e, f, g, h], function() { + return A8(func, a, b, c, d, e, f, g, h); + }); +}); + + + +// FACTS + + +var _VirtualDom_on = F2(function(key, handler) +{ + return { + $: 'a0', + n: key, + o: handler + }; +}); +var _VirtualDom_style = F2(function(key, value) +{ + return { + $: 'a1', + n: key, + o: value + }; +}); +var _VirtualDom_property = F2(function(key, value) +{ + return { + $: 'a2', + n: key, + o: value + }; +}); +var _VirtualDom_attribute = F2(function(key, value) +{ + return { + $: 'a3', + n: key, + o: value + }; +}); +var _VirtualDom_attributeNS = F3(function(namespace, key, value) +{ + return { + $: 'a4', + n: key, + o: { f: namespace, o: value } + }; +}); + + + +// XSS ATTACK VECTOR CHECKS +// +// For some reason, tabs can appear in href protocols and it still works. +// So '\tjava\tSCRIPT:alert("!!!")' and 'javascript:alert("!!!")' are the same +// in practice. That is why _VirtualDom_RE_js and _VirtualDom_RE_js_html look +// so freaky. +// +// Pulling the regular expressions out to the top level gives a slight speed +// boost in small benchmarks (4-10%) but hoisting values to reduce allocation +// can be unpredictable in large programs where JIT may have a harder time with +// functions are not fully self-contained. The benefit is more that the js and +// js_html ones are so weird that I prefer to see them near each other. + + +var _VirtualDom_RE_script = /^script$/i; +var _VirtualDom_RE_on_formAction = /^(on|formAction$)/i; +var _VirtualDom_RE_js = /^\s*j\s*a\s*v\s*a\s*s\s*c\s*r\s*i\s*p\s*t\s*:/i; +var _VirtualDom_RE_js_html = /^\s*(j\s*a\s*v\s*a\s*s\s*c\s*r\s*i\s*p\s*t\s*:|d\s*a\s*t\s*a\s*:\s*t\s*e\s*x\s*t\s*\/\s*h\s*t\s*m\s*l\s*(,|;))/i; + + +function _VirtualDom_noScript(tag) +{ + return _VirtualDom_RE_script.test(tag) ? 'p' : tag; +} + +function _VirtualDom_noOnOrFormAction(key) +{ + return _VirtualDom_RE_on_formAction.test(key) ? 'data-' + key : key; +} + +function _VirtualDom_noInnerHtmlOrFormAction(key) +{ + return key == 'innerHTML' || key == 'formAction' ? 'data-' + key : key; +} + +function _VirtualDom_noJavaScriptUri(value) +{ + return _VirtualDom_RE_js.test(value) + ? /**_UNUSED/''//*//**/'javascript:alert("This is an XSS vector. Please use ports or web components instead.")'//*/ + : value; +} + +function _VirtualDom_noJavaScriptOrHtmlUri(value) +{ + return _VirtualDom_RE_js_html.test(value) + ? /**_UNUSED/''//*//**/'javascript:alert("This is an XSS vector. Please use ports or web components instead.")'//*/ + : value; +} + +function _VirtualDom_noJavaScriptOrHtmlJson(value) +{ + return (typeof _Json_unwrap(value) === 'string' && _VirtualDom_RE_js_html.test(_Json_unwrap(value))) + ? _Json_wrap( + /**_UNUSED/''//*//**/'javascript:alert("This is an XSS vector. Please use ports or web components instead.")'//*/ + ) : value; +} + + + +// MAP FACTS + + +var _VirtualDom_mapAttribute = F2(function(func, attr) +{ + return (attr.$ === 'a0') + ? A2(_VirtualDom_on, attr.n, _VirtualDom_mapHandler(func, attr.o)) + : attr; +}); + +function _VirtualDom_mapHandler(func, handler) +{ + var tag = $elm$virtual_dom$VirtualDom$toHandlerInt(handler); + + // 0 = Normal + // 1 = MayStopPropagation + // 2 = MayPreventDefault + // 3 = Custom + + return { + $: handler.$, + a: + !tag + ? A2($elm$json$Json$Decode$map, func, handler.a) + : + A3($elm$json$Json$Decode$map2, + tag < 3 + ? _VirtualDom_mapEventTuple + : _VirtualDom_mapEventRecord, + $elm$json$Json$Decode$succeed(func), + handler.a + ) + }; +} + +var _VirtualDom_mapEventTuple = F2(function(func, tuple) +{ + return _Utils_Tuple2(func(tuple.a), tuple.b); +}); + +var _VirtualDom_mapEventRecord = F2(function(func, record) +{ + return { + message: func(record.message), + stopPropagation: record.stopPropagation, + preventDefault: record.preventDefault + } +}); + + + +// ORGANIZE FACTS + + +function _VirtualDom_organizeFacts(factList) +{ + for (var facts = {}; factList.b; factList = factList.b) // WHILE_CONS + { + var entry = factList.a; + + var tag = entry.$; + var key = entry.n; + var value = entry.o; + + if (tag === 'a2') + { + (key === 'className') + ? _VirtualDom_addClass(facts, key, _Json_unwrap(value)) + : facts[key] = _Json_unwrap(value); + + continue; + } + + var subFacts = facts[tag] || (facts[tag] = {}); + (tag === 'a3' && key === 'class') + ? _VirtualDom_addClass(subFacts, key, value) + : subFacts[key] = value; + } + + return facts; +} + +function _VirtualDom_addClass(object, key, newClass) +{ + var classes = object[key]; + object[key] = classes ? classes + ' ' + newClass : newClass; +} + + + +// RENDER + + +function _VirtualDom_render(vNode, eventNode) +{ + var tag = vNode.$; + + if (tag === 5) + { + return _VirtualDom_render(vNode.k || (vNode.k = vNode.m()), eventNode); + } + + if (tag === 0) + { + return _VirtualDom_doc.createTextNode(vNode.a); + } + + if (tag === 4) + { + var subNode = vNode.k; + var tagger = vNode.j; + + while (subNode.$ === 4) + { + typeof tagger !== 'object' + ? tagger = [tagger, subNode.j] + : tagger.push(subNode.j); + + subNode = subNode.k; + } + + var subEventRoot = { j: tagger, p: eventNode }; + var domNode = _VirtualDom_render(subNode, subEventRoot); + domNode.elm_event_node_ref = subEventRoot; + return domNode; + } + + if (tag === 3) + { + var domNode = vNode.h(vNode.g); + _VirtualDom_applyFacts(domNode, eventNode, vNode.d); + return domNode; + } + + // at this point `tag` must be 1 or 2 + + var domNode = vNode.f + ? _VirtualDom_doc.createElementNS(vNode.f, vNode.c) + : _VirtualDom_doc.createElement(vNode.c); + + if (_VirtualDom_divertHrefToApp && vNode.c == 'a') + { + domNode.addEventListener('click', _VirtualDom_divertHrefToApp(domNode)); + } + + _VirtualDom_applyFacts(domNode, eventNode, vNode.d); + + for (var kids = vNode.e, i = 0; i < kids.length; i++) + { + _VirtualDom_appendChild(domNode, _VirtualDom_render(tag === 1 ? kids[i] : kids[i].b, eventNode)); + } + + return domNode; +} + + + +// APPLY FACTS + + +function _VirtualDom_applyFacts(domNode, eventNode, facts) +{ + for (var key in facts) + { + var value = facts[key]; + + key === 'a1' + ? _VirtualDom_applyStyles(domNode, value) + : + key === 'a0' + ? _VirtualDom_applyEvents(domNode, eventNode, value) + : + key === 'a3' + ? _VirtualDom_applyAttrs(domNode, value) + : + key === 'a4' + ? _VirtualDom_applyAttrsNS(domNode, value) + : + ((key !== 'value' && key !== 'checked') || domNode[key] !== value) && (domNode[key] = value); + } +} + + + +// APPLY STYLES + + +function _VirtualDom_applyStyles(domNode, styles) +{ + var domNodeStyle = domNode.style; + + for (var key in styles) + { + domNodeStyle[key] = styles[key]; + } +} + + + +// APPLY ATTRS + + +function _VirtualDom_applyAttrs(domNode, attrs) +{ + for (var key in attrs) + { + var value = attrs[key]; + typeof value !== 'undefined' + ? domNode.setAttribute(key, value) + : domNode.removeAttribute(key); + } +} + + + +// APPLY NAMESPACED ATTRS + + +function _VirtualDom_applyAttrsNS(domNode, nsAttrs) +{ + for (var key in nsAttrs) + { + var pair = nsAttrs[key]; + var namespace = pair.f; + var value = pair.o; + + typeof value !== 'undefined' + ? domNode.setAttributeNS(namespace, key, value) + : domNode.removeAttributeNS(namespace, key); + } +} + + + +// APPLY EVENTS + + +function _VirtualDom_applyEvents(domNode, eventNode, events) +{ + var allCallbacks = domNode.elmFs || (domNode.elmFs = {}); + + for (var key in events) + { + var newHandler = events[key]; + var oldCallback = allCallbacks[key]; + + if (!newHandler) + { + domNode.removeEventListener(key, oldCallback); + allCallbacks[key] = undefined; + continue; + } + + if (oldCallback) + { + var oldHandler = oldCallback.q; + if (oldHandler.$ === newHandler.$) + { + oldCallback.q = newHandler; + continue; + } + domNode.removeEventListener(key, oldCallback); + } + + oldCallback = _VirtualDom_makeCallback(eventNode, newHandler); + domNode.addEventListener(key, oldCallback, + _VirtualDom_passiveSupported + && { passive: $elm$virtual_dom$VirtualDom$toHandlerInt(newHandler) < 2 } + ); + allCallbacks[key] = oldCallback; + } +} + + + +// PASSIVE EVENTS + + +var _VirtualDom_passiveSupported; + +try +{ + window.addEventListener('t', null, Object.defineProperty({}, 'passive', { + get: function() { _VirtualDom_passiveSupported = true; } + })); +} +catch(e) {} + + + +// EVENT HANDLERS + + +function _VirtualDom_makeCallback(eventNode, initialHandler) +{ + function callback(event) + { + var handler = callback.q; + var result = _Json_runHelp(handler.a, event); + + if (!$elm$core$Result$isOk(result)) + { + return; + } + + var tag = $elm$virtual_dom$VirtualDom$toHandlerInt(handler); + + // 0 = Normal + // 1 = MayStopPropagation + // 2 = MayPreventDefault + // 3 = Custom + + var value = result.a; + var message = !tag ? value : tag < 3 ? value.a : value.message; + var stopPropagation = tag == 1 ? value.b : tag == 3 && value.stopPropagation; + var currentEventNode = ( + stopPropagation && event.stopPropagation(), + (tag == 2 ? value.b : tag == 3 && value.preventDefault) && event.preventDefault(), + eventNode + ); + var tagger; + var i; + while (tagger = currentEventNode.j) + { + if (typeof tagger == 'function') + { + message = tagger(message); + } + else + { + for (var i = tagger.length; i--; ) + { + message = tagger[i](message); + } + } + currentEventNode = currentEventNode.p; + } + currentEventNode(message, stopPropagation); // stopPropagation implies isSync + } + + callback.q = initialHandler; + + return callback; +} + +function _VirtualDom_equalEvents(x, y) +{ + return x.$ == y.$ && _Json_equality(x.a, y.a); +} + + + +// DIFF + + +// TODO: Should we do patches like in iOS? +// +// type Patch +// = At Int Patch +// | Batch (List Patch) +// | Change ... +// +// How could it not be better? +// +function _VirtualDom_diff(x, y) +{ + var patches = []; + _VirtualDom_diffHelp(x, y, patches, 0); + return patches; +} + + +function _VirtualDom_pushPatch(patches, type, index, data) +{ + var patch = { + $: type, + r: index, + s: data, + t: undefined, + u: undefined + }; + patches.push(patch); + return patch; +} + + +function _VirtualDom_diffHelp(x, y, patches, index) +{ + if (x === y) + { + return; + } + + var xType = x.$; + var yType = y.$; + + // Bail if you run into different types of nodes. Implies that the + // structure has changed significantly and it's not worth a diff. + if (xType !== yType) + { + if (xType === 1 && yType === 2) + { + y = _VirtualDom_dekey(y); + yType = 1; + } + else + { + _VirtualDom_pushPatch(patches, 0, index, y); + return; + } + } + + // Now we know that both nodes are the same $. + switch (yType) + { + case 5: + var xRefs = x.l; + var yRefs = y.l; + var i = xRefs.length; + var same = i === yRefs.length; + while (same && i--) + { + same = xRefs[i] === yRefs[i]; + } + if (same) + { + y.k = x.k; + return; + } + y.k = y.m(); + var subPatches = []; + _VirtualDom_diffHelp(x.k, y.k, subPatches, 0); + subPatches.length > 0 && _VirtualDom_pushPatch(patches, 1, index, subPatches); + return; + + case 4: + // gather nested taggers + var xTaggers = x.j; + var yTaggers = y.j; + var nesting = false; + + var xSubNode = x.k; + while (xSubNode.$ === 4) + { + nesting = true; + + typeof xTaggers !== 'object' + ? xTaggers = [xTaggers, xSubNode.j] + : xTaggers.push(xSubNode.j); + + xSubNode = xSubNode.k; + } + + var ySubNode = y.k; + while (ySubNode.$ === 4) + { + nesting = true; + + typeof yTaggers !== 'object' + ? yTaggers = [yTaggers, ySubNode.j] + : yTaggers.push(ySubNode.j); + + ySubNode = ySubNode.k; + } + + // Just bail if different numbers of taggers. This implies the + // structure of the virtual DOM has changed. + if (nesting && xTaggers.length !== yTaggers.length) + { + _VirtualDom_pushPatch(patches, 0, index, y); + return; + } + + // check if taggers are "the same" + if (nesting ? !_VirtualDom_pairwiseRefEqual(xTaggers, yTaggers) : xTaggers !== yTaggers) + { + _VirtualDom_pushPatch(patches, 2, index, yTaggers); + } + + // diff everything below the taggers + _VirtualDom_diffHelp(xSubNode, ySubNode, patches, index + 1); + return; + + case 0: + if (x.a !== y.a) + { + _VirtualDom_pushPatch(patches, 3, index, y.a); + } + return; + + case 1: + _VirtualDom_diffNodes(x, y, patches, index, _VirtualDom_diffKids); + return; + + case 2: + _VirtualDom_diffNodes(x, y, patches, index, _VirtualDom_diffKeyedKids); + return; + + case 3: + if (x.h !== y.h) + { + _VirtualDom_pushPatch(patches, 0, index, y); + return; + } + + var factsDiff = _VirtualDom_diffFacts(x.d, y.d); + factsDiff && _VirtualDom_pushPatch(patches, 4, index, factsDiff); + + var patch = y.i(x.g, y.g); + patch && _VirtualDom_pushPatch(patches, 5, index, patch); + + return; + } +} + +// assumes the incoming arrays are the same length +function _VirtualDom_pairwiseRefEqual(as, bs) +{ + for (var i = 0; i < as.length; i++) + { + if (as[i] !== bs[i]) + { + return false; + } + } + + return true; +} + +function _VirtualDom_diffNodes(x, y, patches, index, diffKids) +{ + // Bail if obvious indicators have changed. Implies more serious + // structural changes such that it's not worth it to diff. + if (x.c !== y.c || x.f !== y.f) + { + _VirtualDom_pushPatch(patches, 0, index, y); + return; + } + + var factsDiff = _VirtualDom_diffFacts(x.d, y.d); + factsDiff && _VirtualDom_pushPatch(patches, 4, index, factsDiff); + + diffKids(x, y, patches, index); +} + + + +// DIFF FACTS + + +// TODO Instead of creating a new diff object, it's possible to just test if +// there *is* a diff. During the actual patch, do the diff again and make the +// modifications directly. This way, there's no new allocations. Worth it? +function _VirtualDom_diffFacts(x, y, category) +{ + var diff; + + // look for changes and removals + for (var xKey in x) + { + if (xKey === 'a1' || xKey === 'a0' || xKey === 'a3' || xKey === 'a4') + { + var subDiff = _VirtualDom_diffFacts(x[xKey], y[xKey] || {}, xKey); + if (subDiff) + { + diff = diff || {}; + diff[xKey] = subDiff; + } + continue; + } + + // remove if not in the new facts + if (!(xKey in y)) + { + diff = diff || {}; + diff[xKey] = + !category + ? (typeof x[xKey] === 'string' ? '' : null) + : + (category === 'a1') + ? '' + : + (category === 'a0' || category === 'a3') + ? undefined + : + { f: x[xKey].f, o: undefined }; + + continue; + } + + var xValue = x[xKey]; + var yValue = y[xKey]; + + // reference equal, so don't worry about it + if (xValue === yValue && xKey !== 'value' && xKey !== 'checked' + || category === 'a0' && _VirtualDom_equalEvents(xValue, yValue)) + { + continue; + } + + diff = diff || {}; + diff[xKey] = yValue; + } + + // add new stuff + for (var yKey in y) + { + if (!(yKey in x)) + { + diff = diff || {}; + diff[yKey] = y[yKey]; + } + } + + return diff; +} + + + +// DIFF KIDS + + +function _VirtualDom_diffKids(xParent, yParent, patches, index) +{ + var xKids = xParent.e; + var yKids = yParent.e; + + var xLen = xKids.length; + var yLen = yKids.length; + + // FIGURE OUT IF THERE ARE INSERTS OR REMOVALS + + if (xLen > yLen) + { + _VirtualDom_pushPatch(patches, 6, index, { + v: yLen, + i: xLen - yLen + }); + } + else if (xLen < yLen) + { + _VirtualDom_pushPatch(patches, 7, index, { + v: xLen, + e: yKids + }); + } + + // PAIRWISE DIFF EVERYTHING ELSE + + for (var minLen = xLen < yLen ? xLen : yLen, i = 0; i < minLen; i++) + { + var xKid = xKids[i]; + _VirtualDom_diffHelp(xKid, yKids[i], patches, ++index); + index += xKid.b || 0; + } +} + + + +// KEYED DIFF + + +function _VirtualDom_diffKeyedKids(xParent, yParent, patches, rootIndex) +{ + var localPatches = []; + + var changes = {}; // Dict String Entry + var inserts = []; // Array { index : Int, entry : Entry } + // type Entry = { tag : String, vnode : VNode, index : Int, data : _ } + + var xKids = xParent.e; + var yKids = yParent.e; + var xLen = xKids.length; + var yLen = yKids.length; + var xIndex = 0; + var yIndex = 0; + + var index = rootIndex; + + while (xIndex < xLen && yIndex < yLen) + { + var x = xKids[xIndex]; + var y = yKids[yIndex]; + + var xKey = x.a; + var yKey = y.a; + var xNode = x.b; + var yNode = y.b; + + var newMatch = undefined; + var oldMatch = undefined; + + // check if keys match + + if (xKey === yKey) + { + index++; + _VirtualDom_diffHelp(xNode, yNode, localPatches, index); + index += xNode.b || 0; + + xIndex++; + yIndex++; + continue; + } + + // look ahead 1 to detect insertions and removals. + + var xNext = xKids[xIndex + 1]; + var yNext = yKids[yIndex + 1]; + + if (xNext) + { + var xNextKey = xNext.a; + var xNextNode = xNext.b; + oldMatch = yKey === xNextKey; + } + + if (yNext) + { + var yNextKey = yNext.a; + var yNextNode = yNext.b; + newMatch = xKey === yNextKey; + } + + + // swap x and y + if (newMatch && oldMatch) + { + index++; + _VirtualDom_diffHelp(xNode, yNextNode, localPatches, index); + _VirtualDom_insertNode(changes, localPatches, xKey, yNode, yIndex, inserts); + index += xNode.b || 0; + + index++; + _VirtualDom_removeNode(changes, localPatches, xKey, xNextNode, index); + index += xNextNode.b || 0; + + xIndex += 2; + yIndex += 2; + continue; + } + + // insert y + if (newMatch) + { + index++; + _VirtualDom_insertNode(changes, localPatches, yKey, yNode, yIndex, inserts); + _VirtualDom_diffHelp(xNode, yNextNode, localPatches, index); + index += xNode.b || 0; + + xIndex += 1; + yIndex += 2; + continue; + } + + // remove x + if (oldMatch) + { + index++; + _VirtualDom_removeNode(changes, localPatches, xKey, xNode, index); + index += xNode.b || 0; + + index++; + _VirtualDom_diffHelp(xNextNode, yNode, localPatches, index); + index += xNextNode.b || 0; + + xIndex += 2; + yIndex += 1; + continue; + } + + // remove x, insert y + if (xNext && xNextKey === yNextKey) + { + index++; + _VirtualDom_removeNode(changes, localPatches, xKey, xNode, index); + _VirtualDom_insertNode(changes, localPatches, yKey, yNode, yIndex, inserts); + index += xNode.b || 0; + + index++; + _VirtualDom_diffHelp(xNextNode, yNextNode, localPatches, index); + index += xNextNode.b || 0; + + xIndex += 2; + yIndex += 2; + continue; + } + + break; + } + + // eat up any remaining nodes with removeNode and insertNode + + while (xIndex < xLen) + { + index++; + var x = xKids[xIndex]; + var xNode = x.b; + _VirtualDom_removeNode(changes, localPatches, x.a, xNode, index); + index += xNode.b || 0; + xIndex++; + } + + while (yIndex < yLen) + { + var endInserts = endInserts || []; + var y = yKids[yIndex]; + _VirtualDom_insertNode(changes, localPatches, y.a, y.b, undefined, endInserts); + yIndex++; + } + + if (localPatches.length > 0 || inserts.length > 0 || endInserts) + { + _VirtualDom_pushPatch(patches, 8, rootIndex, { + w: localPatches, + x: inserts, + y: endInserts + }); + } +} + + + +// CHANGES FROM KEYED DIFF + + +var _VirtualDom_POSTFIX = '_elmW6BL'; + + +function _VirtualDom_insertNode(changes, localPatches, key, vnode, yIndex, inserts) +{ + var entry = changes[key]; + + // never seen this key before + if (!entry) + { + entry = { + c: 0, + z: vnode, + r: yIndex, + s: undefined + }; + + inserts.push({ r: yIndex, A: entry }); + changes[key] = entry; + + return; + } + + // this key was removed earlier, a match! + if (entry.c === 1) + { + inserts.push({ r: yIndex, A: entry }); + + entry.c = 2; + var subPatches = []; + _VirtualDom_diffHelp(entry.z, vnode, subPatches, entry.r); + entry.r = yIndex; + entry.s.s = { + w: subPatches, + A: entry + }; + + return; + } + + // this key has already been inserted or moved, a duplicate! + _VirtualDom_insertNode(changes, localPatches, key + _VirtualDom_POSTFIX, vnode, yIndex, inserts); +} + + +function _VirtualDom_removeNode(changes, localPatches, key, vnode, index) +{ + var entry = changes[key]; + + // never seen this key before + if (!entry) + { + var patch = _VirtualDom_pushPatch(localPatches, 9, index, undefined); + + changes[key] = { + c: 1, + z: vnode, + r: index, + s: patch + }; + + return; + } + + // this key was inserted earlier, a match! + if (entry.c === 0) + { + entry.c = 2; + var subPatches = []; + _VirtualDom_diffHelp(vnode, entry.z, subPatches, index); + + _VirtualDom_pushPatch(localPatches, 9, index, { + w: subPatches, + A: entry + }); + + return; + } + + // this key has already been removed or moved, a duplicate! + _VirtualDom_removeNode(changes, localPatches, key + _VirtualDom_POSTFIX, vnode, index); +} + + + +// ADD DOM NODES +// +// Each DOM node has an "index" assigned in order of traversal. It is important +// to minimize our crawl over the actual DOM, so these indexes (along with the +// descendantsCount of virtual nodes) let us skip touching entire subtrees of +// the DOM if we know there are no patches there. + + +function _VirtualDom_addDomNodes(domNode, vNode, patches, eventNode) +{ + _VirtualDom_addDomNodesHelp(domNode, vNode, patches, 0, 0, vNode.b, eventNode); +} + + +// assumes `patches` is non-empty and indexes increase monotonically. +function _VirtualDom_addDomNodesHelp(domNode, vNode, patches, i, low, high, eventNode) +{ + var patch = patches[i]; + var index = patch.r; + + while (index === low) + { + var patchType = patch.$; + + if (patchType === 1) + { + _VirtualDom_addDomNodes(domNode, vNode.k, patch.s, eventNode); + } + else if (patchType === 8) + { + patch.t = domNode; + patch.u = eventNode; + + var subPatches = patch.s.w; + if (subPatches.length > 0) + { + _VirtualDom_addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode); + } + } + else if (patchType === 9) + { + patch.t = domNode; + patch.u = eventNode; + + var data = patch.s; + if (data) + { + data.A.s = domNode; + var subPatches = data.w; + if (subPatches.length > 0) + { + _VirtualDom_addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode); + } + } + } + else + { + patch.t = domNode; + patch.u = eventNode; + } + + i++; + + if (!(patch = patches[i]) || (index = patch.r) > high) + { + return i; + } + } + + var tag = vNode.$; + + if (tag === 4) + { + var subNode = vNode.k; + + while (subNode.$ === 4) + { + subNode = subNode.k; + } + + return _VirtualDom_addDomNodesHelp(domNode, subNode, patches, i, low + 1, high, domNode.elm_event_node_ref); + } + + // tag must be 1 or 2 at this point + + var vKids = vNode.e; + var childNodes = domNode.childNodes; + for (var j = 0; j < vKids.length; j++) + { + low++; + var vKid = tag === 1 ? vKids[j] : vKids[j].b; + var nextLow = low + (vKid.b || 0); + if (low <= index && index <= nextLow) + { + i = _VirtualDom_addDomNodesHelp(childNodes[j], vKid, patches, i, low, nextLow, eventNode); + if (!(patch = patches[i]) || (index = patch.r) > high) + { + return i; + } + } + low = nextLow; + } + return i; +} + + + +// APPLY PATCHES + + +function _VirtualDom_applyPatches(rootDomNode, oldVirtualNode, patches, eventNode) +{ + if (patches.length === 0) + { + return rootDomNode; + } + + _VirtualDom_addDomNodes(rootDomNode, oldVirtualNode, patches, eventNode); + return _VirtualDom_applyPatchesHelp(rootDomNode, patches); +} + +function _VirtualDom_applyPatchesHelp(rootDomNode, patches) +{ + for (var i = 0; i < patches.length; i++) + { + var patch = patches[i]; + var localDomNode = patch.t + var newNode = _VirtualDom_applyPatch(localDomNode, patch); + if (localDomNode === rootDomNode) + { + rootDomNode = newNode; + } + } + return rootDomNode; +} + +function _VirtualDom_applyPatch(domNode, patch) +{ + switch (patch.$) + { + case 0: + return _VirtualDom_applyPatchRedraw(domNode, patch.s, patch.u); + + case 4: + _VirtualDom_applyFacts(domNode, patch.u, patch.s); + return domNode; + + case 3: + domNode.replaceData(0, domNode.length, patch.s); + return domNode; + + case 1: + return _VirtualDom_applyPatchesHelp(domNode, patch.s); + + case 2: + if (domNode.elm_event_node_ref) + { + domNode.elm_event_node_ref.j = patch.s; + } + else + { + domNode.elm_event_node_ref = { j: patch.s, p: patch.u }; + } + return domNode; + + case 6: + var data = patch.s; + for (var i = 0; i < data.i; i++) + { + domNode.removeChild(domNode.childNodes[data.v]); + } + return domNode; + + case 7: + var data = patch.s; + var kids = data.e; + var i = data.v; + var theEnd = domNode.childNodes[i]; + for (; i < kids.length; i++) + { + domNode.insertBefore(_VirtualDom_render(kids[i], patch.u), theEnd); + } + return domNode; + + case 9: + var data = patch.s; + if (!data) + { + domNode.parentNode.removeChild(domNode); + return domNode; + } + var entry = data.A; + if (typeof entry.r !== 'undefined') + { + domNode.parentNode.removeChild(domNode); + } + entry.s = _VirtualDom_applyPatchesHelp(domNode, data.w); + return domNode; + + case 8: + return _VirtualDom_applyPatchReorder(domNode, patch); + + case 5: + return patch.s(domNode); + + default: + _Debug_crash(10); // 'Ran into an unknown patch!' + } +} + + +function _VirtualDom_applyPatchRedraw(domNode, vNode, eventNode) +{ + var parentNode = domNode.parentNode; + var newNode = _VirtualDom_render(vNode, eventNode); + + if (!newNode.elm_event_node_ref) + { + newNode.elm_event_node_ref = domNode.elm_event_node_ref; + } + + if (parentNode && newNode !== domNode) + { + parentNode.replaceChild(newNode, domNode); + } + return newNode; +} + + +function _VirtualDom_applyPatchReorder(domNode, patch) +{ + var data = patch.s; + + // remove end inserts + var frag = _VirtualDom_applyPatchReorderEndInsertsHelp(data.y, patch); + + // removals + domNode = _VirtualDom_applyPatchesHelp(domNode, data.w); + + // inserts + var inserts = data.x; + for (var i = 0; i < inserts.length; i++) + { + var insert = inserts[i]; + var entry = insert.A; + var node = entry.c === 2 + ? entry.s + : _VirtualDom_render(entry.z, patch.u); + domNode.insertBefore(node, domNode.childNodes[insert.r]); + } + + // add end inserts + if (frag) + { + _VirtualDom_appendChild(domNode, frag); + } + + return domNode; +} + + +function _VirtualDom_applyPatchReorderEndInsertsHelp(endInserts, patch) +{ + if (!endInserts) + { + return; + } + + var frag = _VirtualDom_doc.createDocumentFragment(); + for (var i = 0; i < endInserts.length; i++) + { + var insert = endInserts[i]; + var entry = insert.A; + _VirtualDom_appendChild(frag, entry.c === 2 + ? entry.s + : _VirtualDom_render(entry.z, patch.u) + ); + } + return frag; +} + + +function _VirtualDom_virtualize(node) +{ + // TEXT NODES + + if (node.nodeType === 3) + { + return _VirtualDom_text(node.textContent); + } + + + // WEIRD NODES + + if (node.nodeType !== 1) + { + return _VirtualDom_text(''); + } + + + // ELEMENT NODES + + var attrList = _List_Nil; + var attrs = node.attributes; + for (var i = attrs.length; i--; ) + { + var attr = attrs[i]; + var name = attr.name; + var value = attr.value; + attrList = _List_Cons( A2(_VirtualDom_attribute, name, value), attrList ); + } + + var tag = node.tagName.toLowerCase(); + var kidList = _List_Nil; + var kids = node.childNodes; + + for (var i = kids.length; i--; ) + { + kidList = _List_Cons(_VirtualDom_virtualize(kids[i]), kidList); + } + return A3(_VirtualDom_node, tag, attrList, kidList); +} + +function _VirtualDom_dekey(keyedNode) +{ + var keyedKids = keyedNode.e; + var len = keyedKids.length; + var kids = new Array(len); + for (var i = 0; i < len; i++) + { + kids[i] = keyedKids[i].b; + } + + return { + $: 1, + c: keyedNode.c, + d: keyedNode.d, + e: kids, + f: keyedNode.f, + b: keyedNode.b + }; +} + + + + +// ELEMENT + + +var _Debugger_element; + +var _Browser_element = _Debugger_element || F4(function(impl, flagDecoder, debugMetadata, args) +{ + return _Platform_initialize( + flagDecoder, + args, + impl.init, + impl.update, + impl.subscriptions, + function(sendToApp, initialModel) { + var view = impl.view; + /**_UNUSED/ + var domNode = args['node']; + //*/ + /**/ + var domNode = args && args['node'] ? args['node'] : _Debug_crash(0); + //*/ + var currNode = _VirtualDom_virtualize(domNode); + + return _Browser_makeAnimator(initialModel, function(model) + { + var nextNode = view(model); + var patches = _VirtualDom_diff(currNode, nextNode); + domNode = _VirtualDom_applyPatches(domNode, currNode, patches, sendToApp); + currNode = nextNode; + }); + } + ); +}); + + + +// DOCUMENT + + +var _Debugger_document; + +var _Browser_document = _Debugger_document || F4(function(impl, flagDecoder, debugMetadata, args) +{ + return _Platform_initialize( + flagDecoder, + args, + impl.init, + impl.update, + impl.subscriptions, + function(sendToApp, initialModel) { + var divertHrefToApp = impl.setup && impl.setup(sendToApp) + var view = impl.view; + var title = _VirtualDom_doc.title; + var bodyNode = _VirtualDom_doc.body; + var currNode = _VirtualDom_virtualize(bodyNode); + return _Browser_makeAnimator(initialModel, function(model) + { + _VirtualDom_divertHrefToApp = divertHrefToApp; + var doc = view(model); + var nextNode = _VirtualDom_node('body')(_List_Nil)(doc.body); + var patches = _VirtualDom_diff(currNode, nextNode); + bodyNode = _VirtualDom_applyPatches(bodyNode, currNode, patches, sendToApp); + currNode = nextNode; + _VirtualDom_divertHrefToApp = 0; + (title !== doc.title) && (_VirtualDom_doc.title = title = doc.title); + }); + } + ); +}); + + + +// ANIMATION + + +var _Browser_cancelAnimationFrame = + typeof cancelAnimationFrame !== 'undefined' + ? cancelAnimationFrame + : function(id) { clearTimeout(id); }; + +var _Browser_requestAnimationFrame = + typeof requestAnimationFrame !== 'undefined' + ? requestAnimationFrame + : function(callback) { return setTimeout(callback, 1000 / 60); }; + + +function _Browser_makeAnimator(model, draw) +{ + draw(model); + + var state = 0; + + function updateIfNeeded() + { + state = state === 1 + ? 0 + : ( _Browser_requestAnimationFrame(updateIfNeeded), draw(model), 1 ); + } + + return function(nextModel, isSync) + { + model = nextModel; + + isSync + ? ( draw(model), + state === 2 && (state = 1) + ) + : ( state === 0 && _Browser_requestAnimationFrame(updateIfNeeded), + state = 2 + ); + }; +} + + + +// APPLICATION + + +function _Browser_application(impl) +{ + var onUrlChange = impl.onUrlChange; + var onUrlRequest = impl.onUrlRequest; + var key = function() { key.a(onUrlChange(_Browser_getUrl())); }; + + return _Browser_document({ + setup: function(sendToApp) + { + key.a = sendToApp; + _Browser_window.addEventListener('popstate', key); + _Browser_window.navigator.userAgent.indexOf('Trident') < 0 || _Browser_window.addEventListener('hashchange', key); + + return F2(function(domNode, event) + { + if (!event.ctrlKey && !event.metaKey && !event.shiftKey && event.button < 1 && !domNode.target && !domNode.hasAttribute('download')) + { + event.preventDefault(); + var href = domNode.href; + var curr = _Browser_getUrl(); + var next = $elm$url$Url$fromString(href).a; + sendToApp(onUrlRequest( + (next + && curr.protocol === next.protocol + && curr.host === next.host + && curr.port_.a === next.port_.a + ) + ? $elm$browser$Browser$Internal(next) + : $elm$browser$Browser$External(href) + )); + } + }); + }, + init: function(flags) + { + return A3(impl.init, flags, _Browser_getUrl(), key); + }, + view: impl.view, + update: impl.update, + subscriptions: impl.subscriptions + }); +} + +function _Browser_getUrl() +{ + return $elm$url$Url$fromString(_VirtualDom_doc.location.href).a || _Debug_crash(1); +} + +var _Browser_go = F2(function(key, n) +{ + return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function() { + n && history.go(n); + key(); + })); +}); + +var _Browser_pushUrl = F2(function(key, url) +{ + return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function() { + history.pushState({}, '', url); + key(); + })); +}); + +var _Browser_replaceUrl = F2(function(key, url) +{ + return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function() { + history.replaceState({}, '', url); + key(); + })); +}); + + + +// GLOBAL EVENTS + + +var _Browser_fakeNode = { addEventListener: function() {}, removeEventListener: function() {} }; +var _Browser_doc = typeof document !== 'undefined' ? document : _Browser_fakeNode; +var _Browser_window = typeof window !== 'undefined' ? window : _Browser_fakeNode; + +var _Browser_on = F3(function(node, eventName, sendToSelf) +{ + return _Scheduler_spawn(_Scheduler_binding(function(callback) + { + function handler(event) { _Scheduler_rawSpawn(sendToSelf(event)); } + node.addEventListener(eventName, handler, _VirtualDom_passiveSupported && { passive: true }); + return function() { node.removeEventListener(eventName, handler); }; + })); +}); + +var _Browser_decodeEvent = F2(function(decoder, event) +{ + var result = _Json_runHelp(decoder, event); + return $elm$core$Result$isOk(result) ? $elm$core$Maybe$Just(result.a) : $elm$core$Maybe$Nothing; +}); + + + +// PAGE VISIBILITY + + +function _Browser_visibilityInfo() +{ + return (typeof _VirtualDom_doc.hidden !== 'undefined') + ? { hidden: 'hidden', change: 'visibilitychange' } + : + (typeof _VirtualDom_doc.mozHidden !== 'undefined') + ? { hidden: 'mozHidden', change: 'mozvisibilitychange' } + : + (typeof _VirtualDom_doc.msHidden !== 'undefined') + ? { hidden: 'msHidden', change: 'msvisibilitychange' } + : + (typeof _VirtualDom_doc.webkitHidden !== 'undefined') + ? { hidden: 'webkitHidden', change: 'webkitvisibilitychange' } + : { hidden: 'hidden', change: 'visibilitychange' }; +} + + + +// ANIMATION FRAMES + + +function _Browser_rAF() +{ + return _Scheduler_binding(function(callback) + { + var id = _Browser_requestAnimationFrame(function() { + callback(_Scheduler_succeed(Date.now())); + }); + + return function() { + _Browser_cancelAnimationFrame(id); + }; + }); +} + + +function _Browser_now() +{ + return _Scheduler_binding(function(callback) + { + callback(_Scheduler_succeed(Date.now())); + }); +} + + + +// DOM STUFF + + +function _Browser_withNode(id, doStuff) +{ + return _Scheduler_binding(function(callback) + { + _Browser_requestAnimationFrame(function() { + var node = document.getElementById(id); + callback(node + ? _Scheduler_succeed(doStuff(node)) + : _Scheduler_fail($elm$browser$Browser$Dom$NotFound(id)) + ); + }); + }); +} + + +function _Browser_withWindow(doStuff) +{ + return _Scheduler_binding(function(callback) + { + _Browser_requestAnimationFrame(function() { + callback(_Scheduler_succeed(doStuff())); + }); + }); +} + + +// FOCUS and BLUR + + +var _Browser_call = F2(function(functionName, id) +{ + return _Browser_withNode(id, function(node) { + node[functionName](); + return _Utils_Tuple0; + }); +}); + + + +// WINDOW VIEWPORT + + +function _Browser_getViewport() +{ + return { + scene: _Browser_getScene(), + viewport: { + x: _Browser_window.pageXOffset, + y: _Browser_window.pageYOffset, + width: _Browser_doc.documentElement.clientWidth, + height: _Browser_doc.documentElement.clientHeight + } + }; +} + +function _Browser_getScene() +{ + var body = _Browser_doc.body; + var elem = _Browser_doc.documentElement; + return { + width: Math.max(body.scrollWidth, body.offsetWidth, elem.scrollWidth, elem.offsetWidth, elem.clientWidth), + height: Math.max(body.scrollHeight, body.offsetHeight, elem.scrollHeight, elem.offsetHeight, elem.clientHeight) + }; +} + +var _Browser_setViewport = F2(function(x, y) +{ + return _Browser_withWindow(function() + { + _Browser_window.scroll(x, y); + return _Utils_Tuple0; + }); +}); + + + +// ELEMENT VIEWPORT + + +function _Browser_getViewportOf(id) +{ + return _Browser_withNode(id, function(node) + { + return { + scene: { + width: node.scrollWidth, + height: node.scrollHeight + }, + viewport: { + x: node.scrollLeft, + y: node.scrollTop, + width: node.clientWidth, + height: node.clientHeight + } + }; + }); +} + + +var _Browser_setViewportOf = F3(function(id, x, y) +{ + return _Browser_withNode(id, function(node) + { + node.scrollLeft = x; + node.scrollTop = y; + return _Utils_Tuple0; + }); +}); + + + +// ELEMENT + + +function _Browser_getElement(id) +{ + return _Browser_withNode(id, function(node) + { + var rect = node.getBoundingClientRect(); + var x = _Browser_window.pageXOffset; + var y = _Browser_window.pageYOffset; + return { + scene: _Browser_getScene(), + viewport: { + x: x, + y: y, + width: _Browser_doc.documentElement.clientWidth, + height: _Browser_doc.documentElement.clientHeight + }, + element: { + x: x + rect.left, + y: y + rect.top, + width: rect.width, + height: rect.height + } + }; + }); +} + + + +// LOAD and RELOAD + + +function _Browser_reload(skipCache) +{ + return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function(callback) + { + _VirtualDom_doc.location.reload(skipCache); + })); +} + +function _Browser_load(url) +{ + return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function(callback) + { + try + { + _Browser_window.location = url; + } + catch(err) + { + // Only Firefox can throw a NS_ERROR_MALFORMED_URI exception here. + // Other browsers reload the page, so let's be consistent about that. + _VirtualDom_doc.location.reload(false); + } + })); +} + + + +// SEND REQUEST + +var _Http_toTask = F3(function(router, toTask, request) +{ + return _Scheduler_binding(function(callback) + { + function done(response) { + callback(toTask(request.expect.a(response))); + } + + var xhr = new XMLHttpRequest(); + xhr.addEventListener('error', function() { done($elm$http$Http$NetworkError_); }); + xhr.addEventListener('timeout', function() { done($elm$http$Http$Timeout_); }); + xhr.addEventListener('load', function() { done(_Http_toResponse(request.expect.b, xhr)); }); + $elm$core$Maybe$isJust(request.tracker) && _Http_track(router, xhr, request.tracker.a); + + try { + xhr.open(request.method, request.url, true); + } catch (e) { + return done($elm$http$Http$BadUrl_(request.url)); + } + + _Http_configureRequest(xhr, request); + + request.body.a && xhr.setRequestHeader('Content-Type', request.body.a); + xhr.send(request.body.b); + + return function() { xhr.c = true; xhr.abort(); }; + }); +}); + + +// CONFIGURE + +function _Http_configureRequest(xhr, request) +{ + for (var headers = request.headers; headers.b; headers = headers.b) // WHILE_CONS + { + xhr.setRequestHeader(headers.a.a, headers.a.b); + } + xhr.timeout = request.timeout.a || 0; + xhr.responseType = request.expect.d; + xhr.withCredentials = request.allowCookiesFromOtherDomains; +} + + +// RESPONSES + +function _Http_toResponse(toBody, xhr) +{ + return A2( + 200 <= xhr.status && xhr.status < 300 ? $elm$http$Http$GoodStatus_ : $elm$http$Http$BadStatus_, + _Http_toMetadata(xhr), + toBody(xhr.response) + ); +} + + +// METADATA + +function _Http_toMetadata(xhr) +{ + return { + url: xhr.responseURL, + statusCode: xhr.status, + statusText: xhr.statusText, + headers: _Http_parseHeaders(xhr.getAllResponseHeaders()) + }; +} + + +// HEADERS + +function _Http_parseHeaders(rawHeaders) +{ + if (!rawHeaders) + { + return $elm$core$Dict$empty; + } + + var headers = $elm$core$Dict$empty; + var headerPairs = rawHeaders.split('\r\n'); + for (var i = headerPairs.length; i--; ) + { + var headerPair = headerPairs[i]; + var index = headerPair.indexOf(': '); + if (index > 0) + { + var key = headerPair.substring(0, index); + var value = headerPair.substring(index + 2); + + headers = A3($elm$core$Dict$update, key, function(oldValue) { + return $elm$core$Maybe$Just($elm$core$Maybe$isJust(oldValue) + ? value + ', ' + oldValue.a + : value + ); + }, headers); + } + } + return headers; +} + + +// EXPECT + +var _Http_expect = F3(function(type, toBody, toValue) +{ + return { + $: 0, + d: type, + b: toBody, + a: toValue + }; +}); + +var _Http_mapExpect = F2(function(func, expect) +{ + return { + $: 0, + d: expect.d, + b: expect.b, + a: function(x) { return func(expect.a(x)); } + }; +}); + +function _Http_toDataView(arrayBuffer) +{ + return new DataView(arrayBuffer); +} + + +// BODY and PARTS + +var _Http_emptyBody = { $: 0 }; +var _Http_pair = F2(function(a, b) { return { $: 0, a: a, b: b }; }); + +function _Http_toFormData(parts) +{ + for (var formData = new FormData(); parts.b; parts = parts.b) // WHILE_CONS + { + var part = parts.a; + formData.append(part.a, part.b); + } + return formData; +} + +var _Http_bytesToBlob = F2(function(mime, bytes) +{ + return new Blob([bytes], { type: mime }); +}); + + +// PROGRESS + +function _Http_track(router, xhr, tracker) +{ + // TODO check out lengthComputable on loadstart event + + xhr.upload.addEventListener('progress', function(event) { + if (xhr.c) { return; } + _Scheduler_rawSpawn(A2($elm$core$Platform$sendToSelf, router, _Utils_Tuple2(tracker, $elm$http$Http$Sending({ + sent: event.loaded, + size: event.total + })))); + }); + xhr.addEventListener('progress', function(event) { + if (xhr.c) { return; } + _Scheduler_rawSpawn(A2($elm$core$Platform$sendToSelf, router, _Utils_Tuple2(tracker, $elm$http$Http$Receiving({ + received: event.loaded, + size: event.lengthComputable ? $elm$core$Maybe$Just(event.total) : $elm$core$Maybe$Nothing + })))); + }); +} + + +var _Bitwise_and = F2(function(a, b) +{ + return a & b; +}); + +var _Bitwise_or = F2(function(a, b) +{ + return a | b; +}); + +var _Bitwise_xor = F2(function(a, b) +{ + return a ^ b; +}); + +function _Bitwise_complement(a) +{ + return ~a; +}; + +var _Bitwise_shiftLeftBy = F2(function(offset, a) +{ + return a << offset; +}); + +var _Bitwise_shiftRightBy = F2(function(offset, a) +{ + return a >> offset; +}); + +var _Bitwise_shiftRightZfBy = F2(function(offset, a) +{ + return a >>> offset; +}); +var $elm$core$Basics$EQ = {$: 'EQ'}; +var $elm$core$Basics$GT = {$: 'GT'}; +var $elm$core$Basics$LT = {$: 'LT'}; +var $elm$core$List$cons = _List_cons; +var $elm$core$Dict$foldr = F3( + function (func, acc, t) { + foldr: + while (true) { + if (t.$ === 'RBEmpty_elm_builtin') { + return acc; + } else { + var key = t.b; + var value = t.c; + var left = t.d; + var right = t.e; + var $temp$func = func, + $temp$acc = A3( + func, + key, + value, + A3($elm$core$Dict$foldr, func, acc, right)), + $temp$t = left; + func = $temp$func; + acc = $temp$acc; + t = $temp$t; + continue foldr; + } + } + }); +var $elm$core$Dict$toList = function (dict) { + return A3( + $elm$core$Dict$foldr, + F3( + function (key, value, list) { + return A2( + $elm$core$List$cons, + _Utils_Tuple2(key, value), + list); + }), + _List_Nil, + dict); +}; +var $elm$core$Dict$keys = function (dict) { + return A3( + $elm$core$Dict$foldr, + F3( + function (key, value, keyList) { + return A2($elm$core$List$cons, key, keyList); + }), + _List_Nil, + dict); +}; +var $elm$core$Set$toList = function (_v0) { + var dict = _v0.a; + return $elm$core$Dict$keys(dict); +}; +var $elm$core$Elm$JsArray$foldr = _JsArray_foldr; +var $elm$core$Array$foldr = F3( + function (func, baseCase, _v0) { + var tree = _v0.c; + var tail = _v0.d; + var helper = F2( + function (node, acc) { + if (node.$ === 'SubTree') { + var subTree = node.a; + return A3($elm$core$Elm$JsArray$foldr, helper, acc, subTree); + } else { + var values = node.a; + return A3($elm$core$Elm$JsArray$foldr, func, acc, values); + } + }); + return A3( + $elm$core$Elm$JsArray$foldr, + helper, + A3($elm$core$Elm$JsArray$foldr, func, baseCase, tail), + tree); + }); +var $elm$core$Array$toList = function (array) { + return A3($elm$core$Array$foldr, $elm$core$List$cons, _List_Nil, array); +}; +var $elm$core$Result$Err = function (a) { + return {$: 'Err', a: a}; +}; +var $elm$json$Json$Decode$Failure = F2( + function (a, b) { + return {$: 'Failure', a: a, b: b}; + }); +var $elm$json$Json$Decode$Field = F2( + function (a, b) { + return {$: 'Field', a: a, b: b}; + }); +var $elm$json$Json$Decode$Index = F2( + function (a, b) { + return {$: 'Index', a: a, b: b}; + }); +var $elm$core$Result$Ok = function (a) { + return {$: 'Ok', a: a}; +}; +var $elm$json$Json$Decode$OneOf = function (a) { + return {$: 'OneOf', a: a}; +}; +var $elm$core$Basics$False = {$: 'False'}; +var $elm$core$Basics$add = _Basics_add; +var $elm$core$Maybe$Just = function (a) { + return {$: 'Just', a: a}; +}; +var $elm$core$Maybe$Nothing = {$: 'Nothing'}; +var $elm$core$String$all = _String_all; +var $elm$core$Basics$and = _Basics_and; +var $elm$core$Basics$append = _Utils_append; +var $elm$json$Json$Encode$encode = _Json_encode; +var $elm$core$String$fromInt = _String_fromNumber; +var $elm$core$String$join = F2( + function (sep, chunks) { + return A2( + _String_join, + sep, + _List_toArray(chunks)); + }); +var $elm$core$String$split = F2( + function (sep, string) { + return _List_fromArray( + A2(_String_split, sep, string)); + }); +var $elm$json$Json$Decode$indent = function (str) { + return A2( + $elm$core$String$join, + '\n ', + A2($elm$core$String$split, '\n', str)); +}; +var $elm$core$List$foldl = F3( + function (func, acc, list) { + foldl: + while (true) { + if (!list.b) { + return acc; + } else { + var x = list.a; + var xs = list.b; + var $temp$func = func, + $temp$acc = A2(func, x, acc), + $temp$list = xs; + func = $temp$func; + acc = $temp$acc; + list = $temp$list; + continue foldl; + } + } + }); +var $elm$core$List$length = function (xs) { + return A3( + $elm$core$List$foldl, + F2( + function (_v0, i) { + return i + 1; + }), + 0, + xs); +}; +var $elm$core$List$map2 = _List_map2; +var $elm$core$Basics$le = _Utils_le; +var $elm$core$Basics$sub = _Basics_sub; +var $elm$core$List$rangeHelp = F3( + function (lo, hi, list) { + rangeHelp: + while (true) { + if (_Utils_cmp(lo, hi) < 1) { + var $temp$lo = lo, + $temp$hi = hi - 1, + $temp$list = A2($elm$core$List$cons, hi, list); + lo = $temp$lo; + hi = $temp$hi; + list = $temp$list; + continue rangeHelp; + } else { + return list; + } + } + }); +var $elm$core$List$range = F2( + function (lo, hi) { + return A3($elm$core$List$rangeHelp, lo, hi, _List_Nil); + }); +var $elm$core$List$indexedMap = F2( + function (f, xs) { + return A3( + $elm$core$List$map2, + f, + A2( + $elm$core$List$range, + 0, + $elm$core$List$length(xs) - 1), + xs); + }); +var $elm$core$Char$toCode = _Char_toCode; +var $elm$core$Char$isLower = function (_char) { + var code = $elm$core$Char$toCode(_char); + return (97 <= code) && (code <= 122); +}; +var $elm$core$Char$isUpper = function (_char) { + var code = $elm$core$Char$toCode(_char); + return (code <= 90) && (65 <= code); +}; +var $elm$core$Basics$or = _Basics_or; +var $elm$core$Char$isAlpha = function (_char) { + return $elm$core$Char$isLower(_char) || $elm$core$Char$isUpper(_char); +}; +var $elm$core$Char$isDigit = function (_char) { + var code = $elm$core$Char$toCode(_char); + return (code <= 57) && (48 <= code); +}; +var $elm$core$Char$isAlphaNum = function (_char) { + return $elm$core$Char$isLower(_char) || ($elm$core$Char$isUpper(_char) || $elm$core$Char$isDigit(_char)); +}; +var $elm$core$List$reverse = function (list) { + return A3($elm$core$List$foldl, $elm$core$List$cons, _List_Nil, list); +}; +var $elm$core$String$uncons = _String_uncons; +var $elm$json$Json$Decode$errorOneOf = F2( + function (i, error) { + return '\n\n(' + ($elm$core$String$fromInt(i + 1) + (') ' + $elm$json$Json$Decode$indent( + $elm$json$Json$Decode$errorToString(error)))); + }); +var $elm$json$Json$Decode$errorToString = function (error) { + return A2($elm$json$Json$Decode$errorToStringHelp, error, _List_Nil); +}; +var $elm$json$Json$Decode$errorToStringHelp = F2( + function (error, context) { + errorToStringHelp: + while (true) { + switch (error.$) { + case 'Field': + var f = error.a; + var err = error.b; + var isSimple = function () { + var _v1 = $elm$core$String$uncons(f); + if (_v1.$ === 'Nothing') { + return false; + } else { + var _v2 = _v1.a; + var _char = _v2.a; + var rest = _v2.b; + return $elm$core$Char$isAlpha(_char) && A2($elm$core$String$all, $elm$core$Char$isAlphaNum, rest); + } + }(); + var fieldName = isSimple ? ('.' + f) : ('[\'' + (f + '\']')); + var $temp$error = err, + $temp$context = A2($elm$core$List$cons, fieldName, context); + error = $temp$error; + context = $temp$context; + continue errorToStringHelp; + case 'Index': + var i = error.a; + var err = error.b; + var indexName = '[' + ($elm$core$String$fromInt(i) + ']'); + var $temp$error = err, + $temp$context = A2($elm$core$List$cons, indexName, context); + error = $temp$error; + context = $temp$context; + continue errorToStringHelp; + case 'OneOf': + var errors = error.a; + if (!errors.b) { + return 'Ran into a Json.Decode.oneOf with no possibilities' + function () { + if (!context.b) { + return '!'; + } else { + return ' at json' + A2( + $elm$core$String$join, + '', + $elm$core$List$reverse(context)); + } + }(); + } else { + if (!errors.b.b) { + var err = errors.a; + var $temp$error = err, + $temp$context = context; + error = $temp$error; + context = $temp$context; + continue errorToStringHelp; + } else { + var starter = function () { + if (!context.b) { + return 'Json.Decode.oneOf'; + } else { + return 'The Json.Decode.oneOf at json' + A2( + $elm$core$String$join, + '', + $elm$core$List$reverse(context)); + } + }(); + var introduction = starter + (' failed in the following ' + ($elm$core$String$fromInt( + $elm$core$List$length(errors)) + ' ways:')); + return A2( + $elm$core$String$join, + '\n\n', + A2( + $elm$core$List$cons, + introduction, + A2($elm$core$List$indexedMap, $elm$json$Json$Decode$errorOneOf, errors))); + } + } + default: + var msg = error.a; + var json = error.b; + var introduction = function () { + if (!context.b) { + return 'Problem with the given value:\n\n'; + } else { + return 'Problem with the value at json' + (A2( + $elm$core$String$join, + '', + $elm$core$List$reverse(context)) + ':\n\n '); + } + }(); + return introduction + ($elm$json$Json$Decode$indent( + A2($elm$json$Json$Encode$encode, 4, json)) + ('\n\n' + msg)); + } + } + }); +var $elm$core$Array$branchFactor = 32; +var $elm$core$Array$Array_elm_builtin = F4( + function (a, b, c, d) { + return {$: 'Array_elm_builtin', a: a, b: b, c: c, d: d}; + }); +var $elm$core$Elm$JsArray$empty = _JsArray_empty; +var $elm$core$Basics$ceiling = _Basics_ceiling; +var $elm$core$Basics$fdiv = _Basics_fdiv; +var $elm$core$Basics$logBase = F2( + function (base, number) { + return _Basics_log(number) / _Basics_log(base); + }); +var $elm$core$Basics$toFloat = _Basics_toFloat; +var $elm$core$Array$shiftStep = $elm$core$Basics$ceiling( + A2($elm$core$Basics$logBase, 2, $elm$core$Array$branchFactor)); +var $elm$core$Array$empty = A4($elm$core$Array$Array_elm_builtin, 0, $elm$core$Array$shiftStep, $elm$core$Elm$JsArray$empty, $elm$core$Elm$JsArray$empty); +var $elm$core$Elm$JsArray$initialize = _JsArray_initialize; +var $elm$core$Array$Leaf = function (a) { + return {$: 'Leaf', a: a}; +}; +var $elm$core$Basics$apL = F2( + function (f, x) { + return f(x); + }); +var $elm$core$Basics$apR = F2( + function (x, f) { + return f(x); + }); +var $elm$core$Basics$eq = _Utils_equal; +var $elm$core$Basics$floor = _Basics_floor; +var $elm$core$Elm$JsArray$length = _JsArray_length; +var $elm$core$Basics$gt = _Utils_gt; +var $elm$core$Basics$max = F2( + function (x, y) { + return (_Utils_cmp(x, y) > 0) ? x : y; + }); +var $elm$core$Basics$mul = _Basics_mul; +var $elm$core$Array$SubTree = function (a) { + return {$: 'SubTree', a: a}; +}; +var $elm$core$Elm$JsArray$initializeFromList = _JsArray_initializeFromList; +var $elm$core$Array$compressNodes = F2( + function (nodes, acc) { + compressNodes: + while (true) { + var _v0 = A2($elm$core$Elm$JsArray$initializeFromList, $elm$core$Array$branchFactor, nodes); + var node = _v0.a; + var remainingNodes = _v0.b; + var newAcc = A2( + $elm$core$List$cons, + $elm$core$Array$SubTree(node), + acc); + if (!remainingNodes.b) { + return $elm$core$List$reverse(newAcc); + } else { + var $temp$nodes = remainingNodes, + $temp$acc = newAcc; + nodes = $temp$nodes; + acc = $temp$acc; + continue compressNodes; + } + } + }); +var $elm$core$Tuple$first = function (_v0) { + var x = _v0.a; + return x; +}; +var $elm$core$Array$treeFromBuilder = F2( + function (nodeList, nodeListSize) { + treeFromBuilder: + while (true) { + var newNodeSize = $elm$core$Basics$ceiling(nodeListSize / $elm$core$Array$branchFactor); + if (newNodeSize === 1) { + return A2($elm$core$Elm$JsArray$initializeFromList, $elm$core$Array$branchFactor, nodeList).a; + } else { + var $temp$nodeList = A2($elm$core$Array$compressNodes, nodeList, _List_Nil), + $temp$nodeListSize = newNodeSize; + nodeList = $temp$nodeList; + nodeListSize = $temp$nodeListSize; + continue treeFromBuilder; + } + } + }); +var $elm$core$Array$builderToArray = F2( + function (reverseNodeList, builder) { + if (!builder.nodeListSize) { + return A4( + $elm$core$Array$Array_elm_builtin, + $elm$core$Elm$JsArray$length(builder.tail), + $elm$core$Array$shiftStep, + $elm$core$Elm$JsArray$empty, + builder.tail); + } else { + var treeLen = builder.nodeListSize * $elm$core$Array$branchFactor; + var depth = $elm$core$Basics$floor( + A2($elm$core$Basics$logBase, $elm$core$Array$branchFactor, treeLen - 1)); + var correctNodeList = reverseNodeList ? $elm$core$List$reverse(builder.nodeList) : builder.nodeList; + var tree = A2($elm$core$Array$treeFromBuilder, correctNodeList, builder.nodeListSize); + return A4( + $elm$core$Array$Array_elm_builtin, + $elm$core$Elm$JsArray$length(builder.tail) + treeLen, + A2($elm$core$Basics$max, 5, depth * $elm$core$Array$shiftStep), + tree, + builder.tail); + } + }); +var $elm$core$Basics$idiv = _Basics_idiv; +var $elm$core$Basics$lt = _Utils_lt; +var $elm$core$Array$initializeHelp = F5( + function (fn, fromIndex, len, nodeList, tail) { + initializeHelp: + while (true) { + if (fromIndex < 0) { + return A2( + $elm$core$Array$builderToArray, + false, + {nodeList: nodeList, nodeListSize: (len / $elm$core$Array$branchFactor) | 0, tail: tail}); + } else { + var leaf = $elm$core$Array$Leaf( + A3($elm$core$Elm$JsArray$initialize, $elm$core$Array$branchFactor, fromIndex, fn)); + var $temp$fn = fn, + $temp$fromIndex = fromIndex - $elm$core$Array$branchFactor, + $temp$len = len, + $temp$nodeList = A2($elm$core$List$cons, leaf, nodeList), + $temp$tail = tail; + fn = $temp$fn; + fromIndex = $temp$fromIndex; + len = $temp$len; + nodeList = $temp$nodeList; + tail = $temp$tail; + continue initializeHelp; + } + } + }); +var $elm$core$Basics$remainderBy = _Basics_remainderBy; +var $elm$core$Array$initialize = F2( + function (len, fn) { + if (len <= 0) { + return $elm$core$Array$empty; + } else { + var tailLen = len % $elm$core$Array$branchFactor; + var tail = A3($elm$core$Elm$JsArray$initialize, tailLen, len - tailLen, fn); + var initialFromIndex = (len - tailLen) - $elm$core$Array$branchFactor; + return A5($elm$core$Array$initializeHelp, fn, initialFromIndex, len, _List_Nil, tail); + } + }); +var $elm$core$Basics$True = {$: 'True'}; +var $elm$core$Result$isOk = function (result) { + if (result.$ === 'Ok') { + return true; + } else { + return false; + } +}; +var $elm$json$Json$Decode$map = _Json_map1; +var $elm$json$Json$Decode$map2 = _Json_map2; +var $elm$json$Json$Decode$succeed = _Json_succeed; +var $elm$virtual_dom$VirtualDom$toHandlerInt = function (handler) { + switch (handler.$) { + case 'Normal': + return 0; + case 'MayStopPropagation': + return 1; + case 'MayPreventDefault': + return 2; + default: + return 3; + } +}; +var $elm$browser$Browser$External = function (a) { + return {$: 'External', a: a}; +}; +var $elm$browser$Browser$Internal = function (a) { + return {$: 'Internal', a: a}; +}; +var $elm$core$Basics$identity = function (x) { + return x; +}; +var $elm$browser$Browser$Dom$NotFound = function (a) { + return {$: 'NotFound', a: a}; +}; +var $elm$url$Url$Http = {$: 'Http'}; +var $elm$url$Url$Https = {$: 'Https'}; +var $elm$url$Url$Url = F6( + function (protocol, host, port_, path, query, fragment) { + return {fragment: fragment, host: host, path: path, port_: port_, protocol: protocol, query: query}; + }); +var $elm$core$String$contains = _String_contains; +var $elm$core$String$length = _String_length; +var $elm$core$String$slice = _String_slice; +var $elm$core$String$dropLeft = F2( + function (n, string) { + return (n < 1) ? string : A3( + $elm$core$String$slice, + n, + $elm$core$String$length(string), + string); + }); +var $elm$core$String$indexes = _String_indexes; +var $elm$core$String$isEmpty = function (string) { + return string === ''; +}; +var $elm$core$String$left = F2( + function (n, string) { + return (n < 1) ? '' : A3($elm$core$String$slice, 0, n, string); + }); +var $elm$core$String$toInt = _String_toInt; +var $elm$url$Url$chompBeforePath = F5( + function (protocol, path, params, frag, str) { + if ($elm$core$String$isEmpty(str) || A2($elm$core$String$contains, '@', str)) { + return $elm$core$Maybe$Nothing; + } else { + var _v0 = A2($elm$core$String$indexes, ':', str); + if (!_v0.b) { + return $elm$core$Maybe$Just( + A6($elm$url$Url$Url, protocol, str, $elm$core$Maybe$Nothing, path, params, frag)); + } else { + if (!_v0.b.b) { + var i = _v0.a; + var _v1 = $elm$core$String$toInt( + A2($elm$core$String$dropLeft, i + 1, str)); + if (_v1.$ === 'Nothing') { + return $elm$core$Maybe$Nothing; + } else { + var port_ = _v1; + return $elm$core$Maybe$Just( + A6( + $elm$url$Url$Url, + protocol, + A2($elm$core$String$left, i, str), + port_, + path, + params, + frag)); + } + } else { + return $elm$core$Maybe$Nothing; + } + } + } + }); +var $elm$url$Url$chompBeforeQuery = F4( + function (protocol, params, frag, str) { + if ($elm$core$String$isEmpty(str)) { + return $elm$core$Maybe$Nothing; + } else { + var _v0 = A2($elm$core$String$indexes, '/', str); + if (!_v0.b) { + return A5($elm$url$Url$chompBeforePath, protocol, '/', params, frag, str); + } else { + var i = _v0.a; + return A5( + $elm$url$Url$chompBeforePath, + protocol, + A2($elm$core$String$dropLeft, i, str), + params, + frag, + A2($elm$core$String$left, i, str)); + } + } + }); +var $elm$url$Url$chompBeforeFragment = F3( + function (protocol, frag, str) { + if ($elm$core$String$isEmpty(str)) { + return $elm$core$Maybe$Nothing; + } else { + var _v0 = A2($elm$core$String$indexes, '?', str); + if (!_v0.b) { + return A4($elm$url$Url$chompBeforeQuery, protocol, $elm$core$Maybe$Nothing, frag, str); + } else { + var i = _v0.a; + return A4( + $elm$url$Url$chompBeforeQuery, + protocol, + $elm$core$Maybe$Just( + A2($elm$core$String$dropLeft, i + 1, str)), + frag, + A2($elm$core$String$left, i, str)); + } + } + }); +var $elm$url$Url$chompAfterProtocol = F2( + function (protocol, str) { + if ($elm$core$String$isEmpty(str)) { + return $elm$core$Maybe$Nothing; + } else { + var _v0 = A2($elm$core$String$indexes, '#', str); + if (!_v0.b) { + return A3($elm$url$Url$chompBeforeFragment, protocol, $elm$core$Maybe$Nothing, str); + } else { + var i = _v0.a; + return A3( + $elm$url$Url$chompBeforeFragment, + protocol, + $elm$core$Maybe$Just( + A2($elm$core$String$dropLeft, i + 1, str)), + A2($elm$core$String$left, i, str)); + } + } + }); +var $elm$core$String$startsWith = _String_startsWith; +var $elm$url$Url$fromString = function (str) { + return A2($elm$core$String$startsWith, 'http://', str) ? A2( + $elm$url$Url$chompAfterProtocol, + $elm$url$Url$Http, + A2($elm$core$String$dropLeft, 7, str)) : (A2($elm$core$String$startsWith, 'https://', str) ? A2( + $elm$url$Url$chompAfterProtocol, + $elm$url$Url$Https, + A2($elm$core$String$dropLeft, 8, str)) : $elm$core$Maybe$Nothing); +}; +var $elm$core$Basics$never = function (_v0) { + never: + while (true) { + var nvr = _v0.a; + var $temp$_v0 = nvr; + _v0 = $temp$_v0; + continue never; + } +}; +var $elm$core$Task$Perform = function (a) { + return {$: 'Perform', a: a}; +}; +var $elm$core$Task$succeed = _Scheduler_succeed; +var $elm$core$Task$init = $elm$core$Task$succeed(_Utils_Tuple0); +var $elm$core$List$foldrHelper = F4( + function (fn, acc, ctr, ls) { + if (!ls.b) { + return acc; + } else { + var a = ls.a; + var r1 = ls.b; + if (!r1.b) { + return A2(fn, a, acc); + } else { + var b = r1.a; + var r2 = r1.b; + if (!r2.b) { + return A2( + fn, + a, + A2(fn, b, acc)); + } else { + var c = r2.a; + var r3 = r2.b; + if (!r3.b) { + return A2( + fn, + a, + A2( + fn, + b, + A2(fn, c, acc))); + } else { + var d = r3.a; + var r4 = r3.b; + var res = (ctr > 500) ? A3( + $elm$core$List$foldl, + fn, + acc, + $elm$core$List$reverse(r4)) : A4($elm$core$List$foldrHelper, fn, acc, ctr + 1, r4); + return A2( + fn, + a, + A2( + fn, + b, + A2( + fn, + c, + A2(fn, d, res)))); + } + } + } + } + }); +var $elm$core$List$foldr = F3( + function (fn, acc, ls) { + return A4($elm$core$List$foldrHelper, fn, acc, 0, ls); + }); +var $elm$core$List$map = F2( + function (f, xs) { + return A3( + $elm$core$List$foldr, + F2( + function (x, acc) { + return A2( + $elm$core$List$cons, + f(x), + acc); + }), + _List_Nil, + xs); + }); +var $elm$core$Task$andThen = _Scheduler_andThen; +var $elm$core$Task$map = F2( + function (func, taskA) { + return A2( + $elm$core$Task$andThen, + function (a) { + return $elm$core$Task$succeed( + func(a)); + }, + taskA); + }); +var $elm$core$Task$map2 = F3( + function (func, taskA, taskB) { + return A2( + $elm$core$Task$andThen, + function (a) { + return A2( + $elm$core$Task$andThen, + function (b) { + return $elm$core$Task$succeed( + A2(func, a, b)); + }, + taskB); + }, + taskA); + }); +var $elm$core$Task$sequence = function (tasks) { + return A3( + $elm$core$List$foldr, + $elm$core$Task$map2($elm$core$List$cons), + $elm$core$Task$succeed(_List_Nil), + tasks); +}; +var $elm$core$Platform$sendToApp = _Platform_sendToApp; +var $elm$core$Task$spawnCmd = F2( + function (router, _v0) { + var task = _v0.a; + return _Scheduler_spawn( + A2( + $elm$core$Task$andThen, + $elm$core$Platform$sendToApp(router), + task)); + }); +var $elm$core$Task$onEffects = F3( + function (router, commands, state) { + return A2( + $elm$core$Task$map, + function (_v0) { + return _Utils_Tuple0; + }, + $elm$core$Task$sequence( + A2( + $elm$core$List$map, + $elm$core$Task$spawnCmd(router), + commands))); + }); +var $elm$core$Task$onSelfMsg = F3( + function (_v0, _v1, _v2) { + return $elm$core$Task$succeed(_Utils_Tuple0); + }); +var $elm$core$Task$cmdMap = F2( + function (tagger, _v0) { + var task = _v0.a; + return $elm$core$Task$Perform( + A2($elm$core$Task$map, tagger, task)); + }); +_Platform_effectManagers['Task'] = _Platform_createManager($elm$core$Task$init, $elm$core$Task$onEffects, $elm$core$Task$onSelfMsg, $elm$core$Task$cmdMap); +var $elm$core$Task$command = _Platform_leaf('Task'); +var $elm$core$Task$perform = F2( + function (toMessage, task) { + return $elm$core$Task$command( + $elm$core$Task$Perform( + A2($elm$core$Task$map, toMessage, task))); + }); +var $elm$browser$Browser$element = _Browser_element; +var $author$project$Main$FetchDataHandler = function (a) { + return {$: 'FetchDataHandler', a: a}; +}; +var $elm$json$Json$Decode$decodeString = _Json_runOnString; +var $elm$http$Http$BadStatus_ = F2( + function (a, b) { + return {$: 'BadStatus_', a: a, b: b}; + }); +var $elm$http$Http$BadUrl_ = function (a) { + return {$: 'BadUrl_', a: a}; +}; +var $elm$http$Http$GoodStatus_ = F2( + function (a, b) { + return {$: 'GoodStatus_', a: a, b: b}; + }); +var $elm$http$Http$NetworkError_ = {$: 'NetworkError_'}; +var $elm$http$Http$Receiving = function (a) { + return {$: 'Receiving', a: a}; +}; +var $elm$http$Http$Sending = function (a) { + return {$: 'Sending', a: a}; +}; +var $elm$http$Http$Timeout_ = {$: 'Timeout_'}; +var $elm$core$Dict$RBEmpty_elm_builtin = {$: 'RBEmpty_elm_builtin'}; +var $elm$core$Dict$empty = $elm$core$Dict$RBEmpty_elm_builtin; +var $elm$core$Maybe$isJust = function (maybe) { + if (maybe.$ === 'Just') { + return true; + } else { + return false; + } +}; +var $elm$core$Platform$sendToSelf = _Platform_sendToSelf; +var $elm$core$Basics$compare = _Utils_compare; +var $elm$core$Dict$get = F2( + function (targetKey, dict) { + get: + while (true) { + if (dict.$ === 'RBEmpty_elm_builtin') { + return $elm$core$Maybe$Nothing; + } else { + var key = dict.b; + var value = dict.c; + var left = dict.d; + var right = dict.e; + var _v1 = A2($elm$core$Basics$compare, targetKey, key); + switch (_v1.$) { + case 'LT': + var $temp$targetKey = targetKey, + $temp$dict = left; + targetKey = $temp$targetKey; + dict = $temp$dict; + continue get; + case 'EQ': + return $elm$core$Maybe$Just(value); + default: + var $temp$targetKey = targetKey, + $temp$dict = right; + targetKey = $temp$targetKey; + dict = $temp$dict; + continue get; + } + } + } + }); +var $elm$core$Dict$Black = {$: 'Black'}; +var $elm$core$Dict$RBNode_elm_builtin = F5( + function (a, b, c, d, e) { + return {$: 'RBNode_elm_builtin', a: a, b: b, c: c, d: d, e: e}; + }); +var $elm$core$Dict$Red = {$: 'Red'}; +var $elm$core$Dict$balance = F5( + function (color, key, value, left, right) { + if ((right.$ === 'RBNode_elm_builtin') && (right.a.$ === 'Red')) { + var _v1 = right.a; + var rK = right.b; + var rV = right.c; + var rLeft = right.d; + var rRight = right.e; + if ((left.$ === 'RBNode_elm_builtin') && (left.a.$ === 'Red')) { + var _v3 = left.a; + var lK = left.b; + var lV = left.c; + var lLeft = left.d; + var lRight = left.e; + return A5( + $elm$core$Dict$RBNode_elm_builtin, + $elm$core$Dict$Red, + key, + value, + A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, lK, lV, lLeft, lRight), + A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, rK, rV, rLeft, rRight)); + } else { + return A5( + $elm$core$Dict$RBNode_elm_builtin, + color, + rK, + rV, + A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, key, value, left, rLeft), + rRight); + } + } else { + if ((((left.$ === 'RBNode_elm_builtin') && (left.a.$ === 'Red')) && (left.d.$ === 'RBNode_elm_builtin')) && (left.d.a.$ === 'Red')) { + var _v5 = left.a; + var lK = left.b; + var lV = left.c; + var _v6 = left.d; + var _v7 = _v6.a; + var llK = _v6.b; + var llV = _v6.c; + var llLeft = _v6.d; + var llRight = _v6.e; + var lRight = left.e; + return A5( + $elm$core$Dict$RBNode_elm_builtin, + $elm$core$Dict$Red, + lK, + lV, + A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, llK, llV, llLeft, llRight), + A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, key, value, lRight, right)); + } else { + return A5($elm$core$Dict$RBNode_elm_builtin, color, key, value, left, right); + } + } + }); +var $elm$core$Dict$insertHelp = F3( + function (key, value, dict) { + if (dict.$ === 'RBEmpty_elm_builtin') { + return A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, key, value, $elm$core$Dict$RBEmpty_elm_builtin, $elm$core$Dict$RBEmpty_elm_builtin); + } else { + var nColor = dict.a; + var nKey = dict.b; + var nValue = dict.c; + var nLeft = dict.d; + var nRight = dict.e; + var _v1 = A2($elm$core$Basics$compare, key, nKey); + switch (_v1.$) { + case 'LT': + return A5( + $elm$core$Dict$balance, + nColor, + nKey, + nValue, + A3($elm$core$Dict$insertHelp, key, value, nLeft), + nRight); + case 'EQ': + return A5($elm$core$Dict$RBNode_elm_builtin, nColor, nKey, value, nLeft, nRight); + default: + return A5( + $elm$core$Dict$balance, + nColor, + nKey, + nValue, + nLeft, + A3($elm$core$Dict$insertHelp, key, value, nRight)); + } + } + }); +var $elm$core$Dict$insert = F3( + function (key, value, dict) { + var _v0 = A3($elm$core$Dict$insertHelp, key, value, dict); + if ((_v0.$ === 'RBNode_elm_builtin') && (_v0.a.$ === 'Red')) { + var _v1 = _v0.a; + var k = _v0.b; + var v = _v0.c; + var l = _v0.d; + var r = _v0.e; + return A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, k, v, l, r); + } else { + var x = _v0; + return x; + } + }); +var $elm$core$Dict$getMin = function (dict) { + getMin: + while (true) { + if ((dict.$ === 'RBNode_elm_builtin') && (dict.d.$ === 'RBNode_elm_builtin')) { + var left = dict.d; + var $temp$dict = left; + dict = $temp$dict; + continue getMin; + } else { + return dict; + } + } +}; +var $elm$core$Dict$moveRedLeft = function (dict) { + if (((dict.$ === 'RBNode_elm_builtin') && (dict.d.$ === 'RBNode_elm_builtin')) && (dict.e.$ === 'RBNode_elm_builtin')) { + if ((dict.e.d.$ === 'RBNode_elm_builtin') && (dict.e.d.a.$ === 'Red')) { + var clr = dict.a; + var k = dict.b; + var v = dict.c; + var _v1 = dict.d; + var lClr = _v1.a; + var lK = _v1.b; + var lV = _v1.c; + var lLeft = _v1.d; + var lRight = _v1.e; + var _v2 = dict.e; + var rClr = _v2.a; + var rK = _v2.b; + var rV = _v2.c; + var rLeft = _v2.d; + var _v3 = rLeft.a; + var rlK = rLeft.b; + var rlV = rLeft.c; + var rlL = rLeft.d; + var rlR = rLeft.e; + var rRight = _v2.e; + return A5( + $elm$core$Dict$RBNode_elm_builtin, + $elm$core$Dict$Red, + rlK, + rlV, + A5( + $elm$core$Dict$RBNode_elm_builtin, + $elm$core$Dict$Black, + k, + v, + A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, lK, lV, lLeft, lRight), + rlL), + A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, rK, rV, rlR, rRight)); + } else { + var clr = dict.a; + var k = dict.b; + var v = dict.c; + var _v4 = dict.d; + var lClr = _v4.a; + var lK = _v4.b; + var lV = _v4.c; + var lLeft = _v4.d; + var lRight = _v4.e; + var _v5 = dict.e; + var rClr = _v5.a; + var rK = _v5.b; + var rV = _v5.c; + var rLeft = _v5.d; + var rRight = _v5.e; + if (clr.$ === 'Black') { + return A5( + $elm$core$Dict$RBNode_elm_builtin, + $elm$core$Dict$Black, + k, + v, + A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, lK, lV, lLeft, lRight), + A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, rK, rV, rLeft, rRight)); + } else { + return A5( + $elm$core$Dict$RBNode_elm_builtin, + $elm$core$Dict$Black, + k, + v, + A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, lK, lV, lLeft, lRight), + A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, rK, rV, rLeft, rRight)); + } + } + } else { + return dict; + } +}; +var $elm$core$Dict$moveRedRight = function (dict) { + if (((dict.$ === 'RBNode_elm_builtin') && (dict.d.$ === 'RBNode_elm_builtin')) && (dict.e.$ === 'RBNode_elm_builtin')) { + if ((dict.d.d.$ === 'RBNode_elm_builtin') && (dict.d.d.a.$ === 'Red')) { + var clr = dict.a; + var k = dict.b; + var v = dict.c; + var _v1 = dict.d; + var lClr = _v1.a; + var lK = _v1.b; + var lV = _v1.c; + var _v2 = _v1.d; + var _v3 = _v2.a; + var llK = _v2.b; + var llV = _v2.c; + var llLeft = _v2.d; + var llRight = _v2.e; + var lRight = _v1.e; + var _v4 = dict.e; + var rClr = _v4.a; + var rK = _v4.b; + var rV = _v4.c; + var rLeft = _v4.d; + var rRight = _v4.e; + return A5( + $elm$core$Dict$RBNode_elm_builtin, + $elm$core$Dict$Red, + lK, + lV, + A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, llK, llV, llLeft, llRight), + A5( + $elm$core$Dict$RBNode_elm_builtin, + $elm$core$Dict$Black, + k, + v, + lRight, + A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, rK, rV, rLeft, rRight))); + } else { + var clr = dict.a; + var k = dict.b; + var v = dict.c; + var _v5 = dict.d; + var lClr = _v5.a; + var lK = _v5.b; + var lV = _v5.c; + var lLeft = _v5.d; + var lRight = _v5.e; + var _v6 = dict.e; + var rClr = _v6.a; + var rK = _v6.b; + var rV = _v6.c; + var rLeft = _v6.d; + var rRight = _v6.e; + if (clr.$ === 'Black') { + return A5( + $elm$core$Dict$RBNode_elm_builtin, + $elm$core$Dict$Black, + k, + v, + A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, lK, lV, lLeft, lRight), + A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, rK, rV, rLeft, rRight)); + } else { + return A5( + $elm$core$Dict$RBNode_elm_builtin, + $elm$core$Dict$Black, + k, + v, + A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, lK, lV, lLeft, lRight), + A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, rK, rV, rLeft, rRight)); + } + } + } else { + return dict; + } +}; +var $elm$core$Dict$removeHelpPrepEQGT = F7( + function (targetKey, dict, color, key, value, left, right) { + if ((left.$ === 'RBNode_elm_builtin') && (left.a.$ === 'Red')) { + var _v1 = left.a; + var lK = left.b; + var lV = left.c; + var lLeft = left.d; + var lRight = left.e; + return A5( + $elm$core$Dict$RBNode_elm_builtin, + color, + lK, + lV, + lLeft, + A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, key, value, lRight, right)); + } else { + _v2$2: + while (true) { + if ((right.$ === 'RBNode_elm_builtin') && (right.a.$ === 'Black')) { + if (right.d.$ === 'RBNode_elm_builtin') { + if (right.d.a.$ === 'Black') { + var _v3 = right.a; + var _v4 = right.d; + var _v5 = _v4.a; + return $elm$core$Dict$moveRedRight(dict); + } else { + break _v2$2; + } + } else { + var _v6 = right.a; + var _v7 = right.d; + return $elm$core$Dict$moveRedRight(dict); + } + } else { + break _v2$2; + } + } + return dict; + } + }); +var $elm$core$Dict$removeMin = function (dict) { + if ((dict.$ === 'RBNode_elm_builtin') && (dict.d.$ === 'RBNode_elm_builtin')) { + var color = dict.a; + var key = dict.b; + var value = dict.c; + var left = dict.d; + var lColor = left.a; + var lLeft = left.d; + var right = dict.e; + if (lColor.$ === 'Black') { + if ((lLeft.$ === 'RBNode_elm_builtin') && (lLeft.a.$ === 'Red')) { + var _v3 = lLeft.a; + return A5( + $elm$core$Dict$RBNode_elm_builtin, + color, + key, + value, + $elm$core$Dict$removeMin(left), + right); + } else { + var _v4 = $elm$core$Dict$moveRedLeft(dict); + if (_v4.$ === 'RBNode_elm_builtin') { + var nColor = _v4.a; + var nKey = _v4.b; + var nValue = _v4.c; + var nLeft = _v4.d; + var nRight = _v4.e; + return A5( + $elm$core$Dict$balance, + nColor, + nKey, + nValue, + $elm$core$Dict$removeMin(nLeft), + nRight); + } else { + return $elm$core$Dict$RBEmpty_elm_builtin; + } + } + } else { + return A5( + $elm$core$Dict$RBNode_elm_builtin, + color, + key, + value, + $elm$core$Dict$removeMin(left), + right); + } + } else { + return $elm$core$Dict$RBEmpty_elm_builtin; + } +}; +var $elm$core$Dict$removeHelp = F2( + function (targetKey, dict) { + if (dict.$ === 'RBEmpty_elm_builtin') { + return $elm$core$Dict$RBEmpty_elm_builtin; + } else { + var color = dict.a; + var key = dict.b; + var value = dict.c; + var left = dict.d; + var right = dict.e; + if (_Utils_cmp(targetKey, key) < 0) { + if ((left.$ === 'RBNode_elm_builtin') && (left.a.$ === 'Black')) { + var _v4 = left.a; + var lLeft = left.d; + if ((lLeft.$ === 'RBNode_elm_builtin') && (lLeft.a.$ === 'Red')) { + var _v6 = lLeft.a; + return A5( + $elm$core$Dict$RBNode_elm_builtin, + color, + key, + value, + A2($elm$core$Dict$removeHelp, targetKey, left), + right); + } else { + var _v7 = $elm$core$Dict$moveRedLeft(dict); + if (_v7.$ === 'RBNode_elm_builtin') { + var nColor = _v7.a; + var nKey = _v7.b; + var nValue = _v7.c; + var nLeft = _v7.d; + var nRight = _v7.e; + return A5( + $elm$core$Dict$balance, + nColor, + nKey, + nValue, + A2($elm$core$Dict$removeHelp, targetKey, nLeft), + nRight); + } else { + return $elm$core$Dict$RBEmpty_elm_builtin; + } + } + } else { + return A5( + $elm$core$Dict$RBNode_elm_builtin, + color, + key, + value, + A2($elm$core$Dict$removeHelp, targetKey, left), + right); + } + } else { + return A2( + $elm$core$Dict$removeHelpEQGT, + targetKey, + A7($elm$core$Dict$removeHelpPrepEQGT, targetKey, dict, color, key, value, left, right)); + } + } + }); +var $elm$core$Dict$removeHelpEQGT = F2( + function (targetKey, dict) { + if (dict.$ === 'RBNode_elm_builtin') { + var color = dict.a; + var key = dict.b; + var value = dict.c; + var left = dict.d; + var right = dict.e; + if (_Utils_eq(targetKey, key)) { + var _v1 = $elm$core$Dict$getMin(right); + if (_v1.$ === 'RBNode_elm_builtin') { + var minKey = _v1.b; + var minValue = _v1.c; + return A5( + $elm$core$Dict$balance, + color, + minKey, + minValue, + left, + $elm$core$Dict$removeMin(right)); + } else { + return $elm$core$Dict$RBEmpty_elm_builtin; + } + } else { + return A5( + $elm$core$Dict$balance, + color, + key, + value, + left, + A2($elm$core$Dict$removeHelp, targetKey, right)); + } + } else { + return $elm$core$Dict$RBEmpty_elm_builtin; + } + }); +var $elm$core$Dict$remove = F2( + function (key, dict) { + var _v0 = A2($elm$core$Dict$removeHelp, key, dict); + if ((_v0.$ === 'RBNode_elm_builtin') && (_v0.a.$ === 'Red')) { + var _v1 = _v0.a; + var k = _v0.b; + var v = _v0.c; + var l = _v0.d; + var r = _v0.e; + return A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, k, v, l, r); + } else { + var x = _v0; + return x; + } + }); +var $elm$core$Dict$update = F3( + function (targetKey, alter, dictionary) { + var _v0 = alter( + A2($elm$core$Dict$get, targetKey, dictionary)); + if (_v0.$ === 'Just') { + var value = _v0.a; + return A3($elm$core$Dict$insert, targetKey, value, dictionary); + } else { + return A2($elm$core$Dict$remove, targetKey, dictionary); + } + }); +var $elm$core$Basics$composeR = F3( + function (f, g, x) { + return g( + f(x)); + }); +var $elm$http$Http$expectStringResponse = F2( + function (toMsg, toResult) { + return A3( + _Http_expect, + '', + $elm$core$Basics$identity, + A2($elm$core$Basics$composeR, toResult, toMsg)); + }); +var $elm$core$Result$mapError = F2( + function (f, result) { + if (result.$ === 'Ok') { + var v = result.a; + return $elm$core$Result$Ok(v); + } else { + var e = result.a; + return $elm$core$Result$Err( + f(e)); + } + }); +var $elm$http$Http$BadBody = function (a) { + return {$: 'BadBody', a: a}; +}; +var $elm$http$Http$BadStatus = function (a) { + return {$: 'BadStatus', a: a}; +}; +var $elm$http$Http$BadUrl = function (a) { + return {$: 'BadUrl', a: a}; +}; +var $elm$http$Http$NetworkError = {$: 'NetworkError'}; +var $elm$http$Http$Timeout = {$: 'Timeout'}; +var $elm$http$Http$resolve = F2( + function (toResult, response) { + switch (response.$) { + case 'BadUrl_': + var url = response.a; + return $elm$core$Result$Err( + $elm$http$Http$BadUrl(url)); + case 'Timeout_': + return $elm$core$Result$Err($elm$http$Http$Timeout); + case 'NetworkError_': + return $elm$core$Result$Err($elm$http$Http$NetworkError); + case 'BadStatus_': + var metadata = response.a; + return $elm$core$Result$Err( + $elm$http$Http$BadStatus(metadata.statusCode)); + default: + var body = response.b; + return A2( + $elm$core$Result$mapError, + $elm$http$Http$BadBody, + toResult(body)); + } + }); +var $elm$http$Http$expectJson = F2( + function (toMsg, decoder) { + return A2( + $elm$http$Http$expectStringResponse, + toMsg, + $elm$http$Http$resolve( + function (string) { + return A2( + $elm$core$Result$mapError, + $elm$json$Json$Decode$errorToString, + A2($elm$json$Json$Decode$decodeString, decoder, string)); + })); + }); +var $elm$http$Http$emptyBody = _Http_emptyBody; +var $elm$http$Http$Request = function (a) { + return {$: 'Request', a: a}; +}; +var $elm$http$Http$State = F2( + function (reqs, subs) { + return {reqs: reqs, subs: subs}; + }); +var $elm$http$Http$init = $elm$core$Task$succeed( + A2($elm$http$Http$State, $elm$core$Dict$empty, _List_Nil)); +var $elm$core$Process$kill = _Scheduler_kill; +var $elm$core$Process$spawn = _Scheduler_spawn; +var $elm$http$Http$updateReqs = F3( + function (router, cmds, reqs) { + updateReqs: + while (true) { + if (!cmds.b) { + return $elm$core$Task$succeed(reqs); + } else { + var cmd = cmds.a; + var otherCmds = cmds.b; + if (cmd.$ === 'Cancel') { + var tracker = cmd.a; + var _v2 = A2($elm$core$Dict$get, tracker, reqs); + if (_v2.$ === 'Nothing') { + var $temp$router = router, + $temp$cmds = otherCmds, + $temp$reqs = reqs; + router = $temp$router; + cmds = $temp$cmds; + reqs = $temp$reqs; + continue updateReqs; + } else { + var pid = _v2.a; + return A2( + $elm$core$Task$andThen, + function (_v3) { + return A3( + $elm$http$Http$updateReqs, + router, + otherCmds, + A2($elm$core$Dict$remove, tracker, reqs)); + }, + $elm$core$Process$kill(pid)); + } + } else { + var req = cmd.a; + return A2( + $elm$core$Task$andThen, + function (pid) { + var _v4 = req.tracker; + if (_v4.$ === 'Nothing') { + return A3($elm$http$Http$updateReqs, router, otherCmds, reqs); + } else { + var tracker = _v4.a; + return A3( + $elm$http$Http$updateReqs, + router, + otherCmds, + A3($elm$core$Dict$insert, tracker, pid, reqs)); + } + }, + $elm$core$Process$spawn( + A3( + _Http_toTask, + router, + $elm$core$Platform$sendToApp(router), + req))); + } + } + } + }); +var $elm$http$Http$onEffects = F4( + function (router, cmds, subs, state) { + return A2( + $elm$core$Task$andThen, + function (reqs) { + return $elm$core$Task$succeed( + A2($elm$http$Http$State, reqs, subs)); + }, + A3($elm$http$Http$updateReqs, router, cmds, state.reqs)); + }); +var $elm$core$List$maybeCons = F3( + function (f, mx, xs) { + var _v0 = f(mx); + if (_v0.$ === 'Just') { + var x = _v0.a; + return A2($elm$core$List$cons, x, xs); + } else { + return xs; + } + }); +var $elm$core$List$filterMap = F2( + function (f, xs) { + return A3( + $elm$core$List$foldr, + $elm$core$List$maybeCons(f), + _List_Nil, + xs); + }); +var $elm$http$Http$maybeSend = F4( + function (router, desiredTracker, progress, _v0) { + var actualTracker = _v0.a; + var toMsg = _v0.b; + return _Utils_eq(desiredTracker, actualTracker) ? $elm$core$Maybe$Just( + A2( + $elm$core$Platform$sendToApp, + router, + toMsg(progress))) : $elm$core$Maybe$Nothing; + }); +var $elm$http$Http$onSelfMsg = F3( + function (router, _v0, state) { + var tracker = _v0.a; + var progress = _v0.b; + return A2( + $elm$core$Task$andThen, + function (_v1) { + return $elm$core$Task$succeed(state); + }, + $elm$core$Task$sequence( + A2( + $elm$core$List$filterMap, + A3($elm$http$Http$maybeSend, router, tracker, progress), + state.subs))); + }); +var $elm$http$Http$Cancel = function (a) { + return {$: 'Cancel', a: a}; +}; +var $elm$http$Http$cmdMap = F2( + function (func, cmd) { + if (cmd.$ === 'Cancel') { + var tracker = cmd.a; + return $elm$http$Http$Cancel(tracker); + } else { + var r = cmd.a; + return $elm$http$Http$Request( + { + allowCookiesFromOtherDomains: r.allowCookiesFromOtherDomains, + body: r.body, + expect: A2(_Http_mapExpect, func, r.expect), + headers: r.headers, + method: r.method, + timeout: r.timeout, + tracker: r.tracker, + url: r.url + }); + } + }); +var $elm$http$Http$MySub = F2( + function (a, b) { + return {$: 'MySub', a: a, b: b}; + }); +var $elm$http$Http$subMap = F2( + function (func, _v0) { + var tracker = _v0.a; + var toMsg = _v0.b; + return A2( + $elm$http$Http$MySub, + tracker, + A2($elm$core$Basics$composeR, toMsg, func)); + }); +_Platform_effectManagers['Http'] = _Platform_createManager($elm$http$Http$init, $elm$http$Http$onEffects, $elm$http$Http$onSelfMsg, $elm$http$Http$cmdMap, $elm$http$Http$subMap); +var $elm$http$Http$command = _Platform_leaf('Http'); +var $elm$http$Http$subscription = _Platform_leaf('Http'); +var $elm$http$Http$request = function (r) { + return $elm$http$Http$command( + $elm$http$Http$Request( + {allowCookiesFromOtherDomains: false, body: r.body, expect: r.expect, headers: r.headers, method: r.method, timeout: r.timeout, tracker: r.tracker, url: r.url})); +}; +var $elm$http$Http$get = function (r) { + return $elm$http$Http$request( + {body: $elm$http$Http$emptyBody, expect: r.expect, headers: _List_Nil, method: 'GET', timeout: $elm$core$Maybe$Nothing, tracker: $elm$core$Maybe$Nothing, url: r.url}); +}; +var $author$project$Api$ErrorResponse = function (a) { + return {$: 'ErrorResponse', a: a}; +}; +var $author$project$Api$OkResponse = function (a) { + return {$: 'OkResponse', a: a}; +}; +var $elm$json$Json$Decode$field = _Json_decodeField; +var $elm$json$Json$Decode$andThen = _Json_andThen; +var $author$project$Api$convertKeysToIntDict = function (stringKeyedDict) { + return $elm$json$Json$Decode$succeed( + A3( + $elm$core$List$foldl, + F2( + function (maybePair, acc) { + if (maybePair.a.$ === 'Just') { + var intKey = maybePair.a.a; + var lesson = maybePair.b; + return A3($elm$core$Dict$insert, intKey, lesson, acc); + } else { + var _v2 = maybePair.a; + return acc; + } + }), + $elm$core$Dict$empty, + A2( + $elm$core$List$map, + function (_v0) { + var key = _v0.a; + var lesson = _v0.b; + return _Utils_Tuple2( + $elm$core$String$toInt(key), + lesson); + }, + $elm$core$Dict$toList(stringKeyedDict)))); +}; +var $elm$core$Dict$fromList = function (assocs) { + return A3( + $elm$core$List$foldl, + F2( + function (_v0, dict) { + var key = _v0.a; + var value = _v0.b; + return A3($elm$core$Dict$insert, key, value, dict); + }), + $elm$core$Dict$empty, + assocs); +}; +var $elm$json$Json$Decode$keyValuePairs = _Json_decodeKeyValuePairs; +var $elm$json$Json$Decode$dict = function (decoder) { + return A2( + $elm$json$Json$Decode$map, + $elm$core$Dict$fromList, + $elm$json$Json$Decode$keyValuePairs(decoder)); +}; +var $author$project$Api$Lesson = F3( + function (text, id, cards) { + return {cards: cards, id: id, text: text}; + }); +var $author$project$Api$Card = F3( + function (text, note, id) { + return {id: id, note: note, text: text}; + }); +var $elm$json$Json$Decode$int = _Json_decodeInt; +var $elm$json$Json$Decode$map3 = _Json_map3; +var $elm$json$Json$Decode$oneOf = _Json_oneOf; +var $elm$json$Json$Decode$maybe = function (decoder) { + return $elm$json$Json$Decode$oneOf( + _List_fromArray( + [ + A2($elm$json$Json$Decode$map, $elm$core$Maybe$Just, decoder), + $elm$json$Json$Decode$succeed($elm$core$Maybe$Nothing) + ])); +}; +var $elm$json$Json$Decode$string = _Json_decodeString; +var $author$project$Api$cardDecoder = A4( + $elm$json$Json$Decode$map3, + $author$project$Api$Card, + A2($elm$json$Json$Decode$field, 'text', $elm$json$Json$Decode$string), + A2( + $elm$json$Json$Decode$field, + 'note', + $elm$json$Json$Decode$maybe($elm$json$Json$Decode$string)), + A2($elm$json$Json$Decode$field, 'id', $elm$json$Json$Decode$int)); +var $elm$json$Json$Decode$list = _Json_decodeList; +var $author$project$Api$lessonDecoder = A4( + $elm$json$Json$Decode$map3, + $author$project$Api$Lesson, + A2($elm$json$Json$Decode$field, 'text', $elm$json$Json$Decode$string), + A2($elm$json$Json$Decode$field, 'id', $elm$json$Json$Decode$int), + A2( + $elm$json$Json$Decode$field, + 'cards', + $elm$json$Json$Decode$list($author$project$Api$cardDecoder))); +var $author$project$Api$lessonsDecoder = A2( + $elm$json$Json$Decode$andThen, + $author$project$Api$convertKeysToIntDict, + $elm$json$Json$Decode$dict($author$project$Api$lessonDecoder)); +var $author$project$Api$serverResponseDecoder = $elm$json$Json$Decode$oneOf( + _List_fromArray( + [ + A2( + $elm$json$Json$Decode$map, + $author$project$Api$OkResponse, + A2($elm$json$Json$Decode$field, 'ok', $author$project$Api$lessonsDecoder)), + A2( + $elm$json$Json$Decode$map, + $author$project$Api$ErrorResponse, + A2($elm$json$Json$Decode$field, 'error', $elm$json$Json$Decode$string)) + ])); +var $author$project$Api$fetchLessons = function (toMsg) { + return $elm$http$Http$get( + { + expect: A2($elm$http$Http$expectJson, toMsg, $author$project$Api$serverResponseDecoder), + url: 'http://localhost:3000/api/lessons' + }); +}; +var $author$project$Main$Lessons = {$: 'Lessons'}; +var $author$project$Main$sampleLessons = $elm$core$Dict$fromList(_List_Nil); +var $author$project$Main$initialState = {isLoading: false, lessons: $author$project$Main$sampleLessons, tab: $author$project$Main$Lessons}; +var $elm$core$Debug$log = _Debug_log; +var $author$project$Main$init = function (flags) { + return function (_v1) { + return _Utils_Tuple2( + $author$project$Main$initialState, + $author$project$Api$fetchLessons($author$project$Main$FetchDataHandler)); + }( + function (_v0) { + return A2($elm$core$Debug$log, 'Initial State', $author$project$Main$initialState); + }( + A2($elm$core$Debug$log, 'Init flags', flags))); +}; +var $elm$core$Platform$Sub$batch = _Platform_batch; +var $elm$core$Platform$Sub$none = $elm$core$Platform$Sub$batch(_List_Nil); +var $elm$core$Platform$Cmd$batch = _Platform_batch; +var $elm$core$Platform$Cmd$none = $elm$core$Platform$Cmd$batch(_List_Nil); +var $author$project$Main$update = F2( + function (msg, model) { + if (msg.$ === 'UserSelectedTab') { + var t = msg.a; + return _Utils_Tuple2( + _Utils_update( + model, + {tab: t}), + $elm$core$Platform$Cmd$none); + } else { + if (msg.a.$ === 'Ok') { + var serres = msg.a.a; + if (serres.$ === 'OkResponse') { + var lessons = serres.a; + return _Utils_Tuple2( + _Utils_update( + model, + {isLoading: false, lessons: lessons}), + $elm$core$Platform$Cmd$none); + } else { + return _Utils_Tuple2( + _Utils_update( + model, + {isLoading: false}), + $elm$core$Platform$Cmd$none); + } + } else { + return _Utils_Tuple2( + _Utils_update( + model, + {isLoading: false}), + $elm$core$Platform$Cmd$none); + } + } + }); +var $author$project$Main$Pronunciation = {$: 'Pronunciation'}; +var $author$project$Main$Words = {$: 'Words'}; +var $mdgriffith$elm_ui$Internal$Model$AlignX = function (a) { + return {$: 'AlignX', a: a}; +}; +var $mdgriffith$elm_ui$Internal$Model$CenterX = {$: 'CenterX'}; +var $mdgriffith$elm_ui$Element$centerX = $mdgriffith$elm_ui$Internal$Model$AlignX($mdgriffith$elm_ui$Internal$Model$CenterX); +var $mdgriffith$elm_ui$Internal$Model$Unkeyed = function (a) { + return {$: 'Unkeyed', a: a}; +}; +var $mdgriffith$elm_ui$Internal$Model$AsColumn = {$: 'AsColumn'}; +var $mdgriffith$elm_ui$Internal$Model$asColumn = $mdgriffith$elm_ui$Internal$Model$AsColumn; +var $mdgriffith$elm_ui$Internal$Style$classes = {above: 'a', active: 'atv', alignBottom: 'ab', alignCenterX: 'cx', alignCenterY: 'cy', alignContainerBottom: 'acb', alignContainerCenterX: 'accx', alignContainerCenterY: 'accy', alignContainerRight: 'acr', alignLeft: 'al', alignRight: 'ar', alignTop: 'at', alignedHorizontally: 'ah', alignedVertically: 'av', any: 's', behind: 'bh', below: 'b', bold: 'w7', borderDashed: 'bd', borderDotted: 'bdt', borderNone: 'bn', borderSolid: 'bs', capturePointerEvents: 'cpe', clip: 'cp', clipX: 'cpx', clipY: 'cpy', column: 'c', container: 'ctr', contentBottom: 'cb', contentCenterX: 'ccx', contentCenterY: 'ccy', contentLeft: 'cl', contentRight: 'cr', contentTop: 'ct', cursorPointer: 'cptr', cursorText: 'ctxt', focus: 'fcs', focusedWithin: 'focus-within', fullSize: 'fs', grid: 'g', hasBehind: 'hbh', heightContent: 'hc', heightExact: 'he', heightFill: 'hf', heightFillPortion: 'hfp', hover: 'hv', imageContainer: 'ic', inFront: 'fr', inputLabel: 'lbl', inputMultiline: 'iml', inputMultilineFiller: 'imlf', inputMultilineParent: 'imlp', inputMultilineWrapper: 'implw', inputText: 'it', italic: 'i', link: 'lnk', nearby: 'nb', noTextSelection: 'notxt', onLeft: 'ol', onRight: 'or', opaque: 'oq', overflowHidden: 'oh', page: 'pg', paragraph: 'p', passPointerEvents: 'ppe', root: 'ui', row: 'r', scrollbars: 'sb', scrollbarsX: 'sbx', scrollbarsY: 'sby', seButton: 'sbt', single: 'e', sizeByCapital: 'cap', spaceEvenly: 'sev', strike: 'sk', text: 't', textCenter: 'tc', textExtraBold: 'w8', textExtraLight: 'w2', textHeavy: 'w9', textJustify: 'tj', textJustifyAll: 'tja', textLeft: 'tl', textLight: 'w3', textMedium: 'w5', textNormalWeight: 'w4', textRight: 'tr', textSemiBold: 'w6', textThin: 'w1', textUnitalicized: 'tun', transition: 'ts', transparent: 'clr', underline: 'u', widthContent: 'wc', widthExact: 'we', widthFill: 'wf', widthFillPortion: 'wfp', wrapped: 'wrp'}; +var $mdgriffith$elm_ui$Internal$Model$Generic = {$: 'Generic'}; +var $mdgriffith$elm_ui$Internal$Model$div = $mdgriffith$elm_ui$Internal$Model$Generic; +var $mdgriffith$elm_ui$Internal$Model$NoNearbyChildren = {$: 'NoNearbyChildren'}; +var $mdgriffith$elm_ui$Internal$Model$columnClass = $mdgriffith$elm_ui$Internal$Style$classes.any + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.column); +var $mdgriffith$elm_ui$Internal$Model$gridClass = $mdgriffith$elm_ui$Internal$Style$classes.any + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.grid); +var $mdgriffith$elm_ui$Internal$Model$pageClass = $mdgriffith$elm_ui$Internal$Style$classes.any + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.page); +var $mdgriffith$elm_ui$Internal$Model$paragraphClass = $mdgriffith$elm_ui$Internal$Style$classes.any + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.paragraph); +var $mdgriffith$elm_ui$Internal$Model$rowClass = $mdgriffith$elm_ui$Internal$Style$classes.any + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.row); +var $mdgriffith$elm_ui$Internal$Model$singleClass = $mdgriffith$elm_ui$Internal$Style$classes.any + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.single); +var $mdgriffith$elm_ui$Internal$Model$contextClasses = function (context) { + switch (context.$) { + case 'AsRow': + return $mdgriffith$elm_ui$Internal$Model$rowClass; + case 'AsColumn': + return $mdgriffith$elm_ui$Internal$Model$columnClass; + case 'AsEl': + return $mdgriffith$elm_ui$Internal$Model$singleClass; + case 'AsGrid': + return $mdgriffith$elm_ui$Internal$Model$gridClass; + case 'AsParagraph': + return $mdgriffith$elm_ui$Internal$Model$paragraphClass; + default: + return $mdgriffith$elm_ui$Internal$Model$pageClass; + } +}; +var $mdgriffith$elm_ui$Internal$Model$Keyed = function (a) { + return {$: 'Keyed', a: a}; +}; +var $mdgriffith$elm_ui$Internal$Model$NoStyleSheet = {$: 'NoStyleSheet'}; +var $mdgriffith$elm_ui$Internal$Model$Styled = function (a) { + return {$: 'Styled', a: a}; +}; +var $mdgriffith$elm_ui$Internal$Model$Unstyled = function (a) { + return {$: 'Unstyled', a: a}; +}; +var $mdgriffith$elm_ui$Internal$Model$addChildren = F2( + function (existing, nearbyChildren) { + switch (nearbyChildren.$) { + case 'NoNearbyChildren': + return existing; + case 'ChildrenBehind': + var behind = nearbyChildren.a; + return _Utils_ap(behind, existing); + case 'ChildrenInFront': + var inFront = nearbyChildren.a; + return _Utils_ap(existing, inFront); + default: + var behind = nearbyChildren.a; + var inFront = nearbyChildren.b; + return _Utils_ap( + behind, + _Utils_ap(existing, inFront)); + } + }); +var $mdgriffith$elm_ui$Internal$Model$addKeyedChildren = F3( + function (key, existing, nearbyChildren) { + switch (nearbyChildren.$) { + case 'NoNearbyChildren': + return existing; + case 'ChildrenBehind': + var behind = nearbyChildren.a; + return _Utils_ap( + A2( + $elm$core$List$map, + function (x) { + return _Utils_Tuple2(key, x); + }, + behind), + existing); + case 'ChildrenInFront': + var inFront = nearbyChildren.a; + return _Utils_ap( + existing, + A2( + $elm$core$List$map, + function (x) { + return _Utils_Tuple2(key, x); + }, + inFront)); + default: + var behind = nearbyChildren.a; + var inFront = nearbyChildren.b; + return _Utils_ap( + A2( + $elm$core$List$map, + function (x) { + return _Utils_Tuple2(key, x); + }, + behind), + _Utils_ap( + existing, + A2( + $elm$core$List$map, + function (x) { + return _Utils_Tuple2(key, x); + }, + inFront))); + } + }); +var $mdgriffith$elm_ui$Internal$Model$AsEl = {$: 'AsEl'}; +var $mdgriffith$elm_ui$Internal$Model$asEl = $mdgriffith$elm_ui$Internal$Model$AsEl; +var $mdgriffith$elm_ui$Internal$Model$AsParagraph = {$: 'AsParagraph'}; +var $mdgriffith$elm_ui$Internal$Model$asParagraph = $mdgriffith$elm_ui$Internal$Model$AsParagraph; +var $mdgriffith$elm_ui$Internal$Flag$Flag = function (a) { + return {$: 'Flag', a: a}; +}; +var $mdgriffith$elm_ui$Internal$Flag$Second = function (a) { + return {$: 'Second', a: a}; +}; +var $elm$core$Bitwise$shiftLeftBy = _Bitwise_shiftLeftBy; +var $mdgriffith$elm_ui$Internal$Flag$flag = function (i) { + return (i > 31) ? $mdgriffith$elm_ui$Internal$Flag$Second(1 << (i - 32)) : $mdgriffith$elm_ui$Internal$Flag$Flag(1 << i); +}; +var $mdgriffith$elm_ui$Internal$Flag$alignBottom = $mdgriffith$elm_ui$Internal$Flag$flag(41); +var $mdgriffith$elm_ui$Internal$Flag$alignRight = $mdgriffith$elm_ui$Internal$Flag$flag(40); +var $mdgriffith$elm_ui$Internal$Flag$centerX = $mdgriffith$elm_ui$Internal$Flag$flag(42); +var $mdgriffith$elm_ui$Internal$Flag$centerY = $mdgriffith$elm_ui$Internal$Flag$flag(43); +var $elm$json$Json$Encode$string = _Json_wrap; +var $elm$html$Html$Attributes$stringProperty = F2( + function (key, string) { + return A2( + _VirtualDom_property, + key, + $elm$json$Json$Encode$string(string)); + }); +var $elm$html$Html$Attributes$class = $elm$html$Html$Attributes$stringProperty('className'); +var $elm$html$Html$div = _VirtualDom_node('div'); +var $elm$core$Set$Set_elm_builtin = function (a) { + return {$: 'Set_elm_builtin', a: a}; +}; +var $elm$core$Set$empty = $elm$core$Set$Set_elm_builtin($elm$core$Dict$empty); +var $mdgriffith$elm_ui$Internal$Model$lengthClassName = function (x) { + switch (x.$) { + case 'Px': + var px = x.a; + return $elm$core$String$fromInt(px) + 'px'; + case 'Content': + return 'auto'; + case 'Fill': + var i = x.a; + return $elm$core$String$fromInt(i) + 'fr'; + case 'Min': + var min = x.a; + var len = x.b; + return 'min' + ($elm$core$String$fromInt(min) + $mdgriffith$elm_ui$Internal$Model$lengthClassName(len)); + default: + var max = x.a; + var len = x.b; + return 'max' + ($elm$core$String$fromInt(max) + $mdgriffith$elm_ui$Internal$Model$lengthClassName(len)); + } +}; +var $elm$core$Tuple$second = function (_v0) { + var y = _v0.b; + return y; +}; +var $elm$core$Basics$round = _Basics_round; +var $mdgriffith$elm_ui$Internal$Model$floatClass = function (x) { + return $elm$core$String$fromInt( + $elm$core$Basics$round(x * 255)); +}; +var $mdgriffith$elm_ui$Internal$Model$transformClass = function (transform) { + switch (transform.$) { + case 'Untransformed': + return $elm$core$Maybe$Nothing; + case 'Moved': + var _v1 = transform.a; + var x = _v1.a; + var y = _v1.b; + var z = _v1.c; + return $elm$core$Maybe$Just( + 'mv-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(x) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(y) + ('-' + $mdgriffith$elm_ui$Internal$Model$floatClass(z)))))); + default: + var _v2 = transform.a; + var tx = _v2.a; + var ty = _v2.b; + var tz = _v2.c; + var _v3 = transform.b; + var sx = _v3.a; + var sy = _v3.b; + var sz = _v3.c; + var _v4 = transform.c; + var ox = _v4.a; + var oy = _v4.b; + var oz = _v4.c; + var angle = transform.d; + return $elm$core$Maybe$Just( + 'tfrm-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(tx) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(ty) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(tz) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(sx) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(sy) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(sz) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(ox) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(oy) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(oz) + ('-' + $mdgriffith$elm_ui$Internal$Model$floatClass(angle)))))))))))))))))))); + } +}; +var $elm$core$Maybe$withDefault = F2( + function (_default, maybe) { + if (maybe.$ === 'Just') { + var value = maybe.a; + return value; + } else { + return _default; + } + }); +var $mdgriffith$elm_ui$Internal$Model$getStyleName = function (style) { + switch (style.$) { + case 'Shadows': + var name = style.a; + return name; + case 'Transparency': + var name = style.a; + var o = style.b; + return name; + case 'Style': + var _class = style.a; + return _class; + case 'FontFamily': + var name = style.a; + return name; + case 'FontSize': + var i = style.a; + return 'font-size-' + $elm$core$String$fromInt(i); + case 'Single': + var _class = style.a; + return _class; + case 'Colored': + var _class = style.a; + return _class; + case 'SpacingStyle': + var cls = style.a; + var x = style.b; + var y = style.c; + return cls; + case 'PaddingStyle': + var cls = style.a; + var top = style.b; + var right = style.c; + var bottom = style.d; + var left = style.e; + return cls; + case 'BorderWidth': + var cls = style.a; + var top = style.b; + var right = style.c; + var bottom = style.d; + var left = style.e; + return cls; + case 'GridTemplateStyle': + var template = style.a; + return 'grid-rows-' + (A2( + $elm$core$String$join, + '-', + A2($elm$core$List$map, $mdgriffith$elm_ui$Internal$Model$lengthClassName, template.rows)) + ('-cols-' + (A2( + $elm$core$String$join, + '-', + A2($elm$core$List$map, $mdgriffith$elm_ui$Internal$Model$lengthClassName, template.columns)) + ('-space-x-' + ($mdgriffith$elm_ui$Internal$Model$lengthClassName(template.spacing.a) + ('-space-y-' + $mdgriffith$elm_ui$Internal$Model$lengthClassName(template.spacing.b))))))); + case 'GridPosition': + var pos = style.a; + return 'gp grid-pos-' + ($elm$core$String$fromInt(pos.row) + ('-' + ($elm$core$String$fromInt(pos.col) + ('-' + ($elm$core$String$fromInt(pos.width) + ('-' + $elm$core$String$fromInt(pos.height))))))); + case 'PseudoSelector': + var selector = style.a; + var subStyle = style.b; + var name = function () { + switch (selector.$) { + case 'Focus': + return 'fs'; + case 'Hover': + return 'hv'; + default: + return 'act'; + } + }(); + return A2( + $elm$core$String$join, + ' ', + A2( + $elm$core$List$map, + function (sty) { + var _v1 = $mdgriffith$elm_ui$Internal$Model$getStyleName(sty); + if (_v1 === '') { + return ''; + } else { + var styleName = _v1; + return styleName + ('-' + name); + } + }, + subStyle)); + default: + var x = style.a; + return A2( + $elm$core$Maybe$withDefault, + '', + $mdgriffith$elm_ui$Internal$Model$transformClass(x)); + } +}; +var $elm$core$Set$insert = F2( + function (key, _v0) { + var dict = _v0.a; + return $elm$core$Set$Set_elm_builtin( + A3($elm$core$Dict$insert, key, _Utils_Tuple0, dict)); + }); +var $elm$core$Dict$member = F2( + function (key, dict) { + var _v0 = A2($elm$core$Dict$get, key, dict); + if (_v0.$ === 'Just') { + return true; + } else { + return false; + } + }); +var $elm$core$Set$member = F2( + function (key, _v0) { + var dict = _v0.a; + return A2($elm$core$Dict$member, key, dict); + }); +var $mdgriffith$elm_ui$Internal$Model$reduceStyles = F2( + function (style, nevermind) { + var cache = nevermind.a; + var existing = nevermind.b; + var styleName = $mdgriffith$elm_ui$Internal$Model$getStyleName(style); + return A2($elm$core$Set$member, styleName, cache) ? nevermind : _Utils_Tuple2( + A2($elm$core$Set$insert, styleName, cache), + A2($elm$core$List$cons, style, existing)); + }); +var $mdgriffith$elm_ui$Internal$Model$Property = F2( + function (a, b) { + return {$: 'Property', a: a, b: b}; + }); +var $mdgriffith$elm_ui$Internal$Model$Style = F2( + function (a, b) { + return {$: 'Style', a: a, b: b}; + }); +var $mdgriffith$elm_ui$Internal$Style$dot = function (c) { + return '.' + c; +}; +var $elm$core$String$fromFloat = _String_fromNumber; +var $mdgriffith$elm_ui$Internal$Model$formatColor = function (_v0) { + var red = _v0.a; + var green = _v0.b; + var blue = _v0.c; + var alpha = _v0.d; + return 'rgba(' + ($elm$core$String$fromInt( + $elm$core$Basics$round(red * 255)) + ((',' + $elm$core$String$fromInt( + $elm$core$Basics$round(green * 255))) + ((',' + $elm$core$String$fromInt( + $elm$core$Basics$round(blue * 255))) + (',' + ($elm$core$String$fromFloat(alpha) + ')'))))); +}; +var $mdgriffith$elm_ui$Internal$Model$formatBoxShadow = function (shadow) { + return A2( + $elm$core$String$join, + ' ', + A2( + $elm$core$List$filterMap, + $elm$core$Basics$identity, + _List_fromArray( + [ + shadow.inset ? $elm$core$Maybe$Just('inset') : $elm$core$Maybe$Nothing, + $elm$core$Maybe$Just( + $elm$core$String$fromFloat(shadow.offset.a) + 'px'), + $elm$core$Maybe$Just( + $elm$core$String$fromFloat(shadow.offset.b) + 'px'), + $elm$core$Maybe$Just( + $elm$core$String$fromFloat(shadow.blur) + 'px'), + $elm$core$Maybe$Just( + $elm$core$String$fromFloat(shadow.size) + 'px'), + $elm$core$Maybe$Just( + $mdgriffith$elm_ui$Internal$Model$formatColor(shadow.color)) + ]))); +}; +var $elm$core$Maybe$map = F2( + function (f, maybe) { + if (maybe.$ === 'Just') { + var value = maybe.a; + return $elm$core$Maybe$Just( + f(value)); + } else { + return $elm$core$Maybe$Nothing; + } + }); +var $elm$core$Tuple$mapFirst = F2( + function (func, _v0) { + var x = _v0.a; + var y = _v0.b; + return _Utils_Tuple2( + func(x), + y); + }); +var $elm$core$Tuple$mapSecond = F2( + function (func, _v0) { + var x = _v0.a; + var y = _v0.b; + return _Utils_Tuple2( + x, + func(y)); + }); +var $mdgriffith$elm_ui$Internal$Model$renderFocusStyle = function (focus) { + return _List_fromArray( + [ + A2( + $mdgriffith$elm_ui$Internal$Model$Style, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.focusedWithin) + ':focus-within', + A2( + $elm$core$List$filterMap, + $elm$core$Basics$identity, + _List_fromArray( + [ + A2( + $elm$core$Maybe$map, + function (color) { + return A2( + $mdgriffith$elm_ui$Internal$Model$Property, + 'border-color', + $mdgriffith$elm_ui$Internal$Model$formatColor(color)); + }, + focus.borderColor), + A2( + $elm$core$Maybe$map, + function (color) { + return A2( + $mdgriffith$elm_ui$Internal$Model$Property, + 'background-color', + $mdgriffith$elm_ui$Internal$Model$formatColor(color)); + }, + focus.backgroundColor), + A2( + $elm$core$Maybe$map, + function (shadow) { + return A2( + $mdgriffith$elm_ui$Internal$Model$Property, + 'box-shadow', + $mdgriffith$elm_ui$Internal$Model$formatBoxShadow( + { + blur: shadow.blur, + color: shadow.color, + inset: false, + offset: A2( + $elm$core$Tuple$mapSecond, + $elm$core$Basics$toFloat, + A2($elm$core$Tuple$mapFirst, $elm$core$Basics$toFloat, shadow.offset)), + size: shadow.size + })); + }, + focus.shadow), + $elm$core$Maybe$Just( + A2($mdgriffith$elm_ui$Internal$Model$Property, 'outline', 'none')) + ]))), + A2( + $mdgriffith$elm_ui$Internal$Model$Style, + ($mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.any) + ':focus .focusable, ') + (($mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.any) + '.focusable:focus, ') + ('.ui-slide-bar:focus + ' + ($mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.any) + ' .focusable-thumb'))), + A2( + $elm$core$List$filterMap, + $elm$core$Basics$identity, + _List_fromArray( + [ + A2( + $elm$core$Maybe$map, + function (color) { + return A2( + $mdgriffith$elm_ui$Internal$Model$Property, + 'border-color', + $mdgriffith$elm_ui$Internal$Model$formatColor(color)); + }, + focus.borderColor), + A2( + $elm$core$Maybe$map, + function (color) { + return A2( + $mdgriffith$elm_ui$Internal$Model$Property, + 'background-color', + $mdgriffith$elm_ui$Internal$Model$formatColor(color)); + }, + focus.backgroundColor), + A2( + $elm$core$Maybe$map, + function (shadow) { + return A2( + $mdgriffith$elm_ui$Internal$Model$Property, + 'box-shadow', + $mdgriffith$elm_ui$Internal$Model$formatBoxShadow( + { + blur: shadow.blur, + color: shadow.color, + inset: false, + offset: A2( + $elm$core$Tuple$mapSecond, + $elm$core$Basics$toFloat, + A2($elm$core$Tuple$mapFirst, $elm$core$Basics$toFloat, shadow.offset)), + size: shadow.size + })); + }, + focus.shadow), + $elm$core$Maybe$Just( + A2($mdgriffith$elm_ui$Internal$Model$Property, 'outline', 'none')) + ]))) + ]); +}; +var $elm$virtual_dom$VirtualDom$node = function (tag) { + return _VirtualDom_node( + _VirtualDom_noScript(tag)); +}; +var $elm$virtual_dom$VirtualDom$property = F2( + function (key, value) { + return A2( + _VirtualDom_property, + _VirtualDom_noInnerHtmlOrFormAction(key), + _VirtualDom_noJavaScriptOrHtmlJson(value)); + }); +var $mdgriffith$elm_ui$Internal$Style$AllChildren = F2( + function (a, b) { + return {$: 'AllChildren', a: a, b: b}; + }); +var $mdgriffith$elm_ui$Internal$Style$Batch = function (a) { + return {$: 'Batch', a: a}; +}; +var $mdgriffith$elm_ui$Internal$Style$Child = F2( + function (a, b) { + return {$: 'Child', a: a, b: b}; + }); +var $mdgriffith$elm_ui$Internal$Style$Class = F2( + function (a, b) { + return {$: 'Class', a: a, b: b}; + }); +var $mdgriffith$elm_ui$Internal$Style$Descriptor = F2( + function (a, b) { + return {$: 'Descriptor', a: a, b: b}; + }); +var $mdgriffith$elm_ui$Internal$Style$Left = {$: 'Left'}; +var $mdgriffith$elm_ui$Internal$Style$Prop = F2( + function (a, b) { + return {$: 'Prop', a: a, b: b}; + }); +var $mdgriffith$elm_ui$Internal$Style$Right = {$: 'Right'}; +var $mdgriffith$elm_ui$Internal$Style$Self = function (a) { + return {$: 'Self', a: a}; +}; +var $mdgriffith$elm_ui$Internal$Style$Supports = F2( + function (a, b) { + return {$: 'Supports', a: a, b: b}; + }); +var $mdgriffith$elm_ui$Internal$Style$Content = function (a) { + return {$: 'Content', a: a}; +}; +var $mdgriffith$elm_ui$Internal$Style$Bottom = {$: 'Bottom'}; +var $mdgriffith$elm_ui$Internal$Style$CenterX = {$: 'CenterX'}; +var $mdgriffith$elm_ui$Internal$Style$CenterY = {$: 'CenterY'}; +var $mdgriffith$elm_ui$Internal$Style$Top = {$: 'Top'}; +var $mdgriffith$elm_ui$Internal$Style$alignments = _List_fromArray( + [$mdgriffith$elm_ui$Internal$Style$Top, $mdgriffith$elm_ui$Internal$Style$Bottom, $mdgriffith$elm_ui$Internal$Style$Right, $mdgriffith$elm_ui$Internal$Style$Left, $mdgriffith$elm_ui$Internal$Style$CenterX, $mdgriffith$elm_ui$Internal$Style$CenterY]); +var $elm$core$List$append = F2( + function (xs, ys) { + if (!ys.b) { + return xs; + } else { + return A3($elm$core$List$foldr, $elm$core$List$cons, ys, xs); + } + }); +var $elm$core$List$concat = function (lists) { + return A3($elm$core$List$foldr, $elm$core$List$append, _List_Nil, lists); +}; +var $elm$core$List$concatMap = F2( + function (f, list) { + return $elm$core$List$concat( + A2($elm$core$List$map, f, list)); + }); +var $mdgriffith$elm_ui$Internal$Style$contentName = function (desc) { + switch (desc.a.$) { + case 'Top': + var _v1 = desc.a; + return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.contentTop); + case 'Bottom': + var _v2 = desc.a; + return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.contentBottom); + case 'Right': + var _v3 = desc.a; + return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.contentRight); + case 'Left': + var _v4 = desc.a; + return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.contentLeft); + case 'CenterX': + var _v5 = desc.a; + return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.contentCenterX); + default: + var _v6 = desc.a; + return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.contentCenterY); + } +}; +var $mdgriffith$elm_ui$Internal$Style$selfName = function (desc) { + switch (desc.a.$) { + case 'Top': + var _v1 = desc.a; + return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.alignTop); + case 'Bottom': + var _v2 = desc.a; + return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.alignBottom); + case 'Right': + var _v3 = desc.a; + return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.alignRight); + case 'Left': + var _v4 = desc.a; + return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.alignLeft); + case 'CenterX': + var _v5 = desc.a; + return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.alignCenterX); + default: + var _v6 = desc.a; + return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.alignCenterY); + } +}; +var $mdgriffith$elm_ui$Internal$Style$describeAlignment = function (values) { + var createDescription = function (alignment) { + var _v0 = values(alignment); + var content = _v0.a; + var indiv = _v0.b; + return _List_fromArray( + [ + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$contentName( + $mdgriffith$elm_ui$Internal$Style$Content(alignment)), + content), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.any), + _List_fromArray( + [ + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$selfName( + $mdgriffith$elm_ui$Internal$Style$Self(alignment)), + indiv) + ])) + ]); + }; + return $mdgriffith$elm_ui$Internal$Style$Batch( + A2($elm$core$List$concatMap, createDescription, $mdgriffith$elm_ui$Internal$Style$alignments)); +}; +var $mdgriffith$elm_ui$Internal$Style$elDescription = _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'flex'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-direction', 'column'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'white-space', 'pre'), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.hasBehind), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'z-index', '0'), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.behind), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'z-index', '-1') + ])) + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.seButton), + _List_fromArray( + [ + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.text), + _List_fromArray( + [ + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.heightFill), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '0') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.widthFill), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'auto !important') + ])) + ])) + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.heightContent), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', 'auto') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.heightFill), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '100000') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.widthFill), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.widthFillPortion), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.widthContent), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'flex-start') + ])), + $mdgriffith$elm_ui$Internal$Style$describeAlignment( + function (alignment) { + switch (alignment.$) { + case 'Top': + return _Utils_Tuple2( + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'flex-start') + ]), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-bottom', 'auto !important'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-top', '0 !important') + ])); + case 'Bottom': + return _Utils_Tuple2( + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'flex-end') + ]), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-top', 'auto !important'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-bottom', '0 !important') + ])); + case 'Right': + return _Utils_Tuple2( + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'flex-end') + ]), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'flex-end') + ])); + case 'Left': + return _Utils_Tuple2( + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'flex-start') + ]), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'flex-start') + ])); + case 'CenterX': + return _Utils_Tuple2( + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'center') + ]), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'center') + ])); + default: + return _Utils_Tuple2( + _List_fromArray( + [ + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.any), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-top', 'auto'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-bottom', 'auto') + ])) + ]), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-top', 'auto !important'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-bottom', 'auto !important') + ])); + } + }) + ]); +var $mdgriffith$elm_ui$Internal$Style$gridAlignments = function (values) { + var createDescription = function (alignment) { + return _List_fromArray( + [ + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.any), + _List_fromArray( + [ + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$selfName( + $mdgriffith$elm_ui$Internal$Style$Self(alignment)), + values(alignment)) + ])) + ]); + }; + return $mdgriffith$elm_ui$Internal$Style$Batch( + A2($elm$core$List$concatMap, createDescription, $mdgriffith$elm_ui$Internal$Style$alignments)); +}; +var $mdgriffith$elm_ui$Internal$Style$Above = {$: 'Above'}; +var $mdgriffith$elm_ui$Internal$Style$Behind = {$: 'Behind'}; +var $mdgriffith$elm_ui$Internal$Style$Below = {$: 'Below'}; +var $mdgriffith$elm_ui$Internal$Style$OnLeft = {$: 'OnLeft'}; +var $mdgriffith$elm_ui$Internal$Style$OnRight = {$: 'OnRight'}; +var $mdgriffith$elm_ui$Internal$Style$Within = {$: 'Within'}; +var $mdgriffith$elm_ui$Internal$Style$locations = function () { + var loc = $mdgriffith$elm_ui$Internal$Style$Above; + var _v0 = function () { + switch (loc.$) { + case 'Above': + return _Utils_Tuple0; + case 'Below': + return _Utils_Tuple0; + case 'OnRight': + return _Utils_Tuple0; + case 'OnLeft': + return _Utils_Tuple0; + case 'Within': + return _Utils_Tuple0; + default: + return _Utils_Tuple0; + } + }(); + return _List_fromArray( + [$mdgriffith$elm_ui$Internal$Style$Above, $mdgriffith$elm_ui$Internal$Style$Below, $mdgriffith$elm_ui$Internal$Style$OnRight, $mdgriffith$elm_ui$Internal$Style$OnLeft, $mdgriffith$elm_ui$Internal$Style$Within, $mdgriffith$elm_ui$Internal$Style$Behind]); +}(); +var $mdgriffith$elm_ui$Internal$Style$baseSheet = _List_fromArray( + [ + A2( + $mdgriffith$elm_ui$Internal$Style$Class, + 'html,body', + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', '100%'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'padding', '0'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin', '0') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Class, + _Utils_ap( + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.any), + _Utils_ap( + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.single), + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.imageContainer))), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'block'), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.heightFill), + _List_fromArray( + [ + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + 'img', + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'max-height', '100%'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'object-fit', 'cover') + ])) + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.widthFill), + _List_fromArray( + [ + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + 'img', + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'max-width', '100%'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'object-fit', 'cover') + ])) + ])) + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Class, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.any) + ':focus', + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'outline', 'none') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Class, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.root), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', 'auto'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'min-height', '100%'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'z-index', '0'), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + _Utils_ap( + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.any), + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.heightFill)), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', '100%'), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.heightFill), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', '100%') + ])) + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.inFront), + _List_fromArray( + [ + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.nearby), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'position', 'fixed'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'z-index', '20') + ])) + ])) + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Class, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.nearby), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'position', 'relative'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'border', 'none'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'flex'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-direction', 'row'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-basis', 'auto'), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.single), + $mdgriffith$elm_ui$Internal$Style$elDescription), + $mdgriffith$elm_ui$Internal$Style$Batch( + function (fn) { + return A2($elm$core$List$map, fn, $mdgriffith$elm_ui$Internal$Style$locations); + }( + function (loc) { + switch (loc.$) { + case 'Above': + return A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.above), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'position', 'absolute'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'bottom', '100%'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'left', '0'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'z-index', '20'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin', '0 !important'), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.heightFill), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', 'auto') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.widthFill), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%') + ])), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'none'), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + '*', + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'auto') + ])) + ])); + case 'Below': + return A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.below), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'position', 'absolute'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'bottom', '0'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'left', '0'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', '0'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'z-index', '20'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin', '0 !important'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'none'), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + '*', + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'auto') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.heightFill), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', 'auto') + ])) + ])); + case 'OnRight': + return A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.onRight), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'position', 'absolute'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'left', '100%'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'top', '0'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', '100%'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin', '0 !important'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'z-index', '20'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'none'), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + '*', + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'auto') + ])) + ])); + case 'OnLeft': + return A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.onLeft), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'position', 'absolute'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'right', '100%'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'top', '0'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', '100%'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin', '0 !important'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'z-index', '20'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'none'), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + '*', + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'auto') + ])) + ])); + case 'Within': + return A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.inFront), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'position', 'absolute'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', '100%'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'left', '0'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'top', '0'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin', '0 !important'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'none'), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + '*', + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'auto') + ])) + ])); + default: + return A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.behind), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'position', 'absolute'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', '100%'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'left', '0'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'top', '0'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin', '0 !important'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'z-index', '0'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'none'), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + '*', + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'auto') + ])) + ])); + } + })) + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Class, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.any), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'position', 'relative'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'border', 'none'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-shrink', '0'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'flex'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-direction', 'row'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-basis', 'auto'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'resize', 'none'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-feature-settings', 'inherit'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'box-sizing', 'border-box'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin', '0'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'padding', '0'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'border-width', '0'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'border-style', 'solid'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-size', 'inherit'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'color', 'inherit'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-family', 'inherit'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'line-height', '1'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-weight', 'inherit'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-decoration', 'none'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-style', 'inherit'), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.wrapped), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-wrap', 'wrap') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.noTextSelection), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, '-moz-user-select', 'none'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, '-webkit-user-select', 'none'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, '-ms-user-select', 'none'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'user-select', 'none') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cursorPointer), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'cursor', 'pointer') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cursorText), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'cursor', 'text') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.passPointerEvents), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'none !important') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.capturePointerEvents), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'auto !important') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.transparent), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'opacity', '0') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.opaque), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'opacity', '1') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot( + _Utils_ap($mdgriffith$elm_ui$Internal$Style$classes.hover, $mdgriffith$elm_ui$Internal$Style$classes.transparent)) + ':hover', + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'opacity', '0') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot( + _Utils_ap($mdgriffith$elm_ui$Internal$Style$classes.hover, $mdgriffith$elm_ui$Internal$Style$classes.opaque)) + ':hover', + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'opacity', '1') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot( + _Utils_ap($mdgriffith$elm_ui$Internal$Style$classes.focus, $mdgriffith$elm_ui$Internal$Style$classes.transparent)) + ':focus', + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'opacity', '0') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot( + _Utils_ap($mdgriffith$elm_ui$Internal$Style$classes.focus, $mdgriffith$elm_ui$Internal$Style$classes.opaque)) + ':focus', + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'opacity', '1') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot( + _Utils_ap($mdgriffith$elm_ui$Internal$Style$classes.active, $mdgriffith$elm_ui$Internal$Style$classes.transparent)) + ':active', + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'opacity', '0') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot( + _Utils_ap($mdgriffith$elm_ui$Internal$Style$classes.active, $mdgriffith$elm_ui$Internal$Style$classes.opaque)) + ':active', + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'opacity', '1') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.transition), + _List_fromArray( + [ + A2( + $mdgriffith$elm_ui$Internal$Style$Prop, + 'transition', + A2( + $elm$core$String$join, + ', ', + A2( + $elm$core$List$map, + function (x) { + return x + ' 160ms'; + }, + _List_fromArray( + ['transform', 'opacity', 'filter', 'background-color', 'color', 'font-size'])))) + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.scrollbars), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'overflow', 'auto'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-shrink', '1') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.scrollbarsX), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'overflow-x', 'auto'), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.row), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-shrink', '1') + ])) + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.scrollbarsY), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'overflow-y', 'auto'), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.column), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-shrink', '1') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.single), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-shrink', '1') + ])) + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.clip), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'overflow', 'hidden') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.clipX), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'overflow-x', 'hidden') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.clipY), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'overflow-y', 'hidden') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.widthContent), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', 'auto') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.borderNone), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'border-width', '0') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.borderDashed), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'border-style', 'dashed') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.borderDotted), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'border-style', 'dotted') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.borderSolid), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'border-style', 'solid') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.text), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'white-space', 'pre'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'inline-block') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.inputText), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'line-height', '1.05'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'background', 'transparent'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-align', 'inherit') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.single), + $mdgriffith$elm_ui$Internal$Style$elDescription), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.row), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'flex'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-direction', 'row'), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.any), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-basis', '0%'), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.widthExact), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-basis', 'auto') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.link), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-basis', 'auto') + ])) + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.heightFill), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'stretch !important') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.heightFillPortion), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'stretch !important') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.widthFill), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '100000') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.container), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '0'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-basis', 'auto'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'stretch') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + 'u:first-of-type.' + $mdgriffith$elm_ui$Internal$Style$classes.alignContainerRight, + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '1') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + 's:first-of-type.' + $mdgriffith$elm_ui$Internal$Style$classes.alignContainerCenterX, + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '1'), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.alignCenterX), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-left', 'auto !important') + ])) + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + 's:last-of-type.' + $mdgriffith$elm_ui$Internal$Style$classes.alignContainerCenterX, + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '1'), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.alignCenterX), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-right', 'auto !important') + ])) + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + 's:only-of-type.' + $mdgriffith$elm_ui$Internal$Style$classes.alignContainerCenterX, + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '1'), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.alignCenterY), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-top', 'auto !important'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-bottom', 'auto !important') + ])) + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + 's:last-of-type.' + ($mdgriffith$elm_ui$Internal$Style$classes.alignContainerCenterX + ' ~ u'), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '0') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + 'u:first-of-type.' + ($mdgriffith$elm_ui$Internal$Style$classes.alignContainerRight + (' ~ s.' + $mdgriffith$elm_ui$Internal$Style$classes.alignContainerCenterX)), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '0') + ])), + $mdgriffith$elm_ui$Internal$Style$describeAlignment( + function (alignment) { + switch (alignment.$) { + case 'Top': + return _Utils_Tuple2( + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'flex-start') + ]), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'flex-start') + ])); + case 'Bottom': + return _Utils_Tuple2( + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'flex-end') + ]), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'flex-end') + ])); + case 'Right': + return _Utils_Tuple2( + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'flex-end') + ]), + _List_Nil); + case 'Left': + return _Utils_Tuple2( + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'flex-start') + ]), + _List_Nil); + case 'CenterX': + return _Utils_Tuple2( + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'center') + ]), + _List_Nil); + default: + return _Utils_Tuple2( + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'center') + ]), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'center') + ])); + } + }), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.spaceEvenly), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'space-between') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.inputLabel), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'baseline') + ])) + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.column), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'flex'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-direction', 'column'), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.any), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-basis', '0px'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'min-height', 'min-content'), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.heightExact), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-basis', 'auto') + ])) + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.heightFill), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '100000') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.widthFill), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.widthFillPortion), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.widthContent), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'flex-start') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + 'u:first-of-type.' + $mdgriffith$elm_ui$Internal$Style$classes.alignContainerBottom, + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '1') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + 's:first-of-type.' + $mdgriffith$elm_ui$Internal$Style$classes.alignContainerCenterY, + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '1'), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.alignCenterY), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-top', 'auto !important'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-bottom', '0 !important') + ])) + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + 's:last-of-type.' + $mdgriffith$elm_ui$Internal$Style$classes.alignContainerCenterY, + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '1'), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.alignCenterY), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-bottom', 'auto !important'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-top', '0 !important') + ])) + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + 's:only-of-type.' + $mdgriffith$elm_ui$Internal$Style$classes.alignContainerCenterY, + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '1'), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.alignCenterY), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-top', 'auto !important'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-bottom', 'auto !important') + ])) + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + 's:last-of-type.' + ($mdgriffith$elm_ui$Internal$Style$classes.alignContainerCenterY + ' ~ u'), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '0') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + 'u:first-of-type.' + ($mdgriffith$elm_ui$Internal$Style$classes.alignContainerBottom + (' ~ s.' + $mdgriffith$elm_ui$Internal$Style$classes.alignContainerCenterY)), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '0') + ])), + $mdgriffith$elm_ui$Internal$Style$describeAlignment( + function (alignment) { + switch (alignment.$) { + case 'Top': + return _Utils_Tuple2( + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'flex-start') + ]), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-bottom', 'auto') + ])); + case 'Bottom': + return _Utils_Tuple2( + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'flex-end') + ]), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-top', 'auto') + ])); + case 'Right': + return _Utils_Tuple2( + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'flex-end') + ]), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'flex-end') + ])); + case 'Left': + return _Utils_Tuple2( + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'flex-start') + ]), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'flex-start') + ])); + case 'CenterX': + return _Utils_Tuple2( + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'center') + ]), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'center') + ])); + default: + return _Utils_Tuple2( + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'center') + ]), + _List_Nil); + } + }), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.container), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '0'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-basis', 'auto'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'stretch !important') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.spaceEvenly), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'space-between') + ])) + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.grid), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', '-ms-grid'), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + '.gp', + _List_fromArray( + [ + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.any), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%') + ])) + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Supports, + _Utils_Tuple2('display', 'grid'), + _List_fromArray( + [ + _Utils_Tuple2('display', 'grid') + ])), + $mdgriffith$elm_ui$Internal$Style$gridAlignments( + function (alignment) { + switch (alignment.$) { + case 'Top': + return _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'flex-start') + ]); + case 'Bottom': + return _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'flex-end') + ]); + case 'Right': + return _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'flex-end') + ]); + case 'Left': + return _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'flex-start') + ]); + case 'CenterX': + return _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'center') + ]); + default: + return _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'center') + ]); + } + }) + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.page), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'block'), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.any + ':first-child'), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin', '0 !important') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot( + $mdgriffith$elm_ui$Internal$Style$classes.any + ($mdgriffith$elm_ui$Internal$Style$selfName( + $mdgriffith$elm_ui$Internal$Style$Self($mdgriffith$elm_ui$Internal$Style$Left)) + (':first-child + .' + $mdgriffith$elm_ui$Internal$Style$classes.any))), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin', '0 !important') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot( + $mdgriffith$elm_ui$Internal$Style$classes.any + ($mdgriffith$elm_ui$Internal$Style$selfName( + $mdgriffith$elm_ui$Internal$Style$Self($mdgriffith$elm_ui$Internal$Style$Right)) + (':first-child + .' + $mdgriffith$elm_ui$Internal$Style$classes.any))), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin', '0 !important') + ])), + $mdgriffith$elm_ui$Internal$Style$describeAlignment( + function (alignment) { + switch (alignment.$) { + case 'Top': + return _Utils_Tuple2(_List_Nil, _List_Nil); + case 'Bottom': + return _Utils_Tuple2(_List_Nil, _List_Nil); + case 'Right': + return _Utils_Tuple2( + _List_Nil, + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'float', 'right'), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + '::after', + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'content', '\"\"'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'table'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'clear', 'both') + ])) + ])); + case 'Left': + return _Utils_Tuple2( + _List_Nil, + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'float', 'left'), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + '::after', + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'content', '\"\"'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'table'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'clear', 'both') + ])) + ])); + case 'CenterX': + return _Utils_Tuple2(_List_Nil, _List_Nil); + default: + return _Utils_Tuple2(_List_Nil, _List_Nil); + } + }) + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.inputMultiline), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'white-space', 'pre-wrap !important'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', '100%'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'background-color', 'transparent') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.inputMultilineWrapper), + _List_fromArray( + [ + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.single), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-basis', 'auto') + ])) + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.inputMultilineParent), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'white-space', 'pre-wrap !important'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'cursor', 'text'), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.inputMultilineFiller), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'white-space', 'pre-wrap !important'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'color', 'transparent') + ])) + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.paragraph), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'block'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'white-space', 'normal'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'overflow-wrap', 'break-word'), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.hasBehind), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'z-index', '0'), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.behind), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'z-index', '-1') + ])) + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$AllChildren, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.text), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'inline'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'white-space', 'normal') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$AllChildren, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.paragraph), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'inline'), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + '::after', + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'content', 'none') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + '::before', + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'content', 'none') + ])) + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$AllChildren, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.single), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'inline'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'white-space', 'normal'), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.widthExact), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'inline-block') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.inFront), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'flex') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.behind), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'flex') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.above), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'flex') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.below), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'flex') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.onRight), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'flex') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.onLeft), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'flex') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.text), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'inline'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'white-space', 'normal') + ])) + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.row), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'inline') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.column), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'inline-flex') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Child, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.grid), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'inline-grid') + ])), + $mdgriffith$elm_ui$Internal$Style$describeAlignment( + function (alignment) { + switch (alignment.$) { + case 'Top': + return _Utils_Tuple2(_List_Nil, _List_Nil); + case 'Bottom': + return _Utils_Tuple2(_List_Nil, _List_Nil); + case 'Right': + return _Utils_Tuple2( + _List_Nil, + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'float', 'right') + ])); + case 'Left': + return _Utils_Tuple2( + _List_Nil, + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'float', 'left') + ])); + case 'CenterX': + return _Utils_Tuple2(_List_Nil, _List_Nil); + default: + return _Utils_Tuple2(_List_Nil, _List_Nil); + } + }) + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + '.hidden', + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'none') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.textThin), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-weight', '100') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.textExtraLight), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-weight', '200') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.textLight), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-weight', '300') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.textNormalWeight), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-weight', '400') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.textMedium), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-weight', '500') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.textSemiBold), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-weight', '600') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.bold), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-weight', '700') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.textExtraBold), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-weight', '800') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.textHeavy), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-weight', '900') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.italic), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-style', 'italic') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.strike), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-decoration', 'line-through') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.underline), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-decoration', 'underline'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-decoration-skip-ink', 'auto'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-decoration-skip', 'ink') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + _Utils_ap( + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.underline), + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.strike)), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-decoration', 'line-through underline'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-decoration-skip-ink', 'auto'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-decoration-skip', 'ink') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.textUnitalicized), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-style', 'normal') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.textJustify), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-align', 'justify') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.textJustifyAll), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-align', 'justify-all') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.textCenter), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-align', 'center') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.textRight), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-align', 'right') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.textLeft), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-align', 'left') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Descriptor, + '.modal', + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'position', 'fixed'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'left', '0'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'top', '0'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', '100%'), + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'none') + ])) + ])) + ]); +var $mdgriffith$elm_ui$Internal$Style$fontVariant = function (_var) { + return _List_fromArray( + [ + A2( + $mdgriffith$elm_ui$Internal$Style$Class, + '.v-' + _var, + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-feature-settings', '\"' + (_var + '\"')) + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Class, + '.v-' + (_var + '-off'), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-feature-settings', '\"' + (_var + '\" 0')) + ])) + ]); +}; +var $mdgriffith$elm_ui$Internal$Style$commonValues = $elm$core$List$concat( + _List_fromArray( + [ + A2( + $elm$core$List$map, + function (x) { + return A2( + $mdgriffith$elm_ui$Internal$Style$Class, + '.border-' + $elm$core$String$fromInt(x), + _List_fromArray( + [ + A2( + $mdgriffith$elm_ui$Internal$Style$Prop, + 'border-width', + $elm$core$String$fromInt(x) + 'px') + ])); + }, + A2($elm$core$List$range, 0, 6)), + A2( + $elm$core$List$map, + function (i) { + return A2( + $mdgriffith$elm_ui$Internal$Style$Class, + '.font-size-' + $elm$core$String$fromInt(i), + _List_fromArray( + [ + A2( + $mdgriffith$elm_ui$Internal$Style$Prop, + 'font-size', + $elm$core$String$fromInt(i) + 'px') + ])); + }, + A2($elm$core$List$range, 8, 32)), + A2( + $elm$core$List$map, + function (i) { + return A2( + $mdgriffith$elm_ui$Internal$Style$Class, + '.p-' + $elm$core$String$fromInt(i), + _List_fromArray( + [ + A2( + $mdgriffith$elm_ui$Internal$Style$Prop, + 'padding', + $elm$core$String$fromInt(i) + 'px') + ])); + }, + A2($elm$core$List$range, 0, 24)), + _List_fromArray( + [ + A2( + $mdgriffith$elm_ui$Internal$Style$Class, + '.v-smcp', + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-variant', 'small-caps') + ])), + A2( + $mdgriffith$elm_ui$Internal$Style$Class, + '.v-smcp-off', + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-variant', 'normal') + ])) + ]), + $mdgriffith$elm_ui$Internal$Style$fontVariant('zero'), + $mdgriffith$elm_ui$Internal$Style$fontVariant('onum'), + $mdgriffith$elm_ui$Internal$Style$fontVariant('liga'), + $mdgriffith$elm_ui$Internal$Style$fontVariant('dlig'), + $mdgriffith$elm_ui$Internal$Style$fontVariant('ordn'), + $mdgriffith$elm_ui$Internal$Style$fontVariant('tnum'), + $mdgriffith$elm_ui$Internal$Style$fontVariant('afrc'), + $mdgriffith$elm_ui$Internal$Style$fontVariant('frac') + ])); +var $mdgriffith$elm_ui$Internal$Style$explainer = '\n.explain {\n border: 6px solid rgb(174, 121, 15) !important;\n}\n.explain > .' + ($mdgriffith$elm_ui$Internal$Style$classes.any + (' {\n border: 4px dashed rgb(0, 151, 167) !important;\n}\n\n.ctr {\n border: none !important;\n}\n.explain > .ctr > .' + ($mdgriffith$elm_ui$Internal$Style$classes.any + ' {\n border: 4px dashed rgb(0, 151, 167) !important;\n}\n\n'))); +var $mdgriffith$elm_ui$Internal$Style$inputTextReset = '\ninput[type="search"],\ninput[type="search"]::-webkit-search-decoration,\ninput[type="search"]::-webkit-search-cancel-button,\ninput[type="search"]::-webkit-search-results-button,\ninput[type="search"]::-webkit-search-results-decoration {\n -webkit-appearance:none;\n}\n'; +var $mdgriffith$elm_ui$Internal$Style$sliderReset = '\ninput[type=range] {\n -webkit-appearance: none; \n background: transparent;\n position:absolute;\n left:0;\n top:0;\n z-index:10;\n width: 100%;\n outline: dashed 1px;\n height: 100%;\n opacity: 0;\n}\n'; +var $mdgriffith$elm_ui$Internal$Style$thumbReset = '\ninput[type=range]::-webkit-slider-thumb {\n -webkit-appearance: none;\n opacity: 0.5;\n width: 80px;\n height: 80px;\n background-color: black;\n border:none;\n border-radius: 5px;\n}\ninput[type=range]::-moz-range-thumb {\n opacity: 0.5;\n width: 80px;\n height: 80px;\n background-color: black;\n border:none;\n border-radius: 5px;\n}\ninput[type=range]::-ms-thumb {\n opacity: 0.5;\n width: 80px;\n height: 80px;\n background-color: black;\n border:none;\n border-radius: 5px;\n}\ninput[type=range][orient=vertical]{\n writing-mode: bt-lr; /* IE */\n -webkit-appearance: slider-vertical; /* WebKit */\n}\n'; +var $mdgriffith$elm_ui$Internal$Style$trackReset = '\ninput[type=range]::-moz-range-track {\n background: transparent;\n cursor: pointer;\n}\ninput[type=range]::-ms-track {\n background: transparent;\n cursor: pointer;\n}\ninput[type=range]::-webkit-slider-runnable-track {\n background: transparent;\n cursor: pointer;\n}\n'; +var $mdgriffith$elm_ui$Internal$Style$overrides = '@media screen and (-ms-high-contrast: active), (-ms-high-contrast: none) {' + ($mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.any) + ($mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.row) + (' > ' + ($mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.any) + (' { flex-basis: auto !important; } ' + ($mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.any) + ($mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.row) + (' > ' + ($mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.any) + ($mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.container) + (' { flex-basis: auto !important; }}' + ($mdgriffith$elm_ui$Internal$Style$inputTextReset + ($mdgriffith$elm_ui$Internal$Style$sliderReset + ($mdgriffith$elm_ui$Internal$Style$trackReset + ($mdgriffith$elm_ui$Internal$Style$thumbReset + $mdgriffith$elm_ui$Internal$Style$explainer))))))))))))))); +var $elm$core$String$concat = function (strings) { + return A2($elm$core$String$join, '', strings); +}; +var $mdgriffith$elm_ui$Internal$Style$Intermediate = function (a) { + return {$: 'Intermediate', a: a}; +}; +var $mdgriffith$elm_ui$Internal$Style$emptyIntermediate = F2( + function (selector, closing) { + return $mdgriffith$elm_ui$Internal$Style$Intermediate( + {closing: closing, others: _List_Nil, props: _List_Nil, selector: selector}); + }); +var $mdgriffith$elm_ui$Internal$Style$renderRules = F2( + function (_v0, rulesToRender) { + var parent = _v0.a; + var generateIntermediates = F2( + function (rule, rendered) { + switch (rule.$) { + case 'Prop': + var name = rule.a; + var val = rule.b; + return _Utils_update( + rendered, + { + props: A2( + $elm$core$List$cons, + _Utils_Tuple2(name, val), + rendered.props) + }); + case 'Supports': + var _v2 = rule.a; + var prop = _v2.a; + var value = _v2.b; + var props = rule.b; + return _Utils_update( + rendered, + { + others: A2( + $elm$core$List$cons, + $mdgriffith$elm_ui$Internal$Style$Intermediate( + {closing: '\n}', others: _List_Nil, props: props, selector: '@supports (' + (prop + (':' + (value + (') {' + parent.selector))))}), + rendered.others) + }); + case 'Adjacent': + var selector = rule.a; + var adjRules = rule.b; + return _Utils_update( + rendered, + { + others: A2( + $elm$core$List$cons, + A2( + $mdgriffith$elm_ui$Internal$Style$renderRules, + A2($mdgriffith$elm_ui$Internal$Style$emptyIntermediate, parent.selector + (' + ' + selector), ''), + adjRules), + rendered.others) + }); + case 'Child': + var child = rule.a; + var childRules = rule.b; + return _Utils_update( + rendered, + { + others: A2( + $elm$core$List$cons, + A2( + $mdgriffith$elm_ui$Internal$Style$renderRules, + A2($mdgriffith$elm_ui$Internal$Style$emptyIntermediate, parent.selector + (' > ' + child), ''), + childRules), + rendered.others) + }); + case 'AllChildren': + var child = rule.a; + var childRules = rule.b; + return _Utils_update( + rendered, + { + others: A2( + $elm$core$List$cons, + A2( + $mdgriffith$elm_ui$Internal$Style$renderRules, + A2($mdgriffith$elm_ui$Internal$Style$emptyIntermediate, parent.selector + (' ' + child), ''), + childRules), + rendered.others) + }); + case 'Descriptor': + var descriptor = rule.a; + var descriptorRules = rule.b; + return _Utils_update( + rendered, + { + others: A2( + $elm$core$List$cons, + A2( + $mdgriffith$elm_ui$Internal$Style$renderRules, + A2( + $mdgriffith$elm_ui$Internal$Style$emptyIntermediate, + _Utils_ap(parent.selector, descriptor), + ''), + descriptorRules), + rendered.others) + }); + default: + var batched = rule.a; + return _Utils_update( + rendered, + { + others: A2( + $elm$core$List$cons, + A2( + $mdgriffith$elm_ui$Internal$Style$renderRules, + A2($mdgriffith$elm_ui$Internal$Style$emptyIntermediate, parent.selector, ''), + batched), + rendered.others) + }); + } + }); + return $mdgriffith$elm_ui$Internal$Style$Intermediate( + A3($elm$core$List$foldr, generateIntermediates, parent, rulesToRender)); + }); +var $mdgriffith$elm_ui$Internal$Style$renderCompact = function (styleClasses) { + var renderValues = function (values) { + return $elm$core$String$concat( + A2( + $elm$core$List$map, + function (_v3) { + var x = _v3.a; + var y = _v3.b; + return x + (':' + (y + ';')); + }, + values)); + }; + var renderClass = function (rule) { + var _v2 = rule.props; + if (!_v2.b) { + return ''; + } else { + return rule.selector + ('{' + (renderValues(rule.props) + (rule.closing + '}'))); + } + }; + var renderIntermediate = function (_v0) { + var rule = _v0.a; + return _Utils_ap( + renderClass(rule), + $elm$core$String$concat( + A2($elm$core$List$map, renderIntermediate, rule.others))); + }; + return $elm$core$String$concat( + A2( + $elm$core$List$map, + renderIntermediate, + A3( + $elm$core$List$foldr, + F2( + function (_v1, existing) { + var name = _v1.a; + var styleRules = _v1.b; + return A2( + $elm$core$List$cons, + A2( + $mdgriffith$elm_ui$Internal$Style$renderRules, + A2($mdgriffith$elm_ui$Internal$Style$emptyIntermediate, name, ''), + styleRules), + existing); + }), + _List_Nil, + styleClasses))); +}; +var $mdgriffith$elm_ui$Internal$Style$rules = _Utils_ap( + $mdgriffith$elm_ui$Internal$Style$overrides, + $mdgriffith$elm_ui$Internal$Style$renderCompact( + _Utils_ap($mdgriffith$elm_ui$Internal$Style$baseSheet, $mdgriffith$elm_ui$Internal$Style$commonValues))); +var $elm$virtual_dom$VirtualDom$text = _VirtualDom_text; +var $mdgriffith$elm_ui$Internal$Model$staticRoot = function (opts) { + var _v0 = opts.mode; + switch (_v0.$) { + case 'Layout': + return A3( + $elm$virtual_dom$VirtualDom$node, + 'div', + _List_Nil, + _List_fromArray( + [ + A3( + $elm$virtual_dom$VirtualDom$node, + 'style', + _List_Nil, + _List_fromArray( + [ + $elm$virtual_dom$VirtualDom$text($mdgriffith$elm_ui$Internal$Style$rules) + ])) + ])); + case 'NoStaticStyleSheet': + return $elm$virtual_dom$VirtualDom$text(''); + default: + return A3( + $elm$virtual_dom$VirtualDom$node, + 'elm-ui-static-rules', + _List_fromArray( + [ + A2( + $elm$virtual_dom$VirtualDom$property, + 'rules', + $elm$json$Json$Encode$string($mdgriffith$elm_ui$Internal$Style$rules)) + ]), + _List_Nil); + } +}; +var $elm$json$Json$Encode$list = F2( + function (func, entries) { + return _Json_wrap( + A3( + $elm$core$List$foldl, + _Json_addEntry(func), + _Json_emptyArray(_Utils_Tuple0), + entries)); + }); +var $elm$json$Json$Encode$object = function (pairs) { + return _Json_wrap( + A3( + $elm$core$List$foldl, + F2( + function (_v0, obj) { + var k = _v0.a; + var v = _v0.b; + return A3(_Json_addField, k, v, obj); + }), + _Json_emptyObject(_Utils_Tuple0), + pairs)); +}; +var $elm$core$List$any = F2( + function (isOkay, list) { + any: + while (true) { + if (!list.b) { + return false; + } else { + var x = list.a; + var xs = list.b; + if (isOkay(x)) { + return true; + } else { + var $temp$isOkay = isOkay, + $temp$list = xs; + isOkay = $temp$isOkay; + list = $temp$list; + continue any; + } + } + } + }); +var $mdgriffith$elm_ui$Internal$Model$fontName = function (font) { + switch (font.$) { + case 'Serif': + return 'serif'; + case 'SansSerif': + return 'sans-serif'; + case 'Monospace': + return 'monospace'; + case 'Typeface': + var name = font.a; + return '\"' + (name + '\"'); + case 'ImportFont': + var name = font.a; + var url = font.b; + return '\"' + (name + '\"'); + default: + var name = font.a.name; + return '\"' + (name + '\"'); + } +}; +var $mdgriffith$elm_ui$Internal$Model$isSmallCaps = function (_var) { + switch (_var.$) { + case 'VariantActive': + var name = _var.a; + return name === 'smcp'; + case 'VariantOff': + var name = _var.a; + return false; + default: + var name = _var.a; + var index = _var.b; + return (name === 'smcp') && (index === 1); + } +}; +var $mdgriffith$elm_ui$Internal$Model$hasSmallCaps = function (typeface) { + if (typeface.$ === 'FontWith') { + var font = typeface.a; + return A2($elm$core$List$any, $mdgriffith$elm_ui$Internal$Model$isSmallCaps, font.variants); + } else { + return false; + } +}; +var $elm$core$Basics$min = F2( + function (x, y) { + return (_Utils_cmp(x, y) < 0) ? x : y; + }); +var $elm$core$Basics$negate = function (n) { + return -n; +}; +var $mdgriffith$elm_ui$Internal$Model$renderProps = F3( + function (force, _v0, existing) { + var key = _v0.a; + var val = _v0.b; + return force ? (existing + ('\n ' + (key + (': ' + (val + ' !important;'))))) : (existing + ('\n ' + (key + (': ' + (val + ';'))))); + }); +var $mdgriffith$elm_ui$Internal$Model$renderStyle = F4( + function (options, maybePseudo, selector, props) { + if (maybePseudo.$ === 'Nothing') { + return _List_fromArray( + [ + selector + ('{' + (A3( + $elm$core$List$foldl, + $mdgriffith$elm_ui$Internal$Model$renderProps(false), + '', + props) + '\n}')) + ]); + } else { + var pseudo = maybePseudo.a; + switch (pseudo.$) { + case 'Hover': + var _v2 = options.hover; + switch (_v2.$) { + case 'NoHover': + return _List_Nil; + case 'ForceHover': + return _List_fromArray( + [ + selector + ('-hv {' + (A3( + $elm$core$List$foldl, + $mdgriffith$elm_ui$Internal$Model$renderProps(true), + '', + props) + '\n}')) + ]); + default: + return _List_fromArray( + [ + selector + ('-hv:hover {' + (A3( + $elm$core$List$foldl, + $mdgriffith$elm_ui$Internal$Model$renderProps(false), + '', + props) + '\n}')) + ]); + } + case 'Focus': + var renderedProps = A3( + $elm$core$List$foldl, + $mdgriffith$elm_ui$Internal$Model$renderProps(false), + '', + props); + return _List_fromArray( + [ + selector + ('-fs:focus {' + (renderedProps + '\n}')), + ('.' + ($mdgriffith$elm_ui$Internal$Style$classes.any + (':focus ' + (selector + '-fs {')))) + (renderedProps + '\n}'), + (selector + '-fs:focus-within {') + (renderedProps + '\n}'), + ('.ui-slide-bar:focus + ' + ($mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.any) + (' .focusable-thumb' + (selector + '-fs {')))) + (renderedProps + '\n}') + ]); + default: + return _List_fromArray( + [ + selector + ('-act:active {' + (A3( + $elm$core$List$foldl, + $mdgriffith$elm_ui$Internal$Model$renderProps(false), + '', + props) + '\n}')) + ]); + } + } + }); +var $mdgriffith$elm_ui$Internal$Model$renderVariant = function (_var) { + switch (_var.$) { + case 'VariantActive': + var name = _var.a; + return '\"' + (name + '\"'); + case 'VariantOff': + var name = _var.a; + return '\"' + (name + '\" 0'); + default: + var name = _var.a; + var index = _var.b; + return '\"' + (name + ('\" ' + $elm$core$String$fromInt(index))); + } +}; +var $mdgriffith$elm_ui$Internal$Model$renderVariants = function (typeface) { + if (typeface.$ === 'FontWith') { + var font = typeface.a; + return $elm$core$Maybe$Just( + A2( + $elm$core$String$join, + ', ', + A2($elm$core$List$map, $mdgriffith$elm_ui$Internal$Model$renderVariant, font.variants))); + } else { + return $elm$core$Maybe$Nothing; + } +}; +var $mdgriffith$elm_ui$Internal$Model$transformValue = function (transform) { + switch (transform.$) { + case 'Untransformed': + return $elm$core$Maybe$Nothing; + case 'Moved': + var _v1 = transform.a; + var x = _v1.a; + var y = _v1.b; + var z = _v1.c; + return $elm$core$Maybe$Just( + 'translate3d(' + ($elm$core$String$fromFloat(x) + ('px, ' + ($elm$core$String$fromFloat(y) + ('px, ' + ($elm$core$String$fromFloat(z) + 'px)')))))); + default: + var _v2 = transform.a; + var tx = _v2.a; + var ty = _v2.b; + var tz = _v2.c; + var _v3 = transform.b; + var sx = _v3.a; + var sy = _v3.b; + var sz = _v3.c; + var _v4 = transform.c; + var ox = _v4.a; + var oy = _v4.b; + var oz = _v4.c; + var angle = transform.d; + var translate = 'translate3d(' + ($elm$core$String$fromFloat(tx) + ('px, ' + ($elm$core$String$fromFloat(ty) + ('px, ' + ($elm$core$String$fromFloat(tz) + 'px)'))))); + var scale = 'scale3d(' + ($elm$core$String$fromFloat(sx) + (', ' + ($elm$core$String$fromFloat(sy) + (', ' + ($elm$core$String$fromFloat(sz) + ')'))))); + var rotate = 'rotate3d(' + ($elm$core$String$fromFloat(ox) + (', ' + ($elm$core$String$fromFloat(oy) + (', ' + ($elm$core$String$fromFloat(oz) + (', ' + ($elm$core$String$fromFloat(angle) + 'rad)'))))))); + return $elm$core$Maybe$Just(translate + (' ' + (scale + (' ' + rotate)))); + } +}; +var $mdgriffith$elm_ui$Internal$Model$renderStyleRule = F3( + function (options, rule, maybePseudo) { + switch (rule.$) { + case 'Style': + var selector = rule.a; + var props = rule.b; + return A4($mdgriffith$elm_ui$Internal$Model$renderStyle, options, maybePseudo, selector, props); + case 'Shadows': + var name = rule.a; + var prop = rule.b; + return A4( + $mdgriffith$elm_ui$Internal$Model$renderStyle, + options, + maybePseudo, + '.' + name, + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Model$Property, 'box-shadow', prop) + ])); + case 'Transparency': + var name = rule.a; + var transparency = rule.b; + var opacity = A2( + $elm$core$Basics$max, + 0, + A2($elm$core$Basics$min, 1, 1 - transparency)); + return A4( + $mdgriffith$elm_ui$Internal$Model$renderStyle, + options, + maybePseudo, + '.' + name, + _List_fromArray( + [ + A2( + $mdgriffith$elm_ui$Internal$Model$Property, + 'opacity', + $elm$core$String$fromFloat(opacity)) + ])); + case 'FontSize': + var i = rule.a; + return A4( + $mdgriffith$elm_ui$Internal$Model$renderStyle, + options, + maybePseudo, + '.font-size-' + $elm$core$String$fromInt(i), + _List_fromArray( + [ + A2( + $mdgriffith$elm_ui$Internal$Model$Property, + 'font-size', + $elm$core$String$fromInt(i) + 'px') + ])); + case 'FontFamily': + var name = rule.a; + var typefaces = rule.b; + var features = A2( + $elm$core$String$join, + ', ', + A2($elm$core$List$filterMap, $mdgriffith$elm_ui$Internal$Model$renderVariants, typefaces)); + var families = _List_fromArray( + [ + A2( + $mdgriffith$elm_ui$Internal$Model$Property, + 'font-family', + A2( + $elm$core$String$join, + ', ', + A2($elm$core$List$map, $mdgriffith$elm_ui$Internal$Model$fontName, typefaces))), + A2($mdgriffith$elm_ui$Internal$Model$Property, 'font-feature-settings', features), + A2( + $mdgriffith$elm_ui$Internal$Model$Property, + 'font-variant', + A2($elm$core$List$any, $mdgriffith$elm_ui$Internal$Model$hasSmallCaps, typefaces) ? 'small-caps' : 'normal') + ]); + return A4($mdgriffith$elm_ui$Internal$Model$renderStyle, options, maybePseudo, '.' + name, families); + case 'Single': + var _class = rule.a; + var prop = rule.b; + var val = rule.c; + return A4( + $mdgriffith$elm_ui$Internal$Model$renderStyle, + options, + maybePseudo, + '.' + _class, + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Model$Property, prop, val) + ])); + case 'Colored': + var _class = rule.a; + var prop = rule.b; + var color = rule.c; + return A4( + $mdgriffith$elm_ui$Internal$Model$renderStyle, + options, + maybePseudo, + '.' + _class, + _List_fromArray( + [ + A2( + $mdgriffith$elm_ui$Internal$Model$Property, + prop, + $mdgriffith$elm_ui$Internal$Model$formatColor(color)) + ])); + case 'SpacingStyle': + var cls = rule.a; + var x = rule.b; + var y = rule.c; + var yPx = $elm$core$String$fromInt(y) + 'px'; + var xPx = $elm$core$String$fromInt(x) + 'px'; + var single = '.' + $mdgriffith$elm_ui$Internal$Style$classes.single; + var row = '.' + $mdgriffith$elm_ui$Internal$Style$classes.row; + var wrappedRow = '.' + ($mdgriffith$elm_ui$Internal$Style$classes.wrapped + row); + var right = '.' + $mdgriffith$elm_ui$Internal$Style$classes.alignRight; + var paragraph = '.' + $mdgriffith$elm_ui$Internal$Style$classes.paragraph; + var page = '.' + $mdgriffith$elm_ui$Internal$Style$classes.page; + var left = '.' + $mdgriffith$elm_ui$Internal$Style$classes.alignLeft; + var halfY = $elm$core$String$fromFloat(y / 2) + 'px'; + var halfX = $elm$core$String$fromFloat(x / 2) + 'px'; + var column = '.' + $mdgriffith$elm_ui$Internal$Style$classes.column; + var _class = '.' + cls; + var any = '.' + $mdgriffith$elm_ui$Internal$Style$classes.any; + return $elm$core$List$concat( + _List_fromArray( + [ + A4( + $mdgriffith$elm_ui$Internal$Model$renderStyle, + options, + maybePseudo, + _class + (row + (' > ' + (any + (' + ' + any)))), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Model$Property, 'margin-left', xPx) + ])), + A4( + $mdgriffith$elm_ui$Internal$Model$renderStyle, + options, + maybePseudo, + _class + (wrappedRow + (' > ' + any)), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Model$Property, 'margin', halfY + (' ' + halfX)) + ])), + A4( + $mdgriffith$elm_ui$Internal$Model$renderStyle, + options, + maybePseudo, + _class + (column + (' > ' + (any + (' + ' + any)))), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Model$Property, 'margin-top', yPx) + ])), + A4( + $mdgriffith$elm_ui$Internal$Model$renderStyle, + options, + maybePseudo, + _class + (page + (' > ' + (any + (' + ' + any)))), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Model$Property, 'margin-top', yPx) + ])), + A4( + $mdgriffith$elm_ui$Internal$Model$renderStyle, + options, + maybePseudo, + _class + (page + (' > ' + left)), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Model$Property, 'margin-right', xPx) + ])), + A4( + $mdgriffith$elm_ui$Internal$Model$renderStyle, + options, + maybePseudo, + _class + (page + (' > ' + right)), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Model$Property, 'margin-left', xPx) + ])), + A4( + $mdgriffith$elm_ui$Internal$Model$renderStyle, + options, + maybePseudo, + _Utils_ap(_class, paragraph), + _List_fromArray( + [ + A2( + $mdgriffith$elm_ui$Internal$Model$Property, + 'line-height', + 'calc(1em + ' + ($elm$core$String$fromInt(y) + 'px)')) + ])), + A4( + $mdgriffith$elm_ui$Internal$Model$renderStyle, + options, + maybePseudo, + 'textarea' + (any + _class), + _List_fromArray( + [ + A2( + $mdgriffith$elm_ui$Internal$Model$Property, + 'line-height', + 'calc(1em + ' + ($elm$core$String$fromInt(y) + 'px)')), + A2( + $mdgriffith$elm_ui$Internal$Model$Property, + 'height', + 'calc(100% + ' + ($elm$core$String$fromInt(y) + 'px)')) + ])), + A4( + $mdgriffith$elm_ui$Internal$Model$renderStyle, + options, + maybePseudo, + _class + (paragraph + (' > ' + left)), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Model$Property, 'margin-right', xPx) + ])), + A4( + $mdgriffith$elm_ui$Internal$Model$renderStyle, + options, + maybePseudo, + _class + (paragraph + (' > ' + right)), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Model$Property, 'margin-left', xPx) + ])), + A4( + $mdgriffith$elm_ui$Internal$Model$renderStyle, + options, + maybePseudo, + _class + (paragraph + '::after'), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Model$Property, 'content', '\'\''), + A2($mdgriffith$elm_ui$Internal$Model$Property, 'display', 'block'), + A2($mdgriffith$elm_ui$Internal$Model$Property, 'height', '0'), + A2($mdgriffith$elm_ui$Internal$Model$Property, 'width', '0'), + A2( + $mdgriffith$elm_ui$Internal$Model$Property, + 'margin-top', + $elm$core$String$fromInt((-1) * ((y / 2) | 0)) + 'px') + ])), + A4( + $mdgriffith$elm_ui$Internal$Model$renderStyle, + options, + maybePseudo, + _class + (paragraph + '::before'), + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Model$Property, 'content', '\'\''), + A2($mdgriffith$elm_ui$Internal$Model$Property, 'display', 'block'), + A2($mdgriffith$elm_ui$Internal$Model$Property, 'height', '0'), + A2($mdgriffith$elm_ui$Internal$Model$Property, 'width', '0'), + A2( + $mdgriffith$elm_ui$Internal$Model$Property, + 'margin-bottom', + $elm$core$String$fromInt((-1) * ((y / 2) | 0)) + 'px') + ])) + ])); + case 'PaddingStyle': + var cls = rule.a; + var top = rule.b; + var right = rule.c; + var bottom = rule.d; + var left = rule.e; + var _class = '.' + cls; + return A4( + $mdgriffith$elm_ui$Internal$Model$renderStyle, + options, + maybePseudo, + _class, + _List_fromArray( + [ + A2( + $mdgriffith$elm_ui$Internal$Model$Property, + 'padding', + $elm$core$String$fromFloat(top) + ('px ' + ($elm$core$String$fromFloat(right) + ('px ' + ($elm$core$String$fromFloat(bottom) + ('px ' + ($elm$core$String$fromFloat(left) + 'px'))))))) + ])); + case 'BorderWidth': + var cls = rule.a; + var top = rule.b; + var right = rule.c; + var bottom = rule.d; + var left = rule.e; + var _class = '.' + cls; + return A4( + $mdgriffith$elm_ui$Internal$Model$renderStyle, + options, + maybePseudo, + _class, + _List_fromArray( + [ + A2( + $mdgriffith$elm_ui$Internal$Model$Property, + 'border-width', + $elm$core$String$fromInt(top) + ('px ' + ($elm$core$String$fromInt(right) + ('px ' + ($elm$core$String$fromInt(bottom) + ('px ' + ($elm$core$String$fromInt(left) + 'px'))))))) + ])); + case 'GridTemplateStyle': + var template = rule.a; + var toGridLengthHelper = F3( + function (minimum, maximum, x) { + toGridLengthHelper: + while (true) { + switch (x.$) { + case 'Px': + var px = x.a; + return $elm$core$String$fromInt(px) + 'px'; + case 'Content': + var _v2 = _Utils_Tuple2(minimum, maximum); + if (_v2.a.$ === 'Nothing') { + if (_v2.b.$ === 'Nothing') { + var _v3 = _v2.a; + var _v4 = _v2.b; + return 'max-content'; + } else { + var _v6 = _v2.a; + var maxSize = _v2.b.a; + return 'minmax(max-content, ' + ($elm$core$String$fromInt(maxSize) + 'px)'); + } + } else { + if (_v2.b.$ === 'Nothing') { + var minSize = _v2.a.a; + var _v5 = _v2.b; + return 'minmax(' + ($elm$core$String$fromInt(minSize) + ('px, ' + 'max-content)')); + } else { + var minSize = _v2.a.a; + var maxSize = _v2.b.a; + return 'minmax(' + ($elm$core$String$fromInt(minSize) + ('px, ' + ($elm$core$String$fromInt(maxSize) + 'px)'))); + } + } + case 'Fill': + var i = x.a; + var _v7 = _Utils_Tuple2(minimum, maximum); + if (_v7.a.$ === 'Nothing') { + if (_v7.b.$ === 'Nothing') { + var _v8 = _v7.a; + var _v9 = _v7.b; + return $elm$core$String$fromInt(i) + 'fr'; + } else { + var _v11 = _v7.a; + var maxSize = _v7.b.a; + return 'minmax(max-content, ' + ($elm$core$String$fromInt(maxSize) + 'px)'); + } + } else { + if (_v7.b.$ === 'Nothing') { + var minSize = _v7.a.a; + var _v10 = _v7.b; + return 'minmax(' + ($elm$core$String$fromInt(minSize) + ('px, ' + ($elm$core$String$fromInt(i) + ('fr' + 'fr)')))); + } else { + var minSize = _v7.a.a; + var maxSize = _v7.b.a; + return 'minmax(' + ($elm$core$String$fromInt(minSize) + ('px, ' + ($elm$core$String$fromInt(maxSize) + 'px)'))); + } + } + case 'Min': + var m = x.a; + var len = x.b; + var $temp$minimum = $elm$core$Maybe$Just(m), + $temp$maximum = maximum, + $temp$x = len; + minimum = $temp$minimum; + maximum = $temp$maximum; + x = $temp$x; + continue toGridLengthHelper; + default: + var m = x.a; + var len = x.b; + var $temp$minimum = minimum, + $temp$maximum = $elm$core$Maybe$Just(m), + $temp$x = len; + minimum = $temp$minimum; + maximum = $temp$maximum; + x = $temp$x; + continue toGridLengthHelper; + } + } + }); + var toGridLength = function (x) { + return A3(toGridLengthHelper, $elm$core$Maybe$Nothing, $elm$core$Maybe$Nothing, x); + }; + var xSpacing = toGridLength(template.spacing.a); + var ySpacing = toGridLength(template.spacing.b); + var rows = function (x) { + return 'grid-template-rows: ' + (x + ';'); + }( + A2( + $elm$core$String$join, + ' ', + A2($elm$core$List$map, toGridLength, template.rows))); + var msRows = function (x) { + return '-ms-grid-rows: ' + (x + ';'); + }( + A2( + $elm$core$String$join, + ySpacing, + A2($elm$core$List$map, toGridLength, template.columns))); + var msColumns = function (x) { + return '-ms-grid-columns: ' + (x + ';'); + }( + A2( + $elm$core$String$join, + ySpacing, + A2($elm$core$List$map, toGridLength, template.columns))); + var gapY = 'grid-row-gap:' + (toGridLength(template.spacing.b) + ';'); + var gapX = 'grid-column-gap:' + (toGridLength(template.spacing.a) + ';'); + var columns = function (x) { + return 'grid-template-columns: ' + (x + ';'); + }( + A2( + $elm$core$String$join, + ' ', + A2($elm$core$List$map, toGridLength, template.columns))); + var _class = '.grid-rows-' + (A2( + $elm$core$String$join, + '-', + A2($elm$core$List$map, $mdgriffith$elm_ui$Internal$Model$lengthClassName, template.rows)) + ('-cols-' + (A2( + $elm$core$String$join, + '-', + A2($elm$core$List$map, $mdgriffith$elm_ui$Internal$Model$lengthClassName, template.columns)) + ('-space-x-' + ($mdgriffith$elm_ui$Internal$Model$lengthClassName(template.spacing.a) + ('-space-y-' + $mdgriffith$elm_ui$Internal$Model$lengthClassName(template.spacing.b))))))); + var modernGrid = _class + ('{' + (columns + (rows + (gapX + (gapY + '}'))))); + var supports = '@supports (display:grid) {' + (modernGrid + '}'); + var base = _class + ('{' + (msColumns + (msRows + '}'))); + return _List_fromArray( + [base, supports]); + case 'GridPosition': + var position = rule.a; + var msPosition = A2( + $elm$core$String$join, + ' ', + _List_fromArray( + [ + '-ms-grid-row: ' + ($elm$core$String$fromInt(position.row) + ';'), + '-ms-grid-row-span: ' + ($elm$core$String$fromInt(position.height) + ';'), + '-ms-grid-column: ' + ($elm$core$String$fromInt(position.col) + ';'), + '-ms-grid-column-span: ' + ($elm$core$String$fromInt(position.width) + ';') + ])); + var modernPosition = A2( + $elm$core$String$join, + ' ', + _List_fromArray( + [ + 'grid-row: ' + ($elm$core$String$fromInt(position.row) + (' / ' + ($elm$core$String$fromInt(position.row + position.height) + ';'))), + 'grid-column: ' + ($elm$core$String$fromInt(position.col) + (' / ' + ($elm$core$String$fromInt(position.col + position.width) + ';'))) + ])); + var _class = '.grid-pos-' + ($elm$core$String$fromInt(position.row) + ('-' + ($elm$core$String$fromInt(position.col) + ('-' + ($elm$core$String$fromInt(position.width) + ('-' + $elm$core$String$fromInt(position.height))))))); + var modernGrid = _class + ('{' + (modernPosition + '}')); + var supports = '@supports (display:grid) {' + (modernGrid + '}'); + var base = _class + ('{' + (msPosition + '}')); + return _List_fromArray( + [base, supports]); + case 'PseudoSelector': + var _class = rule.a; + var styles = rule.b; + var renderPseudoRule = function (style) { + return A3( + $mdgriffith$elm_ui$Internal$Model$renderStyleRule, + options, + style, + $elm$core$Maybe$Just(_class)); + }; + return A2($elm$core$List$concatMap, renderPseudoRule, styles); + default: + var transform = rule.a; + var val = $mdgriffith$elm_ui$Internal$Model$transformValue(transform); + var _class = $mdgriffith$elm_ui$Internal$Model$transformClass(transform); + var _v12 = _Utils_Tuple2(_class, val); + if ((_v12.a.$ === 'Just') && (_v12.b.$ === 'Just')) { + var cls = _v12.a.a; + var v = _v12.b.a; + return A4( + $mdgriffith$elm_ui$Internal$Model$renderStyle, + options, + maybePseudo, + '.' + cls, + _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Model$Property, 'transform', v) + ])); + } else { + return _List_Nil; + } + } + }); +var $mdgriffith$elm_ui$Internal$Model$encodeStyles = F2( + function (options, stylesheet) { + return $elm$json$Json$Encode$object( + A2( + $elm$core$List$map, + function (style) { + var styled = A3($mdgriffith$elm_ui$Internal$Model$renderStyleRule, options, style, $elm$core$Maybe$Nothing); + return _Utils_Tuple2( + $mdgriffith$elm_ui$Internal$Model$getStyleName(style), + A2($elm$json$Json$Encode$list, $elm$json$Json$Encode$string, styled)); + }, + stylesheet)); + }); +var $mdgriffith$elm_ui$Internal$Model$bracket = F2( + function (selector, rules) { + var renderPair = function (_v0) { + var name = _v0.a; + var val = _v0.b; + return name + (': ' + (val + ';')); + }; + return selector + (' {' + (A2( + $elm$core$String$join, + '', + A2($elm$core$List$map, renderPair, rules)) + '}')); + }); +var $mdgriffith$elm_ui$Internal$Model$fontRule = F3( + function (name, modifier, _v0) { + var parentAdj = _v0.a; + var textAdjustment = _v0.b; + return _List_fromArray( + [ + A2($mdgriffith$elm_ui$Internal$Model$bracket, '.' + (name + ('.' + (modifier + (', ' + ('.' + (name + (' .' + modifier))))))), parentAdj), + A2($mdgriffith$elm_ui$Internal$Model$bracket, '.' + (name + ('.' + (modifier + ('> .' + ($mdgriffith$elm_ui$Internal$Style$classes.text + (', .' + (name + (' .' + (modifier + (' > .' + $mdgriffith$elm_ui$Internal$Style$classes.text)))))))))), textAdjustment) + ]); + }); +var $mdgriffith$elm_ui$Internal$Model$renderFontAdjustmentRule = F3( + function (fontToAdjust, _v0, otherFontName) { + var full = _v0.a; + var capital = _v0.b; + var name = _Utils_eq(fontToAdjust, otherFontName) ? fontToAdjust : (otherFontName + (' .' + fontToAdjust)); + return A2( + $elm$core$String$join, + ' ', + _Utils_ap( + A3($mdgriffith$elm_ui$Internal$Model$fontRule, name, $mdgriffith$elm_ui$Internal$Style$classes.sizeByCapital, capital), + A3($mdgriffith$elm_ui$Internal$Model$fontRule, name, $mdgriffith$elm_ui$Internal$Style$classes.fullSize, full))); + }); +var $mdgriffith$elm_ui$Internal$Model$renderNullAdjustmentRule = F2( + function (fontToAdjust, otherFontName) { + var name = _Utils_eq(fontToAdjust, otherFontName) ? fontToAdjust : (otherFontName + (' .' + fontToAdjust)); + return A2( + $elm$core$String$join, + ' ', + _List_fromArray( + [ + A2( + $mdgriffith$elm_ui$Internal$Model$bracket, + '.' + (name + ('.' + ($mdgriffith$elm_ui$Internal$Style$classes.sizeByCapital + (', ' + ('.' + (name + (' .' + $mdgriffith$elm_ui$Internal$Style$classes.sizeByCapital))))))), + _List_fromArray( + [ + _Utils_Tuple2('line-height', '1') + ])), + A2( + $mdgriffith$elm_ui$Internal$Model$bracket, + '.' + (name + ('.' + ($mdgriffith$elm_ui$Internal$Style$classes.sizeByCapital + ('> .' + ($mdgriffith$elm_ui$Internal$Style$classes.text + (', .' + (name + (' .' + ($mdgriffith$elm_ui$Internal$Style$classes.sizeByCapital + (' > .' + $mdgriffith$elm_ui$Internal$Style$classes.text)))))))))), + _List_fromArray( + [ + _Utils_Tuple2('vertical-align', '0'), + _Utils_Tuple2('line-height', '1') + ])) + ])); + }); +var $mdgriffith$elm_ui$Internal$Model$adjust = F3( + function (size, height, vertical) { + return {height: height / size, size: size, vertical: vertical}; + }); +var $elm$core$List$filter = F2( + function (isGood, list) { + return A3( + $elm$core$List$foldr, + F2( + function (x, xs) { + return isGood(x) ? A2($elm$core$List$cons, x, xs) : xs; + }), + _List_Nil, + list); + }); +var $elm$core$List$maximum = function (list) { + if (list.b) { + var x = list.a; + var xs = list.b; + return $elm$core$Maybe$Just( + A3($elm$core$List$foldl, $elm$core$Basics$max, x, xs)); + } else { + return $elm$core$Maybe$Nothing; + } +}; +var $elm$core$List$minimum = function (list) { + if (list.b) { + var x = list.a; + var xs = list.b; + return $elm$core$Maybe$Just( + A3($elm$core$List$foldl, $elm$core$Basics$min, x, xs)); + } else { + return $elm$core$Maybe$Nothing; + } +}; +var $elm$core$Basics$neq = _Utils_notEqual; +var $mdgriffith$elm_ui$Internal$Model$convertAdjustment = function (adjustment) { + var lines = _List_fromArray( + [adjustment.capital, adjustment.baseline, adjustment.descender, adjustment.lowercase]); + var lineHeight = 1.5; + var normalDescender = (lineHeight - 1) / 2; + var oldMiddle = lineHeight / 2; + var descender = A2( + $elm$core$Maybe$withDefault, + adjustment.descender, + $elm$core$List$minimum(lines)); + var newBaseline = A2( + $elm$core$Maybe$withDefault, + adjustment.baseline, + $elm$core$List$minimum( + A2( + $elm$core$List$filter, + function (x) { + return !_Utils_eq(x, descender); + }, + lines))); + var base = lineHeight; + var ascender = A2( + $elm$core$Maybe$withDefault, + adjustment.capital, + $elm$core$List$maximum(lines)); + var capitalSize = 1 / (ascender - newBaseline); + var capitalVertical = 1 - ascender; + var fullSize = 1 / (ascender - descender); + var fullVertical = 1 - ascender; + var newCapitalMiddle = ((ascender - newBaseline) / 2) + newBaseline; + var newFullMiddle = ((ascender - descender) / 2) + descender; + return { + capital: A3($mdgriffith$elm_ui$Internal$Model$adjust, capitalSize, ascender - newBaseline, capitalVertical), + full: A3($mdgriffith$elm_ui$Internal$Model$adjust, fullSize, ascender - descender, fullVertical) + }; +}; +var $mdgriffith$elm_ui$Internal$Model$fontAdjustmentRules = function (converted) { + return _Utils_Tuple2( + _List_fromArray( + [ + _Utils_Tuple2('display', 'block') + ]), + _List_fromArray( + [ + _Utils_Tuple2('display', 'inline-block'), + _Utils_Tuple2( + 'line-height', + $elm$core$String$fromFloat(converted.height)), + _Utils_Tuple2( + 'vertical-align', + $elm$core$String$fromFloat(converted.vertical) + 'em'), + _Utils_Tuple2( + 'font-size', + $elm$core$String$fromFloat(converted.size) + 'em') + ])); +}; +var $mdgriffith$elm_ui$Internal$Model$typefaceAdjustment = function (typefaces) { + return A3( + $elm$core$List$foldl, + F2( + function (face, found) { + if (found.$ === 'Nothing') { + if (face.$ === 'FontWith') { + var _with = face.a; + var _v2 = _with.adjustment; + if (_v2.$ === 'Nothing') { + return found; + } else { + var adjustment = _v2.a; + return $elm$core$Maybe$Just( + _Utils_Tuple2( + $mdgriffith$elm_ui$Internal$Model$fontAdjustmentRules( + function ($) { + return $.full; + }( + $mdgriffith$elm_ui$Internal$Model$convertAdjustment(adjustment))), + $mdgriffith$elm_ui$Internal$Model$fontAdjustmentRules( + function ($) { + return $.capital; + }( + $mdgriffith$elm_ui$Internal$Model$convertAdjustment(adjustment))))); + } + } else { + return found; + } + } else { + return found; + } + }), + $elm$core$Maybe$Nothing, + typefaces); +}; +var $mdgriffith$elm_ui$Internal$Model$renderTopLevelValues = function (rules) { + var withImport = function (font) { + if (font.$ === 'ImportFont') { + var url = font.b; + return $elm$core$Maybe$Just('@import url(\'' + (url + '\');')); + } else { + return $elm$core$Maybe$Nothing; + } + }; + var fontImports = function (_v2) { + var name = _v2.a; + var typefaces = _v2.b; + var imports = A2( + $elm$core$String$join, + '\n', + A2($elm$core$List$filterMap, withImport, typefaces)); + return imports; + }; + var allNames = A2($elm$core$List$map, $elm$core$Tuple$first, rules); + var fontAdjustments = function (_v1) { + var name = _v1.a; + var typefaces = _v1.b; + var _v0 = $mdgriffith$elm_ui$Internal$Model$typefaceAdjustment(typefaces); + if (_v0.$ === 'Nothing') { + return A2( + $elm$core$String$join, + '', + A2( + $elm$core$List$map, + $mdgriffith$elm_ui$Internal$Model$renderNullAdjustmentRule(name), + allNames)); + } else { + var adjustment = _v0.a; + return A2( + $elm$core$String$join, + '', + A2( + $elm$core$List$map, + A2($mdgriffith$elm_ui$Internal$Model$renderFontAdjustmentRule, name, adjustment), + allNames)); + } + }; + return _Utils_ap( + A2( + $elm$core$String$join, + '\n', + A2($elm$core$List$map, fontImports, rules)), + A2( + $elm$core$String$join, + '\n', + A2($elm$core$List$map, fontAdjustments, rules))); +}; +var $mdgriffith$elm_ui$Internal$Model$topLevelValue = function (rule) { + if (rule.$ === 'FontFamily') { + var name = rule.a; + var typefaces = rule.b; + return $elm$core$Maybe$Just( + _Utils_Tuple2(name, typefaces)); + } else { + return $elm$core$Maybe$Nothing; + } +}; +var $mdgriffith$elm_ui$Internal$Model$toStyleSheetString = F2( + function (options, stylesheet) { + var combine = F2( + function (style, rendered) { + return { + rules: _Utils_ap( + rendered.rules, + A3($mdgriffith$elm_ui$Internal$Model$renderStyleRule, options, style, $elm$core$Maybe$Nothing)), + topLevel: function () { + var _v1 = $mdgriffith$elm_ui$Internal$Model$topLevelValue(style); + if (_v1.$ === 'Nothing') { + return rendered.topLevel; + } else { + var topLevel = _v1.a; + return A2($elm$core$List$cons, topLevel, rendered.topLevel); + } + }() + }; + }); + var _v0 = A3( + $elm$core$List$foldl, + combine, + {rules: _List_Nil, topLevel: _List_Nil}, + stylesheet); + var rules = _v0.rules; + var topLevel = _v0.topLevel; + return _Utils_ap( + $mdgriffith$elm_ui$Internal$Model$renderTopLevelValues(topLevel), + $elm$core$String$concat(rules)); + }); +var $mdgriffith$elm_ui$Internal$Model$toStyleSheet = F2( + function (options, styleSheet) { + var _v0 = options.mode; + switch (_v0.$) { + case 'Layout': + return A3( + $elm$virtual_dom$VirtualDom$node, + 'div', + _List_Nil, + _List_fromArray( + [ + A3( + $elm$virtual_dom$VirtualDom$node, + 'style', + _List_Nil, + _List_fromArray( + [ + $elm$virtual_dom$VirtualDom$text( + A2($mdgriffith$elm_ui$Internal$Model$toStyleSheetString, options, styleSheet)) + ])) + ])); + case 'NoStaticStyleSheet': + return A3( + $elm$virtual_dom$VirtualDom$node, + 'div', + _List_Nil, + _List_fromArray( + [ + A3( + $elm$virtual_dom$VirtualDom$node, + 'style', + _List_Nil, + _List_fromArray( + [ + $elm$virtual_dom$VirtualDom$text( + A2($mdgriffith$elm_ui$Internal$Model$toStyleSheetString, options, styleSheet)) + ])) + ])); + default: + return A3( + $elm$virtual_dom$VirtualDom$node, + 'elm-ui-rules', + _List_fromArray( + [ + A2( + $elm$virtual_dom$VirtualDom$property, + 'rules', + A2($mdgriffith$elm_ui$Internal$Model$encodeStyles, options, styleSheet)) + ]), + _List_Nil); + } + }); +var $mdgriffith$elm_ui$Internal$Model$embedKeyed = F4( + function (_static, opts, styles, children) { + var dynamicStyleSheet = A2( + $mdgriffith$elm_ui$Internal$Model$toStyleSheet, + opts, + A3( + $elm$core$List$foldl, + $mdgriffith$elm_ui$Internal$Model$reduceStyles, + _Utils_Tuple2( + $elm$core$Set$empty, + $mdgriffith$elm_ui$Internal$Model$renderFocusStyle(opts.focus)), + styles).b); + return _static ? A2( + $elm$core$List$cons, + _Utils_Tuple2( + 'static-stylesheet', + $mdgriffith$elm_ui$Internal$Model$staticRoot(opts)), + A2( + $elm$core$List$cons, + _Utils_Tuple2('dynamic-stylesheet', dynamicStyleSheet), + children)) : A2( + $elm$core$List$cons, + _Utils_Tuple2('dynamic-stylesheet', dynamicStyleSheet), + children); + }); +var $mdgriffith$elm_ui$Internal$Model$embedWith = F4( + function (_static, opts, styles, children) { + var dynamicStyleSheet = A2( + $mdgriffith$elm_ui$Internal$Model$toStyleSheet, + opts, + A3( + $elm$core$List$foldl, + $mdgriffith$elm_ui$Internal$Model$reduceStyles, + _Utils_Tuple2( + $elm$core$Set$empty, + $mdgriffith$elm_ui$Internal$Model$renderFocusStyle(opts.focus)), + styles).b); + return _static ? A2( + $elm$core$List$cons, + $mdgriffith$elm_ui$Internal$Model$staticRoot(opts), + A2($elm$core$List$cons, dynamicStyleSheet, children)) : A2($elm$core$List$cons, dynamicStyleSheet, children); + }); +var $mdgriffith$elm_ui$Internal$Flag$heightBetween = $mdgriffith$elm_ui$Internal$Flag$flag(45); +var $mdgriffith$elm_ui$Internal$Flag$heightFill = $mdgriffith$elm_ui$Internal$Flag$flag(37); +var $elm$virtual_dom$VirtualDom$keyedNode = function (tag) { + return _VirtualDom_keyedNode( + _VirtualDom_noScript(tag)); +}; +var $elm$core$Basics$not = _Basics_not; +var $elm$html$Html$p = _VirtualDom_node('p'); +var $elm$core$Bitwise$and = _Bitwise_and; +var $mdgriffith$elm_ui$Internal$Flag$present = F2( + function (myFlag, _v0) { + var fieldOne = _v0.a; + var fieldTwo = _v0.b; + if (myFlag.$ === 'Flag') { + var first = myFlag.a; + return _Utils_eq(first & fieldOne, first); + } else { + var second = myFlag.a; + return _Utils_eq(second & fieldTwo, second); + } + }); +var $elm$html$Html$s = _VirtualDom_node('s'); +var $elm$html$Html$u = _VirtualDom_node('u'); +var $mdgriffith$elm_ui$Internal$Flag$widthBetween = $mdgriffith$elm_ui$Internal$Flag$flag(44); +var $mdgriffith$elm_ui$Internal$Flag$widthFill = $mdgriffith$elm_ui$Internal$Flag$flag(39); +var $mdgriffith$elm_ui$Internal$Model$finalizeNode = F6( + function (has, node, attributes, children, embedMode, parentContext) { + var createNode = F2( + function (nodeName, attrs) { + if (children.$ === 'Keyed') { + var keyed = children.a; + return A3( + $elm$virtual_dom$VirtualDom$keyedNode, + nodeName, + attrs, + function () { + switch (embedMode.$) { + case 'NoStyleSheet': + return keyed; + case 'OnlyDynamic': + var opts = embedMode.a; + var styles = embedMode.b; + return A4($mdgriffith$elm_ui$Internal$Model$embedKeyed, false, opts, styles, keyed); + default: + var opts = embedMode.a; + var styles = embedMode.b; + return A4($mdgriffith$elm_ui$Internal$Model$embedKeyed, true, opts, styles, keyed); + } + }()); + } else { + var unkeyed = children.a; + return A2( + function () { + switch (nodeName) { + case 'div': + return $elm$html$Html$div; + case 'p': + return $elm$html$Html$p; + default: + return $elm$virtual_dom$VirtualDom$node(nodeName); + } + }(), + attrs, + function () { + switch (embedMode.$) { + case 'NoStyleSheet': + return unkeyed; + case 'OnlyDynamic': + var opts = embedMode.a; + var styles = embedMode.b; + return A4($mdgriffith$elm_ui$Internal$Model$embedWith, false, opts, styles, unkeyed); + default: + var opts = embedMode.a; + var styles = embedMode.b; + return A4($mdgriffith$elm_ui$Internal$Model$embedWith, true, opts, styles, unkeyed); + } + }()); + } + }); + var html = function () { + switch (node.$) { + case 'Generic': + return A2(createNode, 'div', attributes); + case 'NodeName': + var nodeName = node.a; + return A2(createNode, nodeName, attributes); + default: + var nodeName = node.a; + var internal = node.b; + return A3( + $elm$virtual_dom$VirtualDom$node, + nodeName, + attributes, + _List_fromArray( + [ + A2( + createNode, + internal, + _List_fromArray( + [ + $elm$html$Html$Attributes$class($mdgriffith$elm_ui$Internal$Style$classes.any + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.single)) + ])) + ])); + } + }(); + switch (parentContext.$) { + case 'AsRow': + return (A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$widthFill, has) && (!A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$widthBetween, has))) ? html : (A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$alignRight, has) ? A2( + $elm$html$Html$u, + _List_fromArray( + [ + $elm$html$Html$Attributes$class( + A2( + $elm$core$String$join, + ' ', + _List_fromArray( + [$mdgriffith$elm_ui$Internal$Style$classes.any, $mdgriffith$elm_ui$Internal$Style$classes.single, $mdgriffith$elm_ui$Internal$Style$classes.container, $mdgriffith$elm_ui$Internal$Style$classes.contentCenterY, $mdgriffith$elm_ui$Internal$Style$classes.alignContainerRight]))) + ]), + _List_fromArray( + [html])) : (A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$centerX, has) ? A2( + $elm$html$Html$s, + _List_fromArray( + [ + $elm$html$Html$Attributes$class( + A2( + $elm$core$String$join, + ' ', + _List_fromArray( + [$mdgriffith$elm_ui$Internal$Style$classes.any, $mdgriffith$elm_ui$Internal$Style$classes.single, $mdgriffith$elm_ui$Internal$Style$classes.container, $mdgriffith$elm_ui$Internal$Style$classes.contentCenterY, $mdgriffith$elm_ui$Internal$Style$classes.alignContainerCenterX]))) + ]), + _List_fromArray( + [html])) : html)); + case 'AsColumn': + return (A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$heightFill, has) && (!A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$heightBetween, has))) ? html : (A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$centerY, has) ? A2( + $elm$html$Html$s, + _List_fromArray( + [ + $elm$html$Html$Attributes$class( + A2( + $elm$core$String$join, + ' ', + _List_fromArray( + [$mdgriffith$elm_ui$Internal$Style$classes.any, $mdgriffith$elm_ui$Internal$Style$classes.single, $mdgriffith$elm_ui$Internal$Style$classes.container, $mdgriffith$elm_ui$Internal$Style$classes.alignContainerCenterY]))) + ]), + _List_fromArray( + [html])) : (A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$alignBottom, has) ? A2( + $elm$html$Html$u, + _List_fromArray( + [ + $elm$html$Html$Attributes$class( + A2( + $elm$core$String$join, + ' ', + _List_fromArray( + [$mdgriffith$elm_ui$Internal$Style$classes.any, $mdgriffith$elm_ui$Internal$Style$classes.single, $mdgriffith$elm_ui$Internal$Style$classes.container, $mdgriffith$elm_ui$Internal$Style$classes.alignContainerBottom]))) + ]), + _List_fromArray( + [html])) : html)); + default: + return html; + } + }); +var $elm$core$List$isEmpty = function (xs) { + if (!xs.b) { + return true; + } else { + return false; + } +}; +var $elm$html$Html$text = $elm$virtual_dom$VirtualDom$text; +var $mdgriffith$elm_ui$Internal$Model$textElementClasses = $mdgriffith$elm_ui$Internal$Style$classes.any + (' ' + ($mdgriffith$elm_ui$Internal$Style$classes.text + (' ' + ($mdgriffith$elm_ui$Internal$Style$classes.widthContent + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.heightContent))))); +var $mdgriffith$elm_ui$Internal$Model$textElement = function (str) { + return A2( + $elm$html$Html$div, + _List_fromArray( + [ + $elm$html$Html$Attributes$class($mdgriffith$elm_ui$Internal$Model$textElementClasses) + ]), + _List_fromArray( + [ + $elm$html$Html$text(str) + ])); +}; +var $mdgriffith$elm_ui$Internal$Model$textElementFillClasses = $mdgriffith$elm_ui$Internal$Style$classes.any + (' ' + ($mdgriffith$elm_ui$Internal$Style$classes.text + (' ' + ($mdgriffith$elm_ui$Internal$Style$classes.widthFill + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.heightFill))))); +var $mdgriffith$elm_ui$Internal$Model$textElementFill = function (str) { + return A2( + $elm$html$Html$div, + _List_fromArray( + [ + $elm$html$Html$Attributes$class($mdgriffith$elm_ui$Internal$Model$textElementFillClasses) + ]), + _List_fromArray( + [ + $elm$html$Html$text(str) + ])); +}; +var $mdgriffith$elm_ui$Internal$Model$createElement = F3( + function (context, children, rendered) { + var gatherKeyed = F2( + function (_v8, _v9) { + var key = _v8.a; + var child = _v8.b; + var htmls = _v9.a; + var existingStyles = _v9.b; + switch (child.$) { + case 'Unstyled': + var html = child.a; + return _Utils_eq(context, $mdgriffith$elm_ui$Internal$Model$asParagraph) ? _Utils_Tuple2( + A2( + $elm$core$List$cons, + _Utils_Tuple2( + key, + html(context)), + htmls), + existingStyles) : _Utils_Tuple2( + A2( + $elm$core$List$cons, + _Utils_Tuple2( + key, + html(context)), + htmls), + existingStyles); + case 'Styled': + var styled = child.a; + return _Utils_eq(context, $mdgriffith$elm_ui$Internal$Model$asParagraph) ? _Utils_Tuple2( + A2( + $elm$core$List$cons, + _Utils_Tuple2( + key, + A2(styled.html, $mdgriffith$elm_ui$Internal$Model$NoStyleSheet, context)), + htmls), + $elm$core$List$isEmpty(existingStyles) ? styled.styles : _Utils_ap(styled.styles, existingStyles)) : _Utils_Tuple2( + A2( + $elm$core$List$cons, + _Utils_Tuple2( + key, + A2(styled.html, $mdgriffith$elm_ui$Internal$Model$NoStyleSheet, context)), + htmls), + $elm$core$List$isEmpty(existingStyles) ? styled.styles : _Utils_ap(styled.styles, existingStyles)); + case 'Text': + var str = child.a; + return _Utils_Tuple2( + A2( + $elm$core$List$cons, + _Utils_Tuple2( + key, + _Utils_eq(context, $mdgriffith$elm_ui$Internal$Model$asEl) ? $mdgriffith$elm_ui$Internal$Model$textElementFill(str) : $mdgriffith$elm_ui$Internal$Model$textElement(str)), + htmls), + existingStyles); + default: + return _Utils_Tuple2(htmls, existingStyles); + } + }); + var gather = F2( + function (child, _v6) { + var htmls = _v6.a; + var existingStyles = _v6.b; + switch (child.$) { + case 'Unstyled': + var html = child.a; + return _Utils_eq(context, $mdgriffith$elm_ui$Internal$Model$asParagraph) ? _Utils_Tuple2( + A2( + $elm$core$List$cons, + html(context), + htmls), + existingStyles) : _Utils_Tuple2( + A2( + $elm$core$List$cons, + html(context), + htmls), + existingStyles); + case 'Styled': + var styled = child.a; + return _Utils_eq(context, $mdgriffith$elm_ui$Internal$Model$asParagraph) ? _Utils_Tuple2( + A2( + $elm$core$List$cons, + A2(styled.html, $mdgriffith$elm_ui$Internal$Model$NoStyleSheet, context), + htmls), + $elm$core$List$isEmpty(existingStyles) ? styled.styles : _Utils_ap(styled.styles, existingStyles)) : _Utils_Tuple2( + A2( + $elm$core$List$cons, + A2(styled.html, $mdgriffith$elm_ui$Internal$Model$NoStyleSheet, context), + htmls), + $elm$core$List$isEmpty(existingStyles) ? styled.styles : _Utils_ap(styled.styles, existingStyles)); + case 'Text': + var str = child.a; + return _Utils_Tuple2( + A2( + $elm$core$List$cons, + _Utils_eq(context, $mdgriffith$elm_ui$Internal$Model$asEl) ? $mdgriffith$elm_ui$Internal$Model$textElementFill(str) : $mdgriffith$elm_ui$Internal$Model$textElement(str), + htmls), + existingStyles); + default: + return _Utils_Tuple2(htmls, existingStyles); + } + }); + if (children.$ === 'Keyed') { + var keyedChildren = children.a; + var _v1 = A3( + $elm$core$List$foldr, + gatherKeyed, + _Utils_Tuple2(_List_Nil, _List_Nil), + keyedChildren); + var keyed = _v1.a; + var styles = _v1.b; + var newStyles = $elm$core$List$isEmpty(styles) ? rendered.styles : _Utils_ap(rendered.styles, styles); + if (!newStyles.b) { + return $mdgriffith$elm_ui$Internal$Model$Unstyled( + A5( + $mdgriffith$elm_ui$Internal$Model$finalizeNode, + rendered.has, + rendered.node, + rendered.attributes, + $mdgriffith$elm_ui$Internal$Model$Keyed( + A3($mdgriffith$elm_ui$Internal$Model$addKeyedChildren, 'nearby-element-pls', keyed, rendered.children)), + $mdgriffith$elm_ui$Internal$Model$NoStyleSheet)); + } else { + var allStyles = newStyles; + return $mdgriffith$elm_ui$Internal$Model$Styled( + { + html: A4( + $mdgriffith$elm_ui$Internal$Model$finalizeNode, + rendered.has, + rendered.node, + rendered.attributes, + $mdgriffith$elm_ui$Internal$Model$Keyed( + A3($mdgriffith$elm_ui$Internal$Model$addKeyedChildren, 'nearby-element-pls', keyed, rendered.children))), + styles: allStyles + }); + } + } else { + var unkeyedChildren = children.a; + var _v3 = A3( + $elm$core$List$foldr, + gather, + _Utils_Tuple2(_List_Nil, _List_Nil), + unkeyedChildren); + var unkeyed = _v3.a; + var styles = _v3.b; + var newStyles = $elm$core$List$isEmpty(styles) ? rendered.styles : _Utils_ap(rendered.styles, styles); + if (!newStyles.b) { + return $mdgriffith$elm_ui$Internal$Model$Unstyled( + A5( + $mdgriffith$elm_ui$Internal$Model$finalizeNode, + rendered.has, + rendered.node, + rendered.attributes, + $mdgriffith$elm_ui$Internal$Model$Unkeyed( + A2($mdgriffith$elm_ui$Internal$Model$addChildren, unkeyed, rendered.children)), + $mdgriffith$elm_ui$Internal$Model$NoStyleSheet)); + } else { + var allStyles = newStyles; + return $mdgriffith$elm_ui$Internal$Model$Styled( + { + html: A4( + $mdgriffith$elm_ui$Internal$Model$finalizeNode, + rendered.has, + rendered.node, + rendered.attributes, + $mdgriffith$elm_ui$Internal$Model$Unkeyed( + A2($mdgriffith$elm_ui$Internal$Model$addChildren, unkeyed, rendered.children))), + styles: allStyles + }); + } + } + }); +var $mdgriffith$elm_ui$Internal$Model$Single = F3( + function (a, b, c) { + return {$: 'Single', a: a, b: b, c: c}; + }); +var $mdgriffith$elm_ui$Internal$Model$Transform = function (a) { + return {$: 'Transform', a: a}; +}; +var $mdgriffith$elm_ui$Internal$Flag$Field = F2( + function (a, b) { + return {$: 'Field', a: a, b: b}; + }); +var $elm$core$Bitwise$or = _Bitwise_or; +var $mdgriffith$elm_ui$Internal$Flag$add = F2( + function (myFlag, _v0) { + var one = _v0.a; + var two = _v0.b; + if (myFlag.$ === 'Flag') { + var first = myFlag.a; + return A2($mdgriffith$elm_ui$Internal$Flag$Field, first | one, two); + } else { + var second = myFlag.a; + return A2($mdgriffith$elm_ui$Internal$Flag$Field, one, second | two); + } + }); +var $mdgriffith$elm_ui$Internal$Model$ChildrenBehind = function (a) { + return {$: 'ChildrenBehind', a: a}; +}; +var $mdgriffith$elm_ui$Internal$Model$ChildrenBehindAndInFront = F2( + function (a, b) { + return {$: 'ChildrenBehindAndInFront', a: a, b: b}; + }); +var $mdgriffith$elm_ui$Internal$Model$ChildrenInFront = function (a) { + return {$: 'ChildrenInFront', a: a}; +}; +var $mdgriffith$elm_ui$Internal$Model$nearbyElement = F2( + function (location, elem) { + return A2( + $elm$html$Html$div, + _List_fromArray( + [ + $elm$html$Html$Attributes$class( + function () { + switch (location.$) { + case 'Above': + return A2( + $elm$core$String$join, + ' ', + _List_fromArray( + [$mdgriffith$elm_ui$Internal$Style$classes.nearby, $mdgriffith$elm_ui$Internal$Style$classes.single, $mdgriffith$elm_ui$Internal$Style$classes.above])); + case 'Below': + return A2( + $elm$core$String$join, + ' ', + _List_fromArray( + [$mdgriffith$elm_ui$Internal$Style$classes.nearby, $mdgriffith$elm_ui$Internal$Style$classes.single, $mdgriffith$elm_ui$Internal$Style$classes.below])); + case 'OnRight': + return A2( + $elm$core$String$join, + ' ', + _List_fromArray( + [$mdgriffith$elm_ui$Internal$Style$classes.nearby, $mdgriffith$elm_ui$Internal$Style$classes.single, $mdgriffith$elm_ui$Internal$Style$classes.onRight])); + case 'OnLeft': + return A2( + $elm$core$String$join, + ' ', + _List_fromArray( + [$mdgriffith$elm_ui$Internal$Style$classes.nearby, $mdgriffith$elm_ui$Internal$Style$classes.single, $mdgriffith$elm_ui$Internal$Style$classes.onLeft])); + case 'InFront': + return A2( + $elm$core$String$join, + ' ', + _List_fromArray( + [$mdgriffith$elm_ui$Internal$Style$classes.nearby, $mdgriffith$elm_ui$Internal$Style$classes.single, $mdgriffith$elm_ui$Internal$Style$classes.inFront])); + default: + return A2( + $elm$core$String$join, + ' ', + _List_fromArray( + [$mdgriffith$elm_ui$Internal$Style$classes.nearby, $mdgriffith$elm_ui$Internal$Style$classes.single, $mdgriffith$elm_ui$Internal$Style$classes.behind])); + } + }()) + ]), + _List_fromArray( + [ + function () { + switch (elem.$) { + case 'Empty': + return $elm$virtual_dom$VirtualDom$text(''); + case 'Text': + var str = elem.a; + return $mdgriffith$elm_ui$Internal$Model$textElement(str); + case 'Unstyled': + var html = elem.a; + return html($mdgriffith$elm_ui$Internal$Model$asEl); + default: + var styled = elem.a; + return A2(styled.html, $mdgriffith$elm_ui$Internal$Model$NoStyleSheet, $mdgriffith$elm_ui$Internal$Model$asEl); + } + }() + ])); + }); +var $mdgriffith$elm_ui$Internal$Model$addNearbyElement = F3( + function (location, elem, existing) { + var nearby = A2($mdgriffith$elm_ui$Internal$Model$nearbyElement, location, elem); + switch (existing.$) { + case 'NoNearbyChildren': + if (location.$ === 'Behind') { + return $mdgriffith$elm_ui$Internal$Model$ChildrenBehind( + _List_fromArray( + [nearby])); + } else { + return $mdgriffith$elm_ui$Internal$Model$ChildrenInFront( + _List_fromArray( + [nearby])); + } + case 'ChildrenBehind': + var existingBehind = existing.a; + if (location.$ === 'Behind') { + return $mdgriffith$elm_ui$Internal$Model$ChildrenBehind( + A2($elm$core$List$cons, nearby, existingBehind)); + } else { + return A2( + $mdgriffith$elm_ui$Internal$Model$ChildrenBehindAndInFront, + existingBehind, + _List_fromArray( + [nearby])); + } + case 'ChildrenInFront': + var existingInFront = existing.a; + if (location.$ === 'Behind') { + return A2( + $mdgriffith$elm_ui$Internal$Model$ChildrenBehindAndInFront, + _List_fromArray( + [nearby]), + existingInFront); + } else { + return $mdgriffith$elm_ui$Internal$Model$ChildrenInFront( + A2($elm$core$List$cons, nearby, existingInFront)); + } + default: + var existingBehind = existing.a; + var existingInFront = existing.b; + if (location.$ === 'Behind') { + return A2( + $mdgriffith$elm_ui$Internal$Model$ChildrenBehindAndInFront, + A2($elm$core$List$cons, nearby, existingBehind), + existingInFront); + } else { + return A2( + $mdgriffith$elm_ui$Internal$Model$ChildrenBehindAndInFront, + existingBehind, + A2($elm$core$List$cons, nearby, existingInFront)); + } + } + }); +var $mdgriffith$elm_ui$Internal$Model$Embedded = F2( + function (a, b) { + return {$: 'Embedded', a: a, b: b}; + }); +var $mdgriffith$elm_ui$Internal$Model$NodeName = function (a) { + return {$: 'NodeName', a: a}; +}; +var $mdgriffith$elm_ui$Internal$Model$addNodeName = F2( + function (newNode, old) { + switch (old.$) { + case 'Generic': + return $mdgriffith$elm_ui$Internal$Model$NodeName(newNode); + case 'NodeName': + var name = old.a; + return A2($mdgriffith$elm_ui$Internal$Model$Embedded, name, newNode); + default: + var x = old.a; + var y = old.b; + return A2($mdgriffith$elm_ui$Internal$Model$Embedded, x, y); + } + }); +var $mdgriffith$elm_ui$Internal$Model$alignXName = function (align) { + switch (align.$) { + case 'Left': + return $mdgriffith$elm_ui$Internal$Style$classes.alignedHorizontally + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.alignLeft); + case 'Right': + return $mdgriffith$elm_ui$Internal$Style$classes.alignedHorizontally + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.alignRight); + default: + return $mdgriffith$elm_ui$Internal$Style$classes.alignedHorizontally + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.alignCenterX); + } +}; +var $mdgriffith$elm_ui$Internal$Model$alignYName = function (align) { + switch (align.$) { + case 'Top': + return $mdgriffith$elm_ui$Internal$Style$classes.alignedVertically + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.alignTop); + case 'Bottom': + return $mdgriffith$elm_ui$Internal$Style$classes.alignedVertically + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.alignBottom); + default: + return $mdgriffith$elm_ui$Internal$Style$classes.alignedVertically + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.alignCenterY); + } +}; +var $elm$virtual_dom$VirtualDom$attribute = F2( + function (key, value) { + return A2( + _VirtualDom_attribute, + _VirtualDom_noOnOrFormAction(key), + _VirtualDom_noJavaScriptOrHtmlUri(value)); + }); +var $mdgriffith$elm_ui$Internal$Model$FullTransform = F4( + function (a, b, c, d) { + return {$: 'FullTransform', a: a, b: b, c: c, d: d}; + }); +var $mdgriffith$elm_ui$Internal$Model$Moved = function (a) { + return {$: 'Moved', a: a}; +}; +var $mdgriffith$elm_ui$Internal$Model$composeTransformation = F2( + function (transform, component) { + switch (transform.$) { + case 'Untransformed': + switch (component.$) { + case 'MoveX': + var x = component.a; + return $mdgriffith$elm_ui$Internal$Model$Moved( + _Utils_Tuple3(x, 0, 0)); + case 'MoveY': + var y = component.a; + return $mdgriffith$elm_ui$Internal$Model$Moved( + _Utils_Tuple3(0, y, 0)); + case 'MoveZ': + var z = component.a; + return $mdgriffith$elm_ui$Internal$Model$Moved( + _Utils_Tuple3(0, 0, z)); + case 'MoveXYZ': + var xyz = component.a; + return $mdgriffith$elm_ui$Internal$Model$Moved(xyz); + case 'Rotate': + var xyz = component.a; + var angle = component.b; + return A4( + $mdgriffith$elm_ui$Internal$Model$FullTransform, + _Utils_Tuple3(0, 0, 0), + _Utils_Tuple3(1, 1, 1), + xyz, + angle); + default: + var xyz = component.a; + return A4( + $mdgriffith$elm_ui$Internal$Model$FullTransform, + _Utils_Tuple3(0, 0, 0), + xyz, + _Utils_Tuple3(0, 0, 1), + 0); + } + case 'Moved': + var moved = transform.a; + var x = moved.a; + var y = moved.b; + var z = moved.c; + switch (component.$) { + case 'MoveX': + var newX = component.a; + return $mdgriffith$elm_ui$Internal$Model$Moved( + _Utils_Tuple3(newX, y, z)); + case 'MoveY': + var newY = component.a; + return $mdgriffith$elm_ui$Internal$Model$Moved( + _Utils_Tuple3(x, newY, z)); + case 'MoveZ': + var newZ = component.a; + return $mdgriffith$elm_ui$Internal$Model$Moved( + _Utils_Tuple3(x, y, newZ)); + case 'MoveXYZ': + var xyz = component.a; + return $mdgriffith$elm_ui$Internal$Model$Moved(xyz); + case 'Rotate': + var xyz = component.a; + var angle = component.b; + return A4( + $mdgriffith$elm_ui$Internal$Model$FullTransform, + moved, + _Utils_Tuple3(1, 1, 1), + xyz, + angle); + default: + var scale = component.a; + return A4( + $mdgriffith$elm_ui$Internal$Model$FullTransform, + moved, + scale, + _Utils_Tuple3(0, 0, 1), + 0); + } + default: + var moved = transform.a; + var x = moved.a; + var y = moved.b; + var z = moved.c; + var scaled = transform.b; + var origin = transform.c; + var angle = transform.d; + switch (component.$) { + case 'MoveX': + var newX = component.a; + return A4( + $mdgriffith$elm_ui$Internal$Model$FullTransform, + _Utils_Tuple3(newX, y, z), + scaled, + origin, + angle); + case 'MoveY': + var newY = component.a; + return A4( + $mdgriffith$elm_ui$Internal$Model$FullTransform, + _Utils_Tuple3(x, newY, z), + scaled, + origin, + angle); + case 'MoveZ': + var newZ = component.a; + return A4( + $mdgriffith$elm_ui$Internal$Model$FullTransform, + _Utils_Tuple3(x, y, newZ), + scaled, + origin, + angle); + case 'MoveXYZ': + var newMove = component.a; + return A4($mdgriffith$elm_ui$Internal$Model$FullTransform, newMove, scaled, origin, angle); + case 'Rotate': + var newOrigin = component.a; + var newAngle = component.b; + return A4($mdgriffith$elm_ui$Internal$Model$FullTransform, moved, scaled, newOrigin, newAngle); + default: + var newScale = component.a; + return A4($mdgriffith$elm_ui$Internal$Model$FullTransform, moved, newScale, origin, angle); + } + } + }); +var $mdgriffith$elm_ui$Internal$Flag$height = $mdgriffith$elm_ui$Internal$Flag$flag(7); +var $mdgriffith$elm_ui$Internal$Flag$heightContent = $mdgriffith$elm_ui$Internal$Flag$flag(36); +var $mdgriffith$elm_ui$Internal$Flag$merge = F2( + function (_v0, _v1) { + var one = _v0.a; + var two = _v0.b; + var three = _v1.a; + var four = _v1.b; + return A2($mdgriffith$elm_ui$Internal$Flag$Field, one | three, two | four); + }); +var $mdgriffith$elm_ui$Internal$Flag$none = A2($mdgriffith$elm_ui$Internal$Flag$Field, 0, 0); +var $mdgriffith$elm_ui$Internal$Model$renderHeight = function (h) { + switch (h.$) { + case 'Px': + var px = h.a; + var val = $elm$core$String$fromInt(px); + var name = 'height-px-' + val; + return _Utils_Tuple3( + $mdgriffith$elm_ui$Internal$Flag$none, + $mdgriffith$elm_ui$Internal$Style$classes.heightExact + (' ' + name), + _List_fromArray( + [ + A3($mdgriffith$elm_ui$Internal$Model$Single, name, 'height', val + 'px') + ])); + case 'Content': + return _Utils_Tuple3( + A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$heightContent, $mdgriffith$elm_ui$Internal$Flag$none), + $mdgriffith$elm_ui$Internal$Style$classes.heightContent, + _List_Nil); + case 'Fill': + var portion = h.a; + return (portion === 1) ? _Utils_Tuple3( + A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$heightFill, $mdgriffith$elm_ui$Internal$Flag$none), + $mdgriffith$elm_ui$Internal$Style$classes.heightFill, + _List_Nil) : _Utils_Tuple3( + A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$heightFill, $mdgriffith$elm_ui$Internal$Flag$none), + $mdgriffith$elm_ui$Internal$Style$classes.heightFillPortion + (' height-fill-' + $elm$core$String$fromInt(portion)), + _List_fromArray( + [ + A3( + $mdgriffith$elm_ui$Internal$Model$Single, + $mdgriffith$elm_ui$Internal$Style$classes.any + ('.' + ($mdgriffith$elm_ui$Internal$Style$classes.column + (' > ' + $mdgriffith$elm_ui$Internal$Style$dot( + 'height-fill-' + $elm$core$String$fromInt(portion))))), + 'flex-grow', + $elm$core$String$fromInt(portion * 100000)) + ])); + case 'Min': + var minSize = h.a; + var len = h.b; + var cls = 'min-height-' + $elm$core$String$fromInt(minSize); + var style = A3( + $mdgriffith$elm_ui$Internal$Model$Single, + cls, + 'min-height', + $elm$core$String$fromInt(minSize) + 'px !important'); + var _v1 = $mdgriffith$elm_ui$Internal$Model$renderHeight(len); + var newFlag = _v1.a; + var newAttrs = _v1.b; + var newStyle = _v1.c; + return _Utils_Tuple3( + A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$heightBetween, newFlag), + cls + (' ' + newAttrs), + A2($elm$core$List$cons, style, newStyle)); + default: + var maxSize = h.a; + var len = h.b; + var cls = 'max-height-' + $elm$core$String$fromInt(maxSize); + var style = A3( + $mdgriffith$elm_ui$Internal$Model$Single, + cls, + 'max-height', + $elm$core$String$fromInt(maxSize) + 'px'); + var _v2 = $mdgriffith$elm_ui$Internal$Model$renderHeight(len); + var newFlag = _v2.a; + var newAttrs = _v2.b; + var newStyle = _v2.c; + return _Utils_Tuple3( + A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$heightBetween, newFlag), + cls + (' ' + newAttrs), + A2($elm$core$List$cons, style, newStyle)); + } +}; +var $mdgriffith$elm_ui$Internal$Flag$widthContent = $mdgriffith$elm_ui$Internal$Flag$flag(38); +var $mdgriffith$elm_ui$Internal$Model$renderWidth = function (w) { + switch (w.$) { + case 'Px': + var px = w.a; + return _Utils_Tuple3( + $mdgriffith$elm_ui$Internal$Flag$none, + $mdgriffith$elm_ui$Internal$Style$classes.widthExact + (' width-px-' + $elm$core$String$fromInt(px)), + _List_fromArray( + [ + A3( + $mdgriffith$elm_ui$Internal$Model$Single, + 'width-px-' + $elm$core$String$fromInt(px), + 'width', + $elm$core$String$fromInt(px) + 'px') + ])); + case 'Content': + return _Utils_Tuple3( + A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$widthContent, $mdgriffith$elm_ui$Internal$Flag$none), + $mdgriffith$elm_ui$Internal$Style$classes.widthContent, + _List_Nil); + case 'Fill': + var portion = w.a; + return (portion === 1) ? _Utils_Tuple3( + A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$widthFill, $mdgriffith$elm_ui$Internal$Flag$none), + $mdgriffith$elm_ui$Internal$Style$classes.widthFill, + _List_Nil) : _Utils_Tuple3( + A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$widthFill, $mdgriffith$elm_ui$Internal$Flag$none), + $mdgriffith$elm_ui$Internal$Style$classes.widthFillPortion + (' width-fill-' + $elm$core$String$fromInt(portion)), + _List_fromArray( + [ + A3( + $mdgriffith$elm_ui$Internal$Model$Single, + $mdgriffith$elm_ui$Internal$Style$classes.any + ('.' + ($mdgriffith$elm_ui$Internal$Style$classes.row + (' > ' + $mdgriffith$elm_ui$Internal$Style$dot( + 'width-fill-' + $elm$core$String$fromInt(portion))))), + 'flex-grow', + $elm$core$String$fromInt(portion * 100000)) + ])); + case 'Min': + var minSize = w.a; + var len = w.b; + var cls = 'min-width-' + $elm$core$String$fromInt(minSize); + var style = A3( + $mdgriffith$elm_ui$Internal$Model$Single, + cls, + 'min-width', + $elm$core$String$fromInt(minSize) + 'px'); + var _v1 = $mdgriffith$elm_ui$Internal$Model$renderWidth(len); + var newFlag = _v1.a; + var newAttrs = _v1.b; + var newStyle = _v1.c; + return _Utils_Tuple3( + A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$widthBetween, newFlag), + cls + (' ' + newAttrs), + A2($elm$core$List$cons, style, newStyle)); + default: + var maxSize = w.a; + var len = w.b; + var cls = 'max-width-' + $elm$core$String$fromInt(maxSize); + var style = A3( + $mdgriffith$elm_ui$Internal$Model$Single, + cls, + 'max-width', + $elm$core$String$fromInt(maxSize) + 'px'); + var _v2 = $mdgriffith$elm_ui$Internal$Model$renderWidth(len); + var newFlag = _v2.a; + var newAttrs = _v2.b; + var newStyle = _v2.c; + return _Utils_Tuple3( + A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$widthBetween, newFlag), + cls + (' ' + newAttrs), + A2($elm$core$List$cons, style, newStyle)); + } +}; +var $mdgriffith$elm_ui$Internal$Flag$borderWidth = $mdgriffith$elm_ui$Internal$Flag$flag(27); +var $elm$core$Basics$ge = _Utils_ge; +var $mdgriffith$elm_ui$Internal$Model$skippable = F2( + function (flag, style) { + if (_Utils_eq(flag, $mdgriffith$elm_ui$Internal$Flag$borderWidth)) { + if (style.$ === 'Single') { + var val = style.c; + switch (val) { + case '0px': + return true; + case '1px': + return true; + case '2px': + return true; + case '3px': + return true; + case '4px': + return true; + case '5px': + return true; + case '6px': + return true; + default: + return false; + } + } else { + return false; + } + } else { + switch (style.$) { + case 'FontSize': + var i = style.a; + return (i >= 8) && (i <= 32); + case 'PaddingStyle': + var name = style.a; + var t = style.b; + var r = style.c; + var b = style.d; + var l = style.e; + return _Utils_eq(t, b) && (_Utils_eq(t, r) && (_Utils_eq(t, l) && ((t >= 0) && (t <= 24)))); + default: + return false; + } + } + }); +var $mdgriffith$elm_ui$Internal$Flag$width = $mdgriffith$elm_ui$Internal$Flag$flag(6); +var $mdgriffith$elm_ui$Internal$Flag$xAlign = $mdgriffith$elm_ui$Internal$Flag$flag(30); +var $mdgriffith$elm_ui$Internal$Flag$yAlign = $mdgriffith$elm_ui$Internal$Flag$flag(29); +var $mdgriffith$elm_ui$Internal$Model$gatherAttrRecursive = F8( + function (classes, node, has, transform, styles, attrs, children, elementAttrs) { + gatherAttrRecursive: + while (true) { + if (!elementAttrs.b) { + var _v1 = $mdgriffith$elm_ui$Internal$Model$transformClass(transform); + if (_v1.$ === 'Nothing') { + return { + attributes: A2( + $elm$core$List$cons, + $elm$html$Html$Attributes$class(classes), + attrs), + children: children, + has: has, + node: node, + styles: styles + }; + } else { + var _class = _v1.a; + return { + attributes: A2( + $elm$core$List$cons, + $elm$html$Html$Attributes$class(classes + (' ' + _class)), + attrs), + children: children, + has: has, + node: node, + styles: A2( + $elm$core$List$cons, + $mdgriffith$elm_ui$Internal$Model$Transform(transform), + styles) + }; + } + } else { + var attribute = elementAttrs.a; + var remaining = elementAttrs.b; + switch (attribute.$) { + case 'NoAttribute': + var $temp$classes = classes, + $temp$node = node, + $temp$has = has, + $temp$transform = transform, + $temp$styles = styles, + $temp$attrs = attrs, + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + case 'Class': + var flag = attribute.a; + var exactClassName = attribute.b; + if (A2($mdgriffith$elm_ui$Internal$Flag$present, flag, has)) { + var $temp$classes = classes, + $temp$node = node, + $temp$has = has, + $temp$transform = transform, + $temp$styles = styles, + $temp$attrs = attrs, + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + } else { + var $temp$classes = exactClassName + (' ' + classes), + $temp$node = node, + $temp$has = A2($mdgriffith$elm_ui$Internal$Flag$add, flag, has), + $temp$transform = transform, + $temp$styles = styles, + $temp$attrs = attrs, + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + } + case 'Attr': + var actualAttribute = attribute.a; + var $temp$classes = classes, + $temp$node = node, + $temp$has = has, + $temp$transform = transform, + $temp$styles = styles, + $temp$attrs = A2($elm$core$List$cons, actualAttribute, attrs), + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + case 'StyleClass': + var flag = attribute.a; + var style = attribute.b; + if (A2($mdgriffith$elm_ui$Internal$Flag$present, flag, has)) { + var $temp$classes = classes, + $temp$node = node, + $temp$has = has, + $temp$transform = transform, + $temp$styles = styles, + $temp$attrs = attrs, + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + } else { + if (A2($mdgriffith$elm_ui$Internal$Model$skippable, flag, style)) { + var $temp$classes = $mdgriffith$elm_ui$Internal$Model$getStyleName(style) + (' ' + classes), + $temp$node = node, + $temp$has = A2($mdgriffith$elm_ui$Internal$Flag$add, flag, has), + $temp$transform = transform, + $temp$styles = styles, + $temp$attrs = attrs, + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + } else { + var $temp$classes = $mdgriffith$elm_ui$Internal$Model$getStyleName(style) + (' ' + classes), + $temp$node = node, + $temp$has = A2($mdgriffith$elm_ui$Internal$Flag$add, flag, has), + $temp$transform = transform, + $temp$styles = A2($elm$core$List$cons, style, styles), + $temp$attrs = attrs, + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + } + } + case 'TransformComponent': + var flag = attribute.a; + var component = attribute.b; + var $temp$classes = classes, + $temp$node = node, + $temp$has = A2($mdgriffith$elm_ui$Internal$Flag$add, flag, has), + $temp$transform = A2($mdgriffith$elm_ui$Internal$Model$composeTransformation, transform, component), + $temp$styles = styles, + $temp$attrs = attrs, + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + case 'Width': + var width = attribute.a; + if (A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$width, has)) { + var $temp$classes = classes, + $temp$node = node, + $temp$has = has, + $temp$transform = transform, + $temp$styles = styles, + $temp$attrs = attrs, + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + } else { + switch (width.$) { + case 'Px': + var px = width.a; + var $temp$classes = ($mdgriffith$elm_ui$Internal$Style$classes.widthExact + (' width-px-' + $elm$core$String$fromInt(px))) + (' ' + classes), + $temp$node = node, + $temp$has = A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$width, has), + $temp$transform = transform, + $temp$styles = A2( + $elm$core$List$cons, + A3( + $mdgriffith$elm_ui$Internal$Model$Single, + 'width-px-' + $elm$core$String$fromInt(px), + 'width', + $elm$core$String$fromInt(px) + 'px'), + styles), + $temp$attrs = attrs, + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + case 'Content': + var $temp$classes = classes + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.widthContent), + $temp$node = node, + $temp$has = A2( + $mdgriffith$elm_ui$Internal$Flag$add, + $mdgriffith$elm_ui$Internal$Flag$widthContent, + A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$width, has)), + $temp$transform = transform, + $temp$styles = styles, + $temp$attrs = attrs, + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + case 'Fill': + var portion = width.a; + if (portion === 1) { + var $temp$classes = classes + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.widthFill), + $temp$node = node, + $temp$has = A2( + $mdgriffith$elm_ui$Internal$Flag$add, + $mdgriffith$elm_ui$Internal$Flag$widthFill, + A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$width, has)), + $temp$transform = transform, + $temp$styles = styles, + $temp$attrs = attrs, + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + } else { + var $temp$classes = classes + (' ' + ($mdgriffith$elm_ui$Internal$Style$classes.widthFillPortion + (' width-fill-' + $elm$core$String$fromInt(portion)))), + $temp$node = node, + $temp$has = A2( + $mdgriffith$elm_ui$Internal$Flag$add, + $mdgriffith$elm_ui$Internal$Flag$widthFill, + A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$width, has)), + $temp$transform = transform, + $temp$styles = A2( + $elm$core$List$cons, + A3( + $mdgriffith$elm_ui$Internal$Model$Single, + $mdgriffith$elm_ui$Internal$Style$classes.any + ('.' + ($mdgriffith$elm_ui$Internal$Style$classes.row + (' > ' + $mdgriffith$elm_ui$Internal$Style$dot( + 'width-fill-' + $elm$core$String$fromInt(portion))))), + 'flex-grow', + $elm$core$String$fromInt(portion * 100000)), + styles), + $temp$attrs = attrs, + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + } + default: + var _v4 = $mdgriffith$elm_ui$Internal$Model$renderWidth(width); + var addToFlags = _v4.a; + var newClass = _v4.b; + var newStyles = _v4.c; + var $temp$classes = classes + (' ' + newClass), + $temp$node = node, + $temp$has = A2( + $mdgriffith$elm_ui$Internal$Flag$merge, + addToFlags, + A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$width, has)), + $temp$transform = transform, + $temp$styles = _Utils_ap(newStyles, styles), + $temp$attrs = attrs, + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + } + } + case 'Height': + var height = attribute.a; + if (A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$height, has)) { + var $temp$classes = classes, + $temp$node = node, + $temp$has = has, + $temp$transform = transform, + $temp$styles = styles, + $temp$attrs = attrs, + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + } else { + switch (height.$) { + case 'Px': + var px = height.a; + var val = $elm$core$String$fromInt(px) + 'px'; + var name = 'height-px-' + val; + var $temp$classes = $mdgriffith$elm_ui$Internal$Style$classes.heightExact + (' ' + (name + (' ' + classes))), + $temp$node = node, + $temp$has = A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$height, has), + $temp$transform = transform, + $temp$styles = A2( + $elm$core$List$cons, + A3($mdgriffith$elm_ui$Internal$Model$Single, name, 'height ', val), + styles), + $temp$attrs = attrs, + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + case 'Content': + var $temp$classes = $mdgriffith$elm_ui$Internal$Style$classes.heightContent + (' ' + classes), + $temp$node = node, + $temp$has = A2( + $mdgriffith$elm_ui$Internal$Flag$add, + $mdgriffith$elm_ui$Internal$Flag$heightContent, + A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$height, has)), + $temp$transform = transform, + $temp$styles = styles, + $temp$attrs = attrs, + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + case 'Fill': + var portion = height.a; + if (portion === 1) { + var $temp$classes = $mdgriffith$elm_ui$Internal$Style$classes.heightFill + (' ' + classes), + $temp$node = node, + $temp$has = A2( + $mdgriffith$elm_ui$Internal$Flag$add, + $mdgriffith$elm_ui$Internal$Flag$heightFill, + A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$height, has)), + $temp$transform = transform, + $temp$styles = styles, + $temp$attrs = attrs, + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + } else { + var $temp$classes = classes + (' ' + ($mdgriffith$elm_ui$Internal$Style$classes.heightFillPortion + (' height-fill-' + $elm$core$String$fromInt(portion)))), + $temp$node = node, + $temp$has = A2( + $mdgriffith$elm_ui$Internal$Flag$add, + $mdgriffith$elm_ui$Internal$Flag$heightFill, + A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$height, has)), + $temp$transform = transform, + $temp$styles = A2( + $elm$core$List$cons, + A3( + $mdgriffith$elm_ui$Internal$Model$Single, + $mdgriffith$elm_ui$Internal$Style$classes.any + ('.' + ($mdgriffith$elm_ui$Internal$Style$classes.column + (' > ' + $mdgriffith$elm_ui$Internal$Style$dot( + 'height-fill-' + $elm$core$String$fromInt(portion))))), + 'flex-grow', + $elm$core$String$fromInt(portion * 100000)), + styles), + $temp$attrs = attrs, + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + } + default: + var _v6 = $mdgriffith$elm_ui$Internal$Model$renderHeight(height); + var addToFlags = _v6.a; + var newClass = _v6.b; + var newStyles = _v6.c; + var $temp$classes = classes + (' ' + newClass), + $temp$node = node, + $temp$has = A2( + $mdgriffith$elm_ui$Internal$Flag$merge, + addToFlags, + A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$height, has)), + $temp$transform = transform, + $temp$styles = _Utils_ap(newStyles, styles), + $temp$attrs = attrs, + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + } + } + case 'Describe': + var description = attribute.a; + switch (description.$) { + case 'Main': + var $temp$classes = classes, + $temp$node = A2($mdgriffith$elm_ui$Internal$Model$addNodeName, 'main', node), + $temp$has = has, + $temp$transform = transform, + $temp$styles = styles, + $temp$attrs = attrs, + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + case 'Navigation': + var $temp$classes = classes, + $temp$node = A2($mdgriffith$elm_ui$Internal$Model$addNodeName, 'nav', node), + $temp$has = has, + $temp$transform = transform, + $temp$styles = styles, + $temp$attrs = attrs, + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + case 'ContentInfo': + var $temp$classes = classes, + $temp$node = A2($mdgriffith$elm_ui$Internal$Model$addNodeName, 'footer', node), + $temp$has = has, + $temp$transform = transform, + $temp$styles = styles, + $temp$attrs = attrs, + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + case 'Complementary': + var $temp$classes = classes, + $temp$node = A2($mdgriffith$elm_ui$Internal$Model$addNodeName, 'aside', node), + $temp$has = has, + $temp$transform = transform, + $temp$styles = styles, + $temp$attrs = attrs, + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + case 'Heading': + var i = description.a; + if (i <= 1) { + var $temp$classes = classes, + $temp$node = A2($mdgriffith$elm_ui$Internal$Model$addNodeName, 'h1', node), + $temp$has = has, + $temp$transform = transform, + $temp$styles = styles, + $temp$attrs = attrs, + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + } else { + if (i < 7) { + var $temp$classes = classes, + $temp$node = A2( + $mdgriffith$elm_ui$Internal$Model$addNodeName, + 'h' + $elm$core$String$fromInt(i), + node), + $temp$has = has, + $temp$transform = transform, + $temp$styles = styles, + $temp$attrs = attrs, + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + } else { + var $temp$classes = classes, + $temp$node = A2($mdgriffith$elm_ui$Internal$Model$addNodeName, 'h6', node), + $temp$has = has, + $temp$transform = transform, + $temp$styles = styles, + $temp$attrs = attrs, + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + } + } + case 'Paragraph': + var $temp$classes = classes, + $temp$node = node, + $temp$has = has, + $temp$transform = transform, + $temp$styles = styles, + $temp$attrs = attrs, + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + case 'Button': + var $temp$classes = classes, + $temp$node = node, + $temp$has = has, + $temp$transform = transform, + $temp$styles = styles, + $temp$attrs = A2( + $elm$core$List$cons, + A2($elm$virtual_dom$VirtualDom$attribute, 'role', 'button'), + attrs), + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + case 'Label': + var label = description.a; + var $temp$classes = classes, + $temp$node = node, + $temp$has = has, + $temp$transform = transform, + $temp$styles = styles, + $temp$attrs = A2( + $elm$core$List$cons, + A2($elm$virtual_dom$VirtualDom$attribute, 'aria-label', label), + attrs), + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + case 'LivePolite': + var $temp$classes = classes, + $temp$node = node, + $temp$has = has, + $temp$transform = transform, + $temp$styles = styles, + $temp$attrs = A2( + $elm$core$List$cons, + A2($elm$virtual_dom$VirtualDom$attribute, 'aria-live', 'polite'), + attrs), + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + default: + var $temp$classes = classes, + $temp$node = node, + $temp$has = has, + $temp$transform = transform, + $temp$styles = styles, + $temp$attrs = A2( + $elm$core$List$cons, + A2($elm$virtual_dom$VirtualDom$attribute, 'aria-live', 'assertive'), + attrs), + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + } + case 'Nearby': + var location = attribute.a; + var elem = attribute.b; + var newStyles = function () { + switch (elem.$) { + case 'Empty': + return styles; + case 'Text': + var str = elem.a; + return styles; + case 'Unstyled': + var html = elem.a; + return styles; + default: + var styled = elem.a; + return _Utils_ap(styles, styled.styles); + } + }(); + var $temp$classes = classes, + $temp$node = node, + $temp$has = has, + $temp$transform = transform, + $temp$styles = newStyles, + $temp$attrs = attrs, + $temp$children = A3($mdgriffith$elm_ui$Internal$Model$addNearbyElement, location, elem, children), + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + case 'AlignX': + var x = attribute.a; + if (A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$xAlign, has)) { + var $temp$classes = classes, + $temp$node = node, + $temp$has = has, + $temp$transform = transform, + $temp$styles = styles, + $temp$attrs = attrs, + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + } else { + var $temp$classes = $mdgriffith$elm_ui$Internal$Model$alignXName(x) + (' ' + classes), + $temp$node = node, + $temp$has = function (flags) { + switch (x.$) { + case 'CenterX': + return A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$centerX, flags); + case 'Right': + return A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$alignRight, flags); + default: + return flags; + } + }( + A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$xAlign, has)), + $temp$transform = transform, + $temp$styles = styles, + $temp$attrs = attrs, + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + } + default: + var y = attribute.a; + if (A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$yAlign, has)) { + var $temp$classes = classes, + $temp$node = node, + $temp$has = has, + $temp$transform = transform, + $temp$styles = styles, + $temp$attrs = attrs, + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + } else { + var $temp$classes = $mdgriffith$elm_ui$Internal$Model$alignYName(y) + (' ' + classes), + $temp$node = node, + $temp$has = function (flags) { + switch (y.$) { + case 'CenterY': + return A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$centerY, flags); + case 'Bottom': + return A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$alignBottom, flags); + default: + return flags; + } + }( + A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$yAlign, has)), + $temp$transform = transform, + $temp$styles = styles, + $temp$attrs = attrs, + $temp$children = children, + $temp$elementAttrs = remaining; + classes = $temp$classes; + node = $temp$node; + has = $temp$has; + transform = $temp$transform; + styles = $temp$styles; + attrs = $temp$attrs; + children = $temp$children; + elementAttrs = $temp$elementAttrs; + continue gatherAttrRecursive; + } + } + } + } + }); +var $mdgriffith$elm_ui$Internal$Model$Untransformed = {$: 'Untransformed'}; +var $mdgriffith$elm_ui$Internal$Model$untransformed = $mdgriffith$elm_ui$Internal$Model$Untransformed; +var $mdgriffith$elm_ui$Internal$Model$element = F4( + function (context, node, attributes, children) { + return A3( + $mdgriffith$elm_ui$Internal$Model$createElement, + context, + children, + A8( + $mdgriffith$elm_ui$Internal$Model$gatherAttrRecursive, + $mdgriffith$elm_ui$Internal$Model$contextClasses(context), + node, + $mdgriffith$elm_ui$Internal$Flag$none, + $mdgriffith$elm_ui$Internal$Model$untransformed, + _List_Nil, + _List_Nil, + $mdgriffith$elm_ui$Internal$Model$NoNearbyChildren, + $elm$core$List$reverse(attributes))); + }); +var $mdgriffith$elm_ui$Internal$Model$Height = function (a) { + return {$: 'Height', a: a}; +}; +var $mdgriffith$elm_ui$Element$height = $mdgriffith$elm_ui$Internal$Model$Height; +var $mdgriffith$elm_ui$Internal$Model$Attr = function (a) { + return {$: 'Attr', a: a}; +}; +var $mdgriffith$elm_ui$Internal$Model$htmlClass = function (cls) { + return $mdgriffith$elm_ui$Internal$Model$Attr( + $elm$html$Html$Attributes$class(cls)); +}; +var $mdgriffith$elm_ui$Internal$Model$Content = {$: 'Content'}; +var $mdgriffith$elm_ui$Element$shrink = $mdgriffith$elm_ui$Internal$Model$Content; +var $mdgriffith$elm_ui$Internal$Model$Width = function (a) { + return {$: 'Width', a: a}; +}; +var $mdgriffith$elm_ui$Element$width = $mdgriffith$elm_ui$Internal$Model$Width; +var $mdgriffith$elm_ui$Element$column = F2( + function (attrs, children) { + return A4( + $mdgriffith$elm_ui$Internal$Model$element, + $mdgriffith$elm_ui$Internal$Model$asColumn, + $mdgriffith$elm_ui$Internal$Model$div, + A2( + $elm$core$List$cons, + $mdgriffith$elm_ui$Internal$Model$htmlClass($mdgriffith$elm_ui$Internal$Style$classes.contentTop + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.contentLeft)), + A2( + $elm$core$List$cons, + $mdgriffith$elm_ui$Element$height($mdgriffith$elm_ui$Element$shrink), + A2( + $elm$core$List$cons, + $mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$shrink), + attrs))), + $mdgriffith$elm_ui$Internal$Model$Unkeyed(children)); + }); +var $mdgriffith$elm_ui$Element$el = F2( + function (attrs, child) { + return A4( + $mdgriffith$elm_ui$Internal$Model$element, + $mdgriffith$elm_ui$Internal$Model$asEl, + $mdgriffith$elm_ui$Internal$Model$div, + A2( + $elm$core$List$cons, + $mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$shrink), + A2( + $elm$core$List$cons, + $mdgriffith$elm_ui$Element$height($mdgriffith$elm_ui$Element$shrink), + attrs)), + $mdgriffith$elm_ui$Internal$Model$Unkeyed( + _List_fromArray( + [child]))); + }); +var $mdgriffith$elm_ui$Internal$Model$Fill = function (a) { + return {$: 'Fill', a: a}; +}; +var $mdgriffith$elm_ui$Element$fill = $mdgriffith$elm_ui$Internal$Model$Fill(1); +var $mdgriffith$elm_ui$Internal$Model$OnlyDynamic = F2( + function (a, b) { + return {$: 'OnlyDynamic', a: a, b: b}; + }); +var $mdgriffith$elm_ui$Internal$Model$StaticRootAndDynamic = F2( + function (a, b) { + return {$: 'StaticRootAndDynamic', a: a, b: b}; + }); +var $mdgriffith$elm_ui$Internal$Model$AllowHover = {$: 'AllowHover'}; +var $mdgriffith$elm_ui$Internal$Model$Layout = {$: 'Layout'}; +var $mdgriffith$elm_ui$Internal$Model$Rgba = F4( + function (a, b, c, d) { + return {$: 'Rgba', a: a, b: b, c: c, d: d}; + }); +var $mdgriffith$elm_ui$Internal$Model$focusDefaultStyle = { + backgroundColor: $elm$core$Maybe$Nothing, + borderColor: $elm$core$Maybe$Nothing, + shadow: $elm$core$Maybe$Just( + { + blur: 0, + color: A4($mdgriffith$elm_ui$Internal$Model$Rgba, 155 / 255, 203 / 255, 1, 1), + offset: _Utils_Tuple2(0, 0), + size: 3 + }) +}; +var $mdgriffith$elm_ui$Internal$Model$optionsToRecord = function (options) { + var combine = F2( + function (opt, record) { + switch (opt.$) { + case 'HoverOption': + var hoverable = opt.a; + var _v4 = record.hover; + if (_v4.$ === 'Nothing') { + return _Utils_update( + record, + { + hover: $elm$core$Maybe$Just(hoverable) + }); + } else { + return record; + } + case 'FocusStyleOption': + var focusStyle = opt.a; + var _v5 = record.focus; + if (_v5.$ === 'Nothing') { + return _Utils_update( + record, + { + focus: $elm$core$Maybe$Just(focusStyle) + }); + } else { + return record; + } + default: + var renderMode = opt.a; + var _v6 = record.mode; + if (_v6.$ === 'Nothing') { + return _Utils_update( + record, + { + mode: $elm$core$Maybe$Just(renderMode) + }); + } else { + return record; + } + } + }); + var andFinally = function (record) { + return { + focus: function () { + var _v0 = record.focus; + if (_v0.$ === 'Nothing') { + return $mdgriffith$elm_ui$Internal$Model$focusDefaultStyle; + } else { + var focusable = _v0.a; + return focusable; + } + }(), + hover: function () { + var _v1 = record.hover; + if (_v1.$ === 'Nothing') { + return $mdgriffith$elm_ui$Internal$Model$AllowHover; + } else { + var hoverable = _v1.a; + return hoverable; + } + }(), + mode: function () { + var _v2 = record.mode; + if (_v2.$ === 'Nothing') { + return $mdgriffith$elm_ui$Internal$Model$Layout; + } else { + var actualMode = _v2.a; + return actualMode; + } + }() + }; + }; + return andFinally( + A3( + $elm$core$List$foldr, + combine, + {focus: $elm$core$Maybe$Nothing, hover: $elm$core$Maybe$Nothing, mode: $elm$core$Maybe$Nothing}, + options)); +}; +var $mdgriffith$elm_ui$Internal$Model$toHtml = F2( + function (mode, el) { + switch (el.$) { + case 'Unstyled': + var html = el.a; + return html($mdgriffith$elm_ui$Internal$Model$asEl); + case 'Styled': + var html = el.a.html; + var styles = el.a.styles; + return A2( + html, + mode(styles), + $mdgriffith$elm_ui$Internal$Model$asEl); + case 'Text': + var text = el.a; + return $mdgriffith$elm_ui$Internal$Model$textElement(text); + default: + return $mdgriffith$elm_ui$Internal$Model$textElement(''); + } + }); +var $mdgriffith$elm_ui$Internal$Model$renderRoot = F3( + function (optionList, attributes, child) { + var options = $mdgriffith$elm_ui$Internal$Model$optionsToRecord(optionList); + var embedStyle = function () { + var _v0 = options.mode; + if (_v0.$ === 'NoStaticStyleSheet') { + return $mdgriffith$elm_ui$Internal$Model$OnlyDynamic(options); + } else { + return $mdgriffith$elm_ui$Internal$Model$StaticRootAndDynamic(options); + } + }(); + return A2( + $mdgriffith$elm_ui$Internal$Model$toHtml, + embedStyle, + A4( + $mdgriffith$elm_ui$Internal$Model$element, + $mdgriffith$elm_ui$Internal$Model$asEl, + $mdgriffith$elm_ui$Internal$Model$div, + attributes, + $mdgriffith$elm_ui$Internal$Model$Unkeyed( + _List_fromArray( + [child])))); + }); +var $mdgriffith$elm_ui$Internal$Model$Colored = F3( + function (a, b, c) { + return {$: 'Colored', a: a, b: b, c: c}; + }); +var $mdgriffith$elm_ui$Internal$Model$FontFamily = F2( + function (a, b) { + return {$: 'FontFamily', a: a, b: b}; + }); +var $mdgriffith$elm_ui$Internal$Model$FontSize = function (a) { + return {$: 'FontSize', a: a}; +}; +var $mdgriffith$elm_ui$Internal$Model$SansSerif = {$: 'SansSerif'}; +var $mdgriffith$elm_ui$Internal$Model$StyleClass = F2( + function (a, b) { + return {$: 'StyleClass', a: a, b: b}; + }); +var $mdgriffith$elm_ui$Internal$Model$Typeface = function (a) { + return {$: 'Typeface', a: a}; +}; +var $mdgriffith$elm_ui$Internal$Flag$bgColor = $mdgriffith$elm_ui$Internal$Flag$flag(8); +var $mdgriffith$elm_ui$Internal$Flag$fontColor = $mdgriffith$elm_ui$Internal$Flag$flag(14); +var $mdgriffith$elm_ui$Internal$Flag$fontFamily = $mdgriffith$elm_ui$Internal$Flag$flag(5); +var $mdgriffith$elm_ui$Internal$Flag$fontSize = $mdgriffith$elm_ui$Internal$Flag$flag(4); +var $mdgriffith$elm_ui$Internal$Model$formatColorClass = function (_v0) { + var red = _v0.a; + var green = _v0.b; + var blue = _v0.c; + var alpha = _v0.d; + return $mdgriffith$elm_ui$Internal$Model$floatClass(red) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(green) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(blue) + ('-' + $mdgriffith$elm_ui$Internal$Model$floatClass(alpha)))))); +}; +var $elm$core$String$toLower = _String_toLower; +var $elm$core$String$words = _String_words; +var $mdgriffith$elm_ui$Internal$Model$renderFontClassName = F2( + function (font, current) { + return _Utils_ap( + current, + function () { + switch (font.$) { + case 'Serif': + return 'serif'; + case 'SansSerif': + return 'sans-serif'; + case 'Monospace': + return 'monospace'; + case 'Typeface': + var name = font.a; + return A2( + $elm$core$String$join, + '-', + $elm$core$String$words( + $elm$core$String$toLower(name))); + case 'ImportFont': + var name = font.a; + var url = font.b; + return A2( + $elm$core$String$join, + '-', + $elm$core$String$words( + $elm$core$String$toLower(name))); + default: + var name = font.a.name; + return A2( + $elm$core$String$join, + '-', + $elm$core$String$words( + $elm$core$String$toLower(name))); + } + }()); + }); +var $mdgriffith$elm_ui$Internal$Model$rootStyle = function () { + var families = _List_fromArray( + [ + $mdgriffith$elm_ui$Internal$Model$Typeface('Open Sans'), + $mdgriffith$elm_ui$Internal$Model$Typeface('Helvetica'), + $mdgriffith$elm_ui$Internal$Model$Typeface('Verdana'), + $mdgriffith$elm_ui$Internal$Model$SansSerif + ]); + return _List_fromArray( + [ + A2( + $mdgriffith$elm_ui$Internal$Model$StyleClass, + $mdgriffith$elm_ui$Internal$Flag$bgColor, + A3( + $mdgriffith$elm_ui$Internal$Model$Colored, + 'bg-' + $mdgriffith$elm_ui$Internal$Model$formatColorClass( + A4($mdgriffith$elm_ui$Internal$Model$Rgba, 1, 1, 1, 0)), + 'background-color', + A4($mdgriffith$elm_ui$Internal$Model$Rgba, 1, 1, 1, 0))), + A2( + $mdgriffith$elm_ui$Internal$Model$StyleClass, + $mdgriffith$elm_ui$Internal$Flag$fontColor, + A3( + $mdgriffith$elm_ui$Internal$Model$Colored, + 'fc-' + $mdgriffith$elm_ui$Internal$Model$formatColorClass( + A4($mdgriffith$elm_ui$Internal$Model$Rgba, 0, 0, 0, 1)), + 'color', + A4($mdgriffith$elm_ui$Internal$Model$Rgba, 0, 0, 0, 1))), + A2( + $mdgriffith$elm_ui$Internal$Model$StyleClass, + $mdgriffith$elm_ui$Internal$Flag$fontSize, + $mdgriffith$elm_ui$Internal$Model$FontSize(20)), + A2( + $mdgriffith$elm_ui$Internal$Model$StyleClass, + $mdgriffith$elm_ui$Internal$Flag$fontFamily, + A2( + $mdgriffith$elm_ui$Internal$Model$FontFamily, + A3($elm$core$List$foldl, $mdgriffith$elm_ui$Internal$Model$renderFontClassName, 'font-', families), + families)) + ]); +}(); +var $mdgriffith$elm_ui$Element$layoutWith = F3( + function (_v0, attrs, child) { + var options = _v0.options; + return A3( + $mdgriffith$elm_ui$Internal$Model$renderRoot, + options, + A2( + $elm$core$List$cons, + $mdgriffith$elm_ui$Internal$Model$htmlClass( + A2( + $elm$core$String$join, + ' ', + _List_fromArray( + [$mdgriffith$elm_ui$Internal$Style$classes.root, $mdgriffith$elm_ui$Internal$Style$classes.any, $mdgriffith$elm_ui$Internal$Style$classes.single]))), + _Utils_ap($mdgriffith$elm_ui$Internal$Model$rootStyle, attrs)), + child); + }); +var $mdgriffith$elm_ui$Element$layout = $mdgriffith$elm_ui$Element$layoutWith( + {options: _List_Nil}); +var $mdgriffith$elm_ui$Internal$Model$Text = function (a) { + return {$: 'Text', a: a}; +}; +var $mdgriffith$elm_ui$Element$text = function (content) { + return $mdgriffith$elm_ui$Internal$Model$Text(content); +}; +var $author$project$Main$lessonPreview = function (lesson) { + return A2( + $mdgriffith$elm_ui$Element$el, + _List_Nil, + A2( + $mdgriffith$elm_ui$Element$column, + _List_Nil, + _List_fromArray( + [ + $mdgriffith$elm_ui$Element$text( + 'Lesson: ' + $elm$core$String$fromInt(lesson.id)), + $mdgriffith$elm_ui$Element$text(lesson.text) + ]))); +}; +var $elm$core$Dict$values = function (dict) { + return A3( + $elm$core$Dict$foldr, + F3( + function (key, value, valueList) { + return A2($elm$core$List$cons, value, valueList); + }), + _List_Nil, + dict); +}; +var $author$project$Main$lessonsView = function (lessons) { + return A2( + $mdgriffith$elm_ui$Element$column, + _List_Nil, + A2( + $elm$core$List$map, + $author$project$Main$lessonPreview, + $elm$core$Dict$values(lessons))); +}; +var $mdgriffith$elm_ui$Internal$Model$AsRow = {$: 'AsRow'}; +var $mdgriffith$elm_ui$Internal$Model$asRow = $mdgriffith$elm_ui$Internal$Model$AsRow; +var $mdgriffith$elm_ui$Element$row = F2( + function (attrs, children) { + return A4( + $mdgriffith$elm_ui$Internal$Model$element, + $mdgriffith$elm_ui$Internal$Model$asRow, + $mdgriffith$elm_ui$Internal$Model$div, + A2( + $elm$core$List$cons, + $mdgriffith$elm_ui$Internal$Model$htmlClass($mdgriffith$elm_ui$Internal$Style$classes.contentLeft + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.contentCenterY)), + A2( + $elm$core$List$cons, + $mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$shrink), + A2( + $elm$core$List$cons, + $mdgriffith$elm_ui$Element$height($mdgriffith$elm_ui$Element$shrink), + attrs))), + $mdgriffith$elm_ui$Internal$Model$Unkeyed(children)); + }); +var $author$project$Main$UserSelectedTab = function (a) { + return {$: 'UserSelectedTab', a: a}; +}; +var $mdgriffith$elm_ui$Internal$Model$AlignY = function (a) { + return {$: 'AlignY', a: a}; +}; +var $mdgriffith$elm_ui$Internal$Model$CenterY = {$: 'CenterY'}; +var $mdgriffith$elm_ui$Element$centerY = $mdgriffith$elm_ui$Internal$Model$AlignY($mdgriffith$elm_ui$Internal$Model$CenterY); +var $mdgriffith$elm_ui$Internal$Flag$borderColor = $mdgriffith$elm_ui$Internal$Flag$flag(28); +var $mdgriffith$elm_ui$Element$Border$color = function (clr) { + return A2( + $mdgriffith$elm_ui$Internal$Model$StyleClass, + $mdgriffith$elm_ui$Internal$Flag$borderColor, + A3( + $mdgriffith$elm_ui$Internal$Model$Colored, + 'bc-' + $mdgriffith$elm_ui$Internal$Model$formatColorClass(clr), + 'border-color', + clr)); +}; +var $mdgriffith$elm_ui$Element$rgb255 = F3( + function (red, green, blue) { + return A4($mdgriffith$elm_ui$Internal$Model$Rgba, red / 255, green / 255, blue / 255, 1); + }); +var $author$project$Main$color = { + blue: A3($mdgriffith$elm_ui$Element$rgb255, 114, 159, 207), + darkCharcoal: A3($mdgriffith$elm_ui$Element$rgb255, 46, 52, 54), + lightBlue: A3($mdgriffith$elm_ui$Element$rgb255, 197, 232, 247), + lightGrey: A3($mdgriffith$elm_ui$Element$rgb255, 224, 224, 224), + white: A3($mdgriffith$elm_ui$Element$rgb255, 255, 255, 255) +}; +var $elm$core$Basics$composeL = F3( + function (g, f, x) { + return g( + f(x)); + }); +var $elm$virtual_dom$VirtualDom$Normal = function (a) { + return {$: 'Normal', a: a}; +}; +var $elm$virtual_dom$VirtualDom$on = _VirtualDom_on; +var $elm$html$Html$Events$on = F2( + function (event, decoder) { + return A2( + $elm$virtual_dom$VirtualDom$on, + event, + $elm$virtual_dom$VirtualDom$Normal(decoder)); + }); +var $elm$html$Html$Events$onClick = function (msg) { + return A2( + $elm$html$Html$Events$on, + 'click', + $elm$json$Json$Decode$succeed(msg)); +}; +var $mdgriffith$elm_ui$Element$Events$onClick = A2($elm$core$Basics$composeL, $mdgriffith$elm_ui$Internal$Model$Attr, $elm$html$Html$Events$onClick); +var $mdgriffith$elm_ui$Internal$Model$PaddingStyle = F5( + function (a, b, c, d, e) { + return {$: 'PaddingStyle', a: a, b: b, c: c, d: d, e: e}; + }); +var $mdgriffith$elm_ui$Internal$Flag$padding = $mdgriffith$elm_ui$Internal$Flag$flag(2); +var $mdgriffith$elm_ui$Internal$Model$paddingName = F4( + function (top, right, bottom, left) { + return 'pad-' + ($elm$core$String$fromInt(top) + ('-' + ($elm$core$String$fromInt(right) + ('-' + ($elm$core$String$fromInt(bottom) + ('-' + $elm$core$String$fromInt(left))))))); + }); +var $mdgriffith$elm_ui$Element$paddingEach = function (_v0) { + var left = _v0.left; + var bottom = _v0.bottom; + var right = _v0.right; + var top = _v0.top; + if (_Utils_eq(top, right) && (_Utils_eq(top, bottom) && _Utils_eq(top, left))) { + var topFloat = top; + return A2( + $mdgriffith$elm_ui$Internal$Model$StyleClass, + $mdgriffith$elm_ui$Internal$Flag$padding, + A5( + $mdgriffith$elm_ui$Internal$Model$PaddingStyle, + 'p-' + $elm$core$String$fromInt(top), + topFloat, + topFloat, + topFloat, + topFloat)); + } else { + return A2( + $mdgriffith$elm_ui$Internal$Model$StyleClass, + $mdgriffith$elm_ui$Internal$Flag$padding, + A5( + $mdgriffith$elm_ui$Internal$Model$PaddingStyle, + A4($mdgriffith$elm_ui$Internal$Model$paddingName, top, right, bottom, left), + top, + right, + bottom, + left)); + } +}; +var $mdgriffith$elm_ui$Internal$Flag$borderRound = $mdgriffith$elm_ui$Internal$Flag$flag(17); +var $mdgriffith$elm_ui$Element$Border$roundEach = function (_v0) { + var bottomRight = _v0.bottomRight; + var bottomLeft = _v0.bottomLeft; + var topRight = _v0.topRight; + var topLeft = _v0.topLeft; + return A2( + $mdgriffith$elm_ui$Internal$Model$StyleClass, + $mdgriffith$elm_ui$Internal$Flag$borderRound, + A3( + $mdgriffith$elm_ui$Internal$Model$Single, + 'br-' + ($elm$core$String$fromInt(topLeft) + ('-' + ($elm$core$String$fromInt(topRight) + ($elm$core$String$fromInt(bottomLeft) + ('-' + $elm$core$String$fromInt(bottomRight)))))), + 'border-radius', + $elm$core$String$fromInt(topLeft) + ('px ' + ($elm$core$String$fromInt(topRight) + ('px ' + ($elm$core$String$fromInt(bottomRight) + ('px ' + ($elm$core$String$fromInt(bottomLeft) + 'px')))))))); +}; +var $mdgriffith$elm_ui$Internal$Model$BorderWidth = F5( + function (a, b, c, d, e) { + return {$: 'BorderWidth', a: a, b: b, c: c, d: d, e: e}; + }); +var $mdgriffith$elm_ui$Element$Border$width = function (v) { + return A2( + $mdgriffith$elm_ui$Internal$Model$StyleClass, + $mdgriffith$elm_ui$Internal$Flag$borderWidth, + A5( + $mdgriffith$elm_ui$Internal$Model$BorderWidth, + 'b-' + $elm$core$String$fromInt(v), + v, + v, + v, + v)); +}; +var $mdgriffith$elm_ui$Element$Border$widthXY = F2( + function (x, y) { + return A2( + $mdgriffith$elm_ui$Internal$Model$StyleClass, + $mdgriffith$elm_ui$Internal$Flag$borderWidth, + A5( + $mdgriffith$elm_ui$Internal$Model$BorderWidth, + 'b-' + ($elm$core$String$fromInt(x) + ('-' + $elm$core$String$fromInt(y))), + y, + x, + y, + x)); + }); +var $mdgriffith$elm_ui$Element$Border$widthEach = function (_v0) { + var right = _v0.right; + var left = _v0.left; + var top = _v0.top; + var bottom = _v0.bottom; + return (_Utils_eq(top, bottom) && _Utils_eq(left, right)) ? (_Utils_eq(top, right) ? $mdgriffith$elm_ui$Element$Border$width(top) : A2($mdgriffith$elm_ui$Element$Border$widthXY, left, top)) : A2( + $mdgriffith$elm_ui$Internal$Model$StyleClass, + $mdgriffith$elm_ui$Internal$Flag$borderWidth, + A5( + $mdgriffith$elm_ui$Internal$Model$BorderWidth, + 'b-' + ($elm$core$String$fromInt(top) + ('-' + ($elm$core$String$fromInt(right) + ('-' + ($elm$core$String$fromInt(bottom) + ('-' + $elm$core$String$fromInt(left))))))), + top, + right, + bottom, + left)); +}; +var $author$project$Main$tabEl = F2( + function (tab, selectedTab) { + var isSelected = _Utils_eq(tab, selectedTab); + var padOffset = isSelected ? 0 : 2; + var corners = isSelected ? {bottomLeft: 0, bottomRight: 0, topLeft: 6, topRight: 6} : {bottomLeft: 0, bottomRight: 0, topLeft: 0, topRight: 0}; + var borderWidths = isSelected ? {bottom: 0, left: 2, right: 2, top: 2} : {bottom: 2, left: 0, right: 0, top: 0}; + return A2( + $mdgriffith$elm_ui$Element$el, + _List_fromArray( + [ + $mdgriffith$elm_ui$Element$Border$widthEach(borderWidths), + $mdgriffith$elm_ui$Element$Border$roundEach(corners), + $mdgriffith$elm_ui$Element$Border$color($author$project$Main$color.blue), + $mdgriffith$elm_ui$Element$Events$onClick( + $author$project$Main$UserSelectedTab(tab)) + ]), + A2( + $mdgriffith$elm_ui$Element$el, + _List_fromArray( + [ + $mdgriffith$elm_ui$Element$centerX, + $mdgriffith$elm_ui$Element$centerY, + $mdgriffith$elm_ui$Element$paddingEach( + {bottom: 10 - padOffset, left: 30, right: 30, top: 10 + padOffset}) + ]), + $mdgriffith$elm_ui$Element$text( + function () { + switch (tab.$) { + case 'Lessons': + return 'Lessons'; + case 'Words': + return 'Words'; + default: + return 'Audio'; + } + }()))); + }); +var $author$project$Main$view = function (model) { + return model.isLoading ? A2( + $mdgriffith$elm_ui$Element$layout, + _List_Nil, + $mdgriffith$elm_ui$Element$text('...')) : A2( + $mdgriffith$elm_ui$Element$layout, + _List_fromArray( + [ + $mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$fill), + $mdgriffith$elm_ui$Element$height($mdgriffith$elm_ui$Element$fill) + ]), + A2( + $mdgriffith$elm_ui$Element$column, + _List_fromArray( + [$mdgriffith$elm_ui$Element$centerX]), + _List_fromArray( + [ + A2( + $mdgriffith$elm_ui$Element$row, + _List_Nil, + _List_fromArray( + [ + A2($author$project$Main$tabEl, $author$project$Main$Lessons, model.tab), + A2($author$project$Main$tabEl, $author$project$Main$Words, model.tab), + A2($author$project$Main$tabEl, $author$project$Main$Pronunciation, model.tab) + ])), + _Utils_eq(model.tab, $author$project$Main$Lessons) ? $author$project$Main$lessonsView(model.lessons) : A2( + $mdgriffith$elm_ui$Element$el, + _List_Nil, + $mdgriffith$elm_ui$Element$text('WIP')) + ]))); +}; +var $author$project$Main$main = $elm$browser$Browser$element( + { + init: $author$project$Main$init, + subscriptions: function (_v0) { + return $elm$core$Platform$Sub$none; + }, + update: $author$project$Main$update, + view: $author$project$Main$view + }); +_Platform_export({'Main':{'init':$author$project$Main$main( + $elm$json$Json$Decode$succeed(_Utils_Tuple0))(0)}});}(this)); \ No newline at end of file diff --git a/ui/elm.json b/ui/elm.json index 5398be3..7cd88ec 100644 --- a/ui/elm.json +++ b/ui/elm.json @@ -9,10 +9,13 @@ "elm/browser": "1.0.2", "elm/core": "1.0.5", "elm/html": "1.0.0", + "elm/http": "2.0.0", + "elm/json": "1.1.3", "mdgriffith/elm-ui": "1.1.8" }, "indirect": { - "elm/json": "1.1.3", + "elm/bytes": "1.0.8", + "elm/file": "1.0.5", "elm/time": "1.0.0", "elm/url": "1.0.0", "elm/virtual-dom": "1.0.3" diff --git a/ui/index.html b/ui/index.html index e69de29..1a37638 100644 --- a/ui/index.html +++ b/ui/index.html @@ -0,0 +1,24 @@ + + + + + Prosody + + +
+ + + + + SELECT + l.id, l.text, cards.text, cards.note + FROM cards_lessons cl + JOIN lessons l ON l.id = cl.lesson_id + JOIN cards ON cards.id = lc.card_id + LIMIT 20 + OFFSET 0 + BY l.id ASC diff --git a/ui/src/Api.elm b/ui/src/Api.elm new file mode 100644 index 0000000..bcbec63 --- /dev/null +++ b/ui/src/Api.elm @@ -0,0 +1,113 @@ +module Api exposing (Card, Lesson, Lessons, ServerResponse(..), fetchLessons) + +import Dict exposing (Dict) +import Http +import Json.Decode as Decode + + + +-- data types + + +type alias Card = + { text : String + , note : Maybe String + , id : Int + } + + +type alias Lesson = + { text : String + , id : Int + , cards : List Card + } + + +type alias Lessons = + Dict Int Lesson + + +type ServerResponse + = OkResponse Lessons + | ErrorResponse String + + + +-- json decoders + + +serverResponseDecoder : Decode.Decoder ServerResponse +serverResponseDecoder = + Decode.oneOf + [ Decode.map OkResponse + (Decode.field "ok" lessonsDecoder) + , Decode.map ErrorResponse (Decode.field "error" Decode.string) + ] + + +cardDecoder : Decode.Decoder Card +cardDecoder = + Decode.map3 Card + (Decode.field "text" Decode.string) + (Decode.field "note" (Decode.maybe Decode.string)) + (Decode.field "id" Decode.int) + + +lessonDecoder : Decode.Decoder Lesson +lessonDecoder = + Decode.map3 Lesson + (Decode.field "text" Decode.string) + (Decode.field "id" Decode.int) + (Decode.field "cards" (Decode.list cardDecoder)) + + +lessonsDecoder : Decode.Decoder Lessons +lessonsDecoder = + Decode.dict lessonDecoder + |> Decode.andThen convertKeysToIntDict + + +convertKeysToIntDict : Dict String Lesson -> Decode.Decoder Lessons +convertKeysToIntDict stringKeyedDict = + stringKeyedDict + |> Dict.toList + |> List.map (\( key, lesson ) -> ( String.toInt key, lesson )) + |> List.foldl + (\maybePair acc -> + case maybePair of + ( Just intKey, lesson ) -> + Dict.insert intKey lesson acc + + ( Nothing, _ ) -> + acc + ) + Dict.empty + |> Decode.succeed + + + +-- http command + + +fetchLessons : (Result Http.Error ServerResponse -> msg) -> Cmd msg +fetchLessons toMsg = + Http.get + { url = "http://localhost:3000/api/lessons" + , expect = Http.expectJson toMsg serverResponseDecoder + } + + + +-- FetchRawJsonHandler (Ok rawJson) -> +-- Debug.log "Raw json response" rawJson +-- |> (\_ -> +-- case Decode.decodeString lessonsDecoder rawJson of +-- Ok lessons -> +-- ( { model | lessons = lessons, isLoading = False }, Cmd.none ) +-- Err decodeError -> +-- Debug.log "Decode Error" decodeError +-- |> (\_ -> ( { model | isLoading = False }, Cmd.none )) +-- ) +-- FetchRawJsonHandler (Err httpError) -> +-- Debug.log "HTTP Error" httpError +-- |> (\_ -> ( { model | isLoading = False }, Cmd.none )) diff --git a/ui/src/Main.elm b/ui/src/Main.elm index 628b7d7..da55519 100644 --- a/ui/src/Main.elm +++ b/ui/src/Main.elm @@ -1,24 +1,190 @@ +module Main exposing (..) + +import Api exposing (Card, Lesson, Lessons, ServerResponse(..), fetchLessons) import Browser -import Html exposing (Html, button, div, text) -import Html.Events exposing (onClick) +import Dict exposing (Dict) +import Element exposing (..) +import Element.Background as Background +import Element.Border as Border +import Element.Events exposing (onClick) +import Element.Font as Font +import Html exposing (Html) +import Http -main = - Browser.sandbox { init = 0, update = update, view = view } --- user actions -type Msg = Increment | Decrement +type Tab + = Lessons + | Words + | Pronunciation + +type Msg + = UserSelectedTab Tab + | FetchDataHandler (Result Http.Error ServerResponse) + + + +-- state + + +type alias Model = + { lessons : Lessons + , tab : Tab + , isLoading : Bool + } + + +sampleLessons : Lessons +sampleLessons = + Dict.fromList [] + + +initialState : Model +initialState = + { isLoading = False + , lessons = sampleLessons + , tab = Lessons + } + + + +-- update + + +update : Msg -> Model -> ( Model, Cmd Msg ) update msg model = - case msg of - Increment -> - model + 1 + case msg of + UserSelectedTab t -> + ( { model | tab = t }, Cmd.none ) - Decrement -> - model - 1 + FetchDataHandler (Ok serres) -> + -- let + -- _ = + -- Debug.log "hi" serres + -- in + case serres of + OkResponse lessons -> + ( { model | lessons = lessons, isLoading = False }, Cmd.none ) + ErrorResponse _ -> + ( { model | isLoading = False }, Cmd.none ) + + FetchDataHandler (Err _) -> + ( { model | isLoading = False }, Cmd.none ) + + +view : Model -> Html Msg view model = - div [] - [ button [ onClick Decrement ] [ text "-" ] - , div [] [ text (String.fromInt model) ] - , button [ onClick Increment ] [ text "+" ] - ] + if model.isLoading then + layout [] (text "...") + + else + layout [ width fill, height fill ] <| + column + [ centerX ] + [ row [] + [ tabEl Lessons model.tab + , tabEl Words model.tab + , tabEl Pronunciation model.tab + ] + , if model.tab == Lessons then + lessonsView model.lessons + + else + el [] (text "WIP") + ] + + +tabEl : Tab -> Tab -> Element Msg +tabEl tab selectedTab = + let + isSelected = + tab == selectedTab + + padOffset = + if isSelected then + 0 + + else + 2 + + borderWidths = + if isSelected then + { left = 2, top = 2, right = 2, bottom = 0 } + + else + { bottom = 2, top = 0, left = 0, right = 0 } + + corners = + if isSelected then + { topLeft = 6, topRight = 6, bottomLeft = 0, bottomRight = 0 } + + else + { topLeft = 0, topRight = 0, bottomLeft = 0, bottomRight = 0 } + in + el + [ Border.widthEach borderWidths + , Border.roundEach corners + , Border.color color.blue + , onClick <| UserSelectedTab tab + ] + <| + el + [ centerX + , centerY + , paddingEach { left = 30, right = 30, top = 10 + padOffset, bottom = 10 - padOffset } + ] + <| + text <| + case tab of + Lessons -> + "Lessons" + + Words -> + "Words" + + Pronunciation -> + "Audio" + + +lessonsView : Lessons -> Element Msg +lessonsView lessons = + Dict.values lessons + |> List.map lessonPreview + |> column [] + + +lessonPreview : Lesson -> Element Msg +lessonPreview lesson = + el [] + (column [] + [ text ("Lesson: " ++ String.fromInt lesson.id) + , text lesson.text + ] + ) + + +init : flags -> ( Model, Cmd Msg ) +init flags = + Debug.log "Init flags" flags + |> (\_ -> Debug.log "Initial State" initialState) + |> (\_ -> ( initialState, fetchLessons FetchDataHandler )) + + +main : Program () Model Msg +main = + Browser.element + { init = init + , view = view + , update = update + , subscriptions = \_ -> Sub.none + } + + +color = + { blue = rgb255 0x72 0x9F 0xCF + , darkCharcoal = rgb255 0x2E 0x34 0x36 + , lightBlue = rgb255 0xC5 0xE8 0xF7 + , lightGrey = rgb255 0xE0 0xE0 0xE0 + , white = rgb255 0xFF 0xFF 0xFF + }