From 4e2fd913ab175d2811089f22fc83861bcd7f0b4f Mon Sep 17 00:00:00 2001
From: dvdrtrgn <dvdrtrgn@gmail.com>
Date: Mon, 12 Dec 2016 18:13:50 -0600
Subject: [PATCH 01/28] add record action

---
 01 - JavaScript Drum Kit/index.html | 23 +-------
 01 - JavaScript Drum Kit/play.js    | 20 +++++++
 01 - JavaScript Drum Kit/record.js  | 81 +++++++++++++++++++++++++++++
 3 files changed, 103 insertions(+), 21 deletions(-)
 create mode 100644 01 - JavaScript Drum Kit/play.js
 create mode 100644 01 - JavaScript Drum Kit/record.js

diff --git a/01 - JavaScript Drum Kit/index.html b/01 - JavaScript Drum Kit/index.html
index 246639f990..29bb8a64d0 100644
--- a/01 - JavaScript Drum Kit/index.html	
+++ b/01 - JavaScript Drum Kit/index.html	
@@ -57,27 +57,8 @@
   <audio data-key="75" src="sounds/tom.wav"></audio>
   <audio data-key="76" src="sounds/tink.wav"></audio>
 
-<script>
-
-
-  function playSound(e) {
-    const audio = document.querySelector(`audio[data-key="${e.keyCode}"]`);
-    const key = document.querySelector(`.key[data-key="${e.keyCode}"]`);
-    if (!audio) return; // stop the function from running all together
-    audio.currentTime = 0; // rewind to the start
-    audio.play();
-    key.classList.add('playing');
-  }
-  function removeTransition(e) {
-    if (e.propertyName !== 'transform') return; // skip it if it's not a transform
-    this.classList.remove('playing');
-  }
-
-  const keys = document.querySelectorAll('.key');
-  keys.forEach(key => key.addEventListener('transitionend', removeTransition));
-  window.addEventListener('keydown', playSound);
-
-</script>
+  <script src="play.js" charset="utf-8"></script>
+  <script src="record.js" charset="utf-8"></script>
 
 </body>
 </html>
diff --git a/01 - JavaScript Drum Kit/play.js b/01 - JavaScript Drum Kit/play.js
new file mode 100644
index 0000000000..324e24ceba
--- /dev/null
+++ b/01 - JavaScript Drum Kit/play.js	
@@ -0,0 +1,20 @@
+var lastKey;
+
+function playSound(e) {
+  const audio = document.querySelector(`audio[data-key="${e.keyCode}"]`);
+  const key = document.querySelector(`.key[data-key="${e.keyCode}"]`);
+  if (!audio) return; // stop the function from running all together
+  audio.currentTime = 0; // rewind to the start
+  audio.play();
+  key.classList.add('playing');
+  lastKey = e.keyCode;
+}
+
+function removeTransition(e) {
+  if (e.propertyName !== 'transform') return; // skip it if it's not a transform
+  this.classList.remove('playing');
+}
+
+const keys = document.querySelectorAll('.key');
+keys.forEach(key => key.addEventListener('transitionend', removeTransition));
+window.addEventListener('keydown', playSound);
diff --git a/01 - JavaScript Drum Kit/record.js b/01 - JavaScript Drum Kit/record.js
new file mode 100644
index 0000000000..e89f613ecc
--- /dev/null
+++ b/01 - JavaScript Drum Kit/record.js	
@@ -0,0 +1,81 @@
+var Record = (function () {
+
+  var recording;
+  var playing;
+  var buffer = [];
+  var index = -1;
+
+  function hitSpace(e) {
+    if (e.keyCode !== 32) return;
+
+    if (!buffer.length) {
+      recording = window.setInterval(recordKey, 100);
+    } else if (!playing) {
+      window.clearInterval(recording);
+      startPlaying();
+    } else {
+      stopPlaying();
+    }
+    console.log(buffer);
+  }
+
+  function playNext() {
+    insertKey();
+    index = (++index % buffer.length);
+    if (buffer[index]) {
+      autoKey(buffer[index]);
+    }
+  }
+
+  function recordKey() {
+    if (!lastKey && !buffer.length) return;
+    // trims leading silence
+
+    buffer.push(lastKey);
+    cleanKey(); // reset
+  }
+
+  function insertKey() {
+    if (!lastKey) return;
+    buffer[index] = lastKey;
+    cleanKey(); // reset
+  }
+
+  function autoKey(key) {
+    playSound({
+      keyCode: key,
+    });
+    cleanKey();
+  }
+
+  function stopPlaying() {
+    window.clearInterval(playing);
+    playing = undefined;
+  }
+
+  function startPlaying(num) {
+    index = num || -1;
+    if (!playing) {
+      playing = window.setInterval(playNext, 100);
+    }
+  }
+
+  function cleanKey() {
+    if (lastKey) console.log(lastKey);
+    lastKey = undefined;
+  }
+
+  window.addEventListener('keydown', hitSpace);
+
+  return {
+    addToBuffer: (...arr) => buffer.push(...arr),
+  };
+}());
+
+// cool beat
+// [75, 76, 75, 65, 70, 74, 71, undefined, 83, undefined, 72, 76, 74, 76, 76, 71, 74, 83, 76, 71, 75, 76, 65, 65, 74, 74, 75, 68, 83, undefined, 83, 68, 71, undefined]
+/*
+
+progress bar show how far the buffer pointer is
+
+*/

From 74525dca2e236d4099df1fa006082b21cc6714b4 Mon Sep 17 00:00:00 2001
From: dvdrtrgn <dvdrtrgn@gmail.com>
Date: Mon, 12 Dec 2016 22:02:20 -0600
Subject: [PATCH 02/28] refine record

---
 01 - JavaScript Drum Kit/index.html |   5 +
 01 - JavaScript Drum Kit/record.js  | 184 +++++++++++++++++++---------
 2 files changed, 128 insertions(+), 61 deletions(-)

diff --git a/01 - JavaScript Drum Kit/index.html b/01 - JavaScript Drum Kit/index.html
index 29bb8a64d0..c4015e6b88 100644
--- a/01 - JavaScript Drum Kit/index.html	
+++ b/01 - JavaScript Drum Kit/index.html	
@@ -7,6 +7,11 @@
 </head>
 <body>
 
+  <div id="Meter" style=" background-color: gray; position: absolute; text-align: center; width: 100%;">
+    <p style="color: white;">spacebar to play/record+stop/play</p>
+    <input style="margin: 1em; width: 90%;" type="range" min="0" max="99" step="1">
+    <button style="border-radius: 2em;">X</button>
+  </div>
 
   <div class="keys">
     <div data-key="65" class="key">
diff --git a/01 - JavaScript Drum Kit/record.js b/01 - JavaScript Drum Kit/record.js
index e89f613ecc..3c14f778d1 100644
--- a/01 - JavaScript Drum Kit/record.js	
+++ b/01 - JavaScript Drum Kit/record.js	
@@ -1,81 +1,143 @@
-var Record = (function () {
-
-  var recording;
-  var playing;
-  var buffer = [];
-  var index = -1;
+/*global lastKey */
 
-  function hitSpace(e) {
-    if (e.keyCode !== 32) return;
+var Record = (function () {
 
-    if (!buffer.length) {
-      recording = window.setInterval(recordKey, 100);
-    } else if (!playing) {
-      window.clearInterval(recording);
-      startPlaying();
+  var Index;
+  var tempo = 1000 / 8;
+  var int_rec;
+  var int_play;
+  var funky = [75, 76, 75, 65, 70, 74, 71, undefined, 83, undefined,
+    72, 76, 74, 76, 76, 71, 74, 83, 76, 71, 75,
+    76, 65, 65, 74, 74, 75, 68, 83, undefined, 83, 68, 71, undefined];
+
+  function keyPress(evt) {
+    //console.log(evt.keyCode);
+    if (evt.keyCode === 8) return Key.delete();
+    if (evt.keyCode !== 32) return; // not spacebar?
+
+    if (!int_rec && !Buffer.length) {
+      Index = -1;
+      int_rec = window.setInterval(Key.record, tempo);
+    } else if (!int_play) {
+      int_rec = window.clearInterval(int_rec);
+      Play.start(Index);
     } else {
-      stopPlaying();
-    }
-    console.log(buffer);
-  }
-
-  function playNext() {
-    insertKey();
-    index = (++index % buffer.length);
-    if (buffer[index]) {
-      autoKey(buffer[index]);
+      Play.stop();
     }
   }
 
-  function recordKey() {
-    if (!lastKey && !buffer.length) return;
-    // trims leading silence
-
-    buffer.push(lastKey);
-    cleanKey(); // reset
+  function advance() {
+    Meter.set(Index);
+    Index = (++Index % Buffer.length);
   }
 
-  function insertKey() {
-    if (!lastKey) return;
-    buffer[index] = lastKey;
-    cleanKey(); // reset
-  }
+  const Buffer = {
+    idx2pct: (num) => Math.min(Math.round(100 * num / Buffer.length), 100),
+    pct2idx: (num) => Math.min(Math.round(num / 100 * Buffer.length), Buffer.length),
+    arr: funky,
+    get length() {
+      return Buffer.arr.length;
+    },
+    get now() {
+      return Buffer.arr[Index];
+    },
+    set now(val) {
+      Buffer.arr[Index] = val;
+    },
+    push: function () {
+      Buffer.arr.push.apply(Buffer.arr, arguments);
+    },
+    clear: function () {
+      Buffer.arr.splice(0);
+      Meter.focus();
+      Meter.set(1);
+    },
+  };
 
-  function autoKey(key) {
-    playSound({
-      keyCode: key,
-    });
-    cleanKey();
-  }
+  const Key = {
+    delete: function () {
+      Buffer.now = undefined;
+    },
+    record: function () {
+      console.log('listening');
+      if (!lastKey && !Buffer.length) return; // trim leading silence
+      Buffer.push(lastKey);
+      Key.clean(true); // reset
+    },
+    insert: function () {
+      if (!lastKey) return;
+      Buffer.now = lastKey;
+      Key.clean(true); // reset
+    },
+    auto: function (key) {
+      playSound({
+        keyCode: key,
+      });
+      Key.clean();
+    },
+    clean: function (bool) {
+      if (bool && lastKey) {
+        console.log(Index, lastKey, Buffer.length);
+      }
+      lastKey = undefined;
+    },
+    bind: function () {
+      window.addEventListener('keydown', keyPress);
+    },
+  };
 
-  function stopPlaying() {
-    window.clearInterval(playing);
-    playing = undefined;
-  }
+  const Meter = {
+    ele: document.querySelector('#Meter input'),
+    del: document.querySelector('#Meter button'),
+    set: function (num) {
+      Meter.ele.value = Buffer.idx2pct(num || 0);
+    },
+    read: function () {
+      Index = Buffer.pct2idx(Meter.ele.value);
+    },
+    focus: function () {
+      Meter.ele.focus();
+    },
+    bind: function () {
+      Meter.ele.addEventListener('mouseup', Meter.read);
+      Meter.del.addEventListener('mouseup', Buffer.clear);
+      Meter.set();
+    },
+  };
 
-  function startPlaying(num) {
-    index = num || -1;
-    if (!playing) {
-      playing = window.setInterval(playNext, 100);
-    }
-  }
+  const Play = {
+    stop: function () {
+      window.clearInterval(int_play);
+      int_play = undefined;
+    },
+    start: function (num) {
+      Index = num || 0;
+      if (!int_play) {
+        int_play = window.setInterval(Play.next, tempo);
+      }
+    },
+    next: function () {
+      Key.insert();
+      advance();
+      if (Buffer.now) {
+        Key.auto(Buffer.now);
+      }
+    },
+  };
 
-  function cleanKey() {
-    if (lastKey) console.log(lastKey);
-    lastKey = undefined;
-  }
+  const Api = {
+    Buffer, Key, Meter, Play,
+  };
 
-  window.addEventListener('keydown', hitSpace);
+  Key.bind();
+  Meter.bind();
 
-  return {
-    addToBuffer: (...arr) => buffer.push(...arr),
-  };
+  console.debug(Api);
+  return Api;
 }());
 
-// cool beat
-// [75, 76, 75, 65, 70, 74, 71, undefined, 83, undefined, 72, 76, 74, 76, 76, 71, 74, 83, 76, 71, 75, 76, 65, 65, 74, 74, 75, 68, 83, undefined, 83, 68, 71, undefined]
 /*
 
-progress bar show how far the buffer pointer is
+
 
 */

From 8a79db4df72de9b1055d16fe59bbebd116c02fc5 Mon Sep 17 00:00:00 2001
From: dvdrtrgn <dvdrtrgn@gmail.com>
Date: Tue, 13 Dec 2016 21:44:22 -0600
Subject: [PATCH 03/28] attempt clock

---
 02 - JS + CSS Clock/index-START.html | 35 ++++++++++++++++++++++++++--
 1 file changed, 33 insertions(+), 2 deletions(-)

diff --git a/02 - JS + CSS Clock/index-START.html b/02 - JS + CSS Clock/index-START.html
index 2712384201..e75cd12af4 100644
--- a/02 - JS + CSS Clock/index-START.html	
+++ b/02 - JS + CSS Clock/index-START.html	
@@ -52,21 +52,52 @@
       position: relative;
       width: 100%;
       height: 100%;
-      transform: translateY(-3px); /* account for the height of the clock hands */
+      transform: translateY(-3px) rotate(90deg); /* account for the height of the clock hands */
     }
 
     .hand {
       width:50%;
-      height:6px;
       background:black;
       position: absolute;
       top:50%;
+      transform-origin: right;
+    }
+    .second-hand {
+      background-color: red;
+      height:2px;
+    }
+    .min-hand {
+      background-color: white;
+      height:4px;
+    }
+    .hour-hand {
+      background-color: black;
+      height:8px;
     }
 
   </style>
 
   <script>
+  var secondHand = document.querySelector('.second-hand');
+  var minsHand = document.querySelector('.min-hand');
+  var hourHand = document.querySelector('.hour-hand');
+
+  function setTime() {
+    var now = new Date(); // Date.now() + 8411544
+    var arr = [now.getSeconds(), now.getMinutes(), now.getHours()];
+
+    arr[0] *= (360 / 60);
+    arr[1] *= (360 / 60);
+    arr[2] *= (360 / 12);
+    arr[2] += arr[1] / 14; // tweak hour hand
+
+    secondHand.style.transform = `rotate(${arr[0]}deg)`;
+    minsHand.style.transform = `rotate(${arr[1]}deg)`;
+    hourHand.style.transform = `rotate(${arr[2]}deg)`;
+  }
 
+  setInterval(setTime, 1000);
+  setTime();
 
   </script>
 </body>

From 53663ca613386bfd15464d600ea3fe5ddd3c759e Mon Sep 17 00:00:00 2001
From: dvdrtrgn <dvdrtrgn@gmail.com>
Date: Tue, 13 Dec 2016 22:21:15 -0600
Subject: [PATCH 04/28] lil fixes

---
 01 - JavaScript Drum Kit/play.js   | 3 ++-
 01 - JavaScript Drum Kit/record.js | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/01 - JavaScript Drum Kit/play.js b/01 - JavaScript Drum Kit/play.js
index 324e24ceba..30b6a42c73 100644
--- a/01 - JavaScript Drum Kit/play.js	
+++ b/01 - JavaScript Drum Kit/play.js	
@@ -11,7 +11,8 @@ function playSound(e) {
 }
 
 function removeTransition(e) {
-  if (e.propertyName !== 'transform') return; // skip it if it's not a transform
+  /* this causes sticking
+  if (e.propertyName !== 'transform') return; // skip it if it's not a transform */
   this.classList.remove('playing');
 }
 
diff --git a/01 - JavaScript Drum Kit/record.js b/01 - JavaScript Drum Kit/record.js
index 3c14f778d1..8144f3aad0 100644
--- a/01 - JavaScript Drum Kit/record.js	
+++ b/01 - JavaScript Drum Kit/record.js	
@@ -132,7 +132,7 @@ var Record = (function () {
   Key.bind();
   Meter.bind();
 
-  console.debug(Api);
+  console.table(Api);
   return Api;
 }());
 

From fcfb498a1ef3894efb2e1f39a553dcb5f47f6f47 Mon Sep 17 00:00:00 2001
From: nadiarasul <nadia.rasul@gmail.com>
Date: Fri, 9 Dec 2016 15:21:35 -0500
Subject: [PATCH 05/28] adding women inventors

This is a random selection of female inventors for the dataset
---
 04 - Array Cardio Day 1/index-START.html | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/04 - Array Cardio Day 1/index-START.html b/04 - Array Cardio Day 1/index-START.html
index 6e28e357d0..9d9e3bef57 100644
--- a/04 - Array Cardio Day 1/index-START.html	
+++ b/04 - Array Cardio Day 1/index-START.html	
@@ -18,7 +18,12 @@
       { first: 'Marie', last: 'Curie', year: 1867, passed: 1934 },
       { first: 'Johannes', last: 'Kepler', year: 1571, passed: 1630 },
       { first: 'Nicolaus', last: 'Copernicus', year: 1473, passed: 1543 },
-      { first: 'Max', last: 'Planck', year: 1858, passed: 1947 }
+      { first: 'Max', last: 'Planck', year: 1858, passed: 1947 },
+      { first: 'Katherine', last: 'Blodgett', year: 1898, passed: 1979 },
+      { first: 'Ada', last: 'Lovelace', year: 1815, passed: 1852 },
+      { first: 'Sarah E.', last: 'Goode', year: 1855, passed: 1905 },
+      { first: 'Lise', last: 'Meitner', year: 1878, passed: 1968 },
+      { first: 'Hanna', last: 'Hammarström', year: 1829, passed: 1909 }
     ];
 
     const flavours = ['Chocolate Chip', 'Kulfi', 'Caramel Praline', 'Chocolate', 'Burnt Caramel', 'Pistachio', 'Rose', 'Sweet Coconut', 'Lemon Cookie', 'Toffeeness', 'Toasted Almond', 'Black Raspberry Crunch', 'Chocolate Brownies', 'Pistachio Almond', 'Strawberry', 'Lavender Honey', 'Lychee', 'Peach', 'Black Walnut', 'Birthday Cake', 'Mexican Chocolate', 'Mocha Almond Fudge', 'Raspberry'];

From b3a96e332c71d9c325d06464d85759286fb1eab3 Mon Sep 17 00:00:00 2001
From: nadiarasul <nadia.rasul@gmail.com>
Date: Fri, 9 Dec 2016 15:25:08 -0500
Subject: [PATCH 06/28] female inventors + change in const name

A random selection of female inventors for the dataset along with proposed change in const name.
---
 04 - Array Cardio Day 1/index-FINISHED.html | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/04 - Array Cardio Day 1/index-FINISHED.html b/04 - Array Cardio Day 1/index-FINISHED.html
index f68d8c3545..2436441cda 100644
--- a/04 - Array Cardio Day 1/index-FINISHED.html	
+++ b/04 - Array Cardio Day 1/index-FINISHED.html	
@@ -19,6 +19,11 @@
       { first: 'Johannes', last: 'Kepler', year: 1571, passed: 1630 },
       { first: 'Nicolaus', last: 'Copernicus', year: 1473, passed: 1543 },
       { first: 'Max', last: 'Planck', year: 1858, passed: 1947 },
+      { first: 'Katherine', last: 'Blodgett', year: 1898, passed: 1979 },
+      { first: 'Ada', last: 'Lovelace', year: 1815, passed: 1852 },
+      { first: 'Sarah E.', last: 'Goode', year: 1855, passed: 1905 },
+      { first: 'Lise', last: 'Meitner', year: 1878, passed: 1968 },
+      { first: 'Hanna', last: 'Hammarström', year: 1829, passed: 1909 }
     ];
 
     const people = ['Beck, Glenn', 'Becker, Carl', 'Beckett, Samuel', 'Beddoes, Mick', 'Beecher, Henry', 'Beethoven, Ludwig', 'Begin, Menachem', 'Belloc, Hilaire', 'Bellow, Saul', 'Benchley, Robert', 'Benenson, Peter', 'Ben-Gurion, David', 'Benjamin, Walter', 'Benn, Tony', 'Bennington, Chester', 'Benson, Leana', 'Bent, Silas', 'Bentsen, Lloyd', 'Berger, Ric', 'Bergman, Ingmar', 'Berio, Luciano', 'Berle, Milton', 'Berlin, Irving', 'Berne, Eric', 'Bernhard, Sandra', 'Berra, Yogi', 'Berry, Halle', 'Berry, Wendell', 'Bethea, Erin', 'Bevan, Aneurin', 'Bevel, Ken', 'Biden, Joseph', 'Bierce, Ambrose', 'Biko, Steve', 'Billings, Josh', 'Biondo, Frank', 'Birrell, Augustine', 'Black Elk', 'Blair, Robert', 'Blair, Tony', 'Blake, William'];
@@ -57,9 +62,9 @@
 
     // 5. Sort the inventors by years lived
     const oldest = inventors.sort(function(a, b) {
-      const lastGuy = a.passed - a.year;
-      const nextGuy = b.passed - b.year;
-      return lastGuy > nextGuy ? -1 : 1;
+      const lastInventor = a.passed - a.year;
+      const nextInventor = b.passed - b.year;
+      return lastInventor > nextInventor ? -1 : 1;
     });
     console.table(oldest);
 

From bc8ad2d070b9ad1915cf9b0485c407b045c6c720 Mon Sep 17 00:00:00 2001
From: Akshay Kadam <akshaykadam0904@gmail.com>
Date: Sat, 10 Dec 2016 02:01:01 +0530
Subject: [PATCH 07/28] Unused CSS :smile:

---
 03 - CSS Variables/index-FINISHED.html | 5 -----
 03 - CSS Variables/index-START.html    | 5 -----
 2 files changed, 10 deletions(-)

diff --git a/03 - CSS Variables/index-FINISHED.html b/03 - CSS Variables/index-FINISHED.html
index 9401d7b339..c3217fc003 100644
--- a/03 - CSS Variables/index-FINISHED.html	
+++ b/03 - CSS Variables/index-FINISHED.html	
@@ -57,11 +57,6 @@ <h2>Update CSS Variables with <span class='hl'>JS</span></h2>
       margin-bottom: 50px;
     }
 
-    a {
-      color: var(--base);
-      text-decoration: none;
-    }
-
     input {
       width:100px;
     }
diff --git a/03 - CSS Variables/index-START.html b/03 - CSS Variables/index-START.html
index bf0f33e3ba..7171607a8b 100644
--- a/03 - CSS Variables/index-START.html	
+++ b/03 - CSS Variables/index-START.html	
@@ -42,11 +42,6 @@ <h2>Update CSS Variables with <span class='hl'>JS</span></h2>
       margin-bottom: 50px;
     }
 
-    a {
-      color: var(--base);
-      text-decoration: none;
-    }
-
     input {
       width:100px;
     }

From ed7f5f2f8a1e0b7c63fc82852a20f06d5829eeca Mon Sep 17 00:00:00 2001
From: Jake Johnson <xyclos@users.noreply.github.com>
Date: Fri, 9 Dec 2016 23:46:07 -0500
Subject: [PATCH 08/28] typo: inventory > inventors'

---
 04 - Array Cardio Day 1/index-START.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/04 - Array Cardio Day 1/index-START.html b/04 - Array Cardio Day 1/index-START.html
index 9d9e3bef57..927fb03540 100644
--- a/04 - Array Cardio Day 1/index-START.html	
+++ b/04 - Array Cardio Day 1/index-START.html	
@@ -34,7 +34,7 @@
     // 1. Filter the list of inventors for those who were born in the 1500's
 
     // Array.prototype.map()
-    // 2. Give us an array of the inventory first and last names
+    // 2. Give us an array of the inventors' first and last names
 
     // Array.prototype.sort()
     // 3. Sort the inventors by birthdate, oldest to youngest

From 0dd3356509c4d345bc75c5fe957a5e255d14fc5a Mon Sep 17 00:00:00 2001
From: PiotrBerebecki <petebere@gmail.com>
Date: Sat, 10 Dec 2016 11:26:08 +0000
Subject: [PATCH 09/28] Fix typo in readme.md

---
 readme.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/readme.md b/readme.md
index 829f4d07f5..6c4ee28eea 100644
--- a/readme.md
+++ b/readme.md
@@ -12,4 +12,4 @@ These are meant to be 1:1 copies of what is done in the video. If you found a be
 
 The starter files + solutions will be updated if/when the videos are updated. 
 
-Thank!
+Thanks!

From 8421932734f561f19d7ec98c9503d493981ec6ec Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fede=20Guzm=C3=A1n?= <fedeguzman07@gmail.com>
Date: Sat, 10 Dec 2016 18:46:32 -0300
Subject: [PATCH 10/28] Removed the extra code from the start file

---
 07 - Array Cardio Day 2/index-START.html | 27 ------------------------
 1 file changed, 27 deletions(-)

diff --git a/07 - Array Cardio Day 2/index-START.html b/07 - Array Cardio Day 2/index-START.html
index bdf6c44415..b80ab6b650 100644
--- a/07 - Array Cardio Day 2/index-START.html	
+++ b/07 - Array Cardio Day 2/index-START.html	
@@ -25,42 +25,15 @@
 
     // Some and Every Checks
     // Array.prototype.some() // is at least one person 19?
-    // const isAdult = people.some(function(person) {
-    //   const currentYear = (new Date()).getFullYear();
-    //   if(currentYear - person.year >= 19) {
-    //     return true;
-    //   }
-    // });
-
-    const isAdult = people.some(person => ((new Date()).getFullYear()) - person.year >= 19);
-
-    console.log({isAdult});
     // Array.prototype.every() // is everyone 19?
 
-    const allAdults = people.every(person => ((new Date()).getFullYear()) - person.year >= 19);
-    console.log({allAdults});
-
     // Array.prototype.find()
     // Find is like filter, but instead returns just the one you are looking for
     // find the comment with the ID of 823423
 
-
-    const comment = comments.find(comment => comment.id === 823423);
-
-    console.log(comment);
-
     // Array.prototype.findIndex()
     // Find the comment with this ID
     // delete the comment with the ID of 823423
-    const index = comments.findIndex(comment => comment.id === 823423);
-    console.log(index);
-
-    // comments.splice(index, 1);
-
-    const newComments = [
-      ...comments.slice(0, index),
-      ...comments.slice(index + 1)
-    ];
 
   </script>
 </body>

From bc57dc610e8493d00963368fe8bc989c258350d5 Mon Sep 17 00:00:00 2001
From: Mitchel van Eijgen <mvaneijgen@gmail.com>
Date: Sun, 11 Dec 2016 11:25:38 +0100
Subject: [PATCH 11/28] 7. sort Exercise make it so it sorts on last name

In your video you still sort on the first name of the array but you called it `aLast` and `bLast` but they where in the first position of the array like this: `const [aLast, aFirst]` when changed to `const [aFirst, aLast]` it will filter on the second part of the array. There for it will sort on the last name.

To bad there is no way to pull request your video.
---
 04 - Array Cardio Day 1/index-FINISHED.html | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/04 - Array Cardio Day 1/index-FINISHED.html b/04 - Array Cardio Day 1/index-FINISHED.html
index 2436441cda..377d786a33 100644
--- a/04 - Array Cardio Day 1/index-FINISHED.html	
+++ b/04 - Array Cardio Day 1/index-FINISHED.html	
@@ -80,8 +80,8 @@
     // 7. sort Exercise
     // Sort the people alphabetically by last name
     const alpha = people.sort((lastOne, nextOne) => {
-      const [aLast, aFirst] = lastOne.split(', ');
-      const [bLast, bFirst] = nextOne.split(', ');
+      const [aFirst, aLast] = lastOne.split(', ');
+      const [bFirst, bLast] = nextOne.split(', ');
       return aLast > bLast ? 1 : -1;
     });
     console.log(alpha);

From fb740b79c0c6ae8747e0a675238500f7e327a80c Mon Sep 17 00:00:00 2001
From: Nitish Dayal <nitishdayal@users.noreply.github.com>
Date: Mon, 12 Dec 2016 02:54:03 -0800
Subject: [PATCH 12/28] Update readme.md

As requested by Wes Bos.
---
 readme.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/readme.md b/readme.md
index 6c4ee28eea..5a1eaa18c8 100644
--- a/readme.md
+++ b/readme.md
@@ -6,6 +6,8 @@ Starter Files + Completed solutions for the JavaScript 30 Day Challenge.
 
 Grab the course at [https://JavaScript30.com](https://JavaScript30.com)
 
+Text-based guides (unofficial) for the challenges can be found here - [Text Guides](https://github.com/nitishdayal/JavaScript30).
+
 ## Pull Requests
 
 These are meant to be 1:1 copies of what is done in the video. If you found a better / different way to do things, great, but I will be keeping them the same as the videos. 

From b95e8ca2cbffec1e17936786d96762029ebabdc1 Mon Sep 17 00:00:00 2001
From: claudiopro <claudio.procida@gmail.com>
Date: Mon, 12 Dec 2016 19:18:08 +0100
Subject: [PATCH 13/28] =?UTF-8?q?Massages=20Array=20Cardio=20challenges=20?=
 =?UTF-8?q?=F0=9F=92=AA?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 04 - Array Cardio Day 1/index-FINISHED.html | 1 +
 04 - Array Cardio Day 1/index-START.html    | 1 +
 07 - Array Cardio Day 2/index-FINISHED.html | 5 +++--
 07 - Array Cardio Day 2/index-START.html    | 5 +++--
 4 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/04 - Array Cardio Day 1/index-FINISHED.html b/04 - Array Cardio Day 1/index-FINISHED.html
index 377d786a33..e61b94c006 100644
--- a/04 - Array Cardio Day 1/index-FINISHED.html	
+++ b/04 - Array Cardio Day 1/index-FINISHED.html	
@@ -5,6 +5,7 @@
   <title>Array Cardio 💪</title>
 </head>
 <body>
+  <p><em>Psst: have a look at the JavaScript Console</em> 💁</p>
   <script>
     // Get your shorts on - this is an array workout!
     // ## Array Cardio Day 1
diff --git a/04 - Array Cardio Day 1/index-START.html b/04 - Array Cardio Day 1/index-START.html
index 927fb03540..4162bce339 100644
--- a/04 - Array Cardio Day 1/index-START.html	
+++ b/04 - Array Cardio Day 1/index-START.html	
@@ -5,6 +5,7 @@
   <title>Array Cardio 💪</title>
 </head>
 <body>
+  <p><em>Psst: have a look at the JavaScript Console</em> 💁</p>
   <script>
     // Get your shorts on - this is an array workout!
     // ## Array Cardio Day 1
diff --git a/07 - Array Cardio Day 2/index-FINISHED.html b/07 - Array Cardio Day 2/index-FINISHED.html
index e39d35f79a..c8e5b25d3b 100644
--- a/07 - Array Cardio Day 2/index-FINISHED.html	
+++ b/07 - Array Cardio Day 2/index-FINISHED.html	
@@ -2,9 +2,10 @@
 <html lang="en">
 <head>
   <meta charset="UTF-8">
-  <title>Document</title>
+  <title>Array Cardio 💪💪</title>
 </head>
 <body>
+  <p><em>Psst: have a look at the JavaScript Console</em> 💁</p>
   <script>
     // ## Array Cardio Day 2
 
@@ -19,7 +20,7 @@
       { text: 'Love this!', id: 523423 },
       { text: 'Super good', id: 823423 },
       { text: 'You are the best', id: 2039842 },
-      { text: 'Ramen in my fav food ever', id: 123523 },
+      { text: 'Ramen is my fav food ever', id: 123523 },
       { text: 'Nice Nice Nice!', id: 542328 }
     ];
 
diff --git a/07 - Array Cardio Day 2/index-START.html b/07 - Array Cardio Day 2/index-START.html
index b80ab6b650..206ec31aa0 100644
--- a/07 - Array Cardio Day 2/index-START.html	
+++ b/07 - Array Cardio Day 2/index-START.html	
@@ -2,9 +2,10 @@
 <html lang="en">
 <head>
   <meta charset="UTF-8">
-  <title>Document</title>
+  <title>Array Cardio 💪💪</title>
 </head>
 <body>
+  <p><em>Psst: have a look at the JavaScript Console</em> 💁</p>
   <script>
     // ## Array Cardio Day 2
 
@@ -19,7 +20,7 @@
       { text: 'Love this!', id: 523423 },
       { text: 'Super good', id: 823423 },
       { text: 'You are the best', id: 2039842 },
-      { text: 'Ramen in my fav food ever', id: 123523 },
+      { text: 'Ramen is my fav food ever', id: 123523 },
       { text: 'Nice Nice Nice!', id: 542328 }
     ];
 

From 335197cfc1e63f2a1a5200d4a19231743cb7ca24 Mon Sep 17 00:00:00 2001
From: Adam Baxter <voltagex@voltagex.org>
Date: Tue, 13 Dec 2016 10:14:56 +1100
Subject: [PATCH 14/28] Typo fix

---
 {29 - Countown Timer => 29 - Countdown Timer}/index.html          | 0
 {29 - Countown Timer => 29 - Countdown Timer}/scripts-FINISHED.js | 0
 {29 - Countown Timer => 29 - Countdown Timer}/scripts-START.js    | 0
 {29 - Countown Timer => 29 - Countdown Timer}/style.css           | 0
 4 files changed, 0 insertions(+), 0 deletions(-)
 rename {29 - Countown Timer => 29 - Countdown Timer}/index.html (100%)
 rename {29 - Countown Timer => 29 - Countdown Timer}/scripts-FINISHED.js (100%)
 rename {29 - Countown Timer => 29 - Countdown Timer}/scripts-START.js (100%)
 rename {29 - Countown Timer => 29 - Countdown Timer}/style.css (100%)

diff --git a/29 - Countown Timer/index.html b/29 - Countdown Timer/index.html
similarity index 100%
rename from 29 - Countown Timer/index.html
rename to 29 - Countdown Timer/index.html
diff --git a/29 - Countown Timer/scripts-FINISHED.js b/29 - Countdown Timer/scripts-FINISHED.js
similarity index 100%
rename from 29 - Countown Timer/scripts-FINISHED.js
rename to 29 - Countdown Timer/scripts-FINISHED.js
diff --git a/29 - Countown Timer/scripts-START.js b/29 - Countdown Timer/scripts-START.js
similarity index 100%
rename from 29 - Countown Timer/scripts-START.js
rename to 29 - Countdown Timer/scripts-START.js
diff --git a/29 - Countown Timer/style.css b/29 - Countdown Timer/style.css
similarity index 100%
rename from 29 - Countown Timer/style.css
rename to 29 - Countdown Timer/style.css

From 0457082b6e1b347eccc23bf785aa8147b27e34cf Mon Sep 17 00:00:00 2001
From: Tom Sullivan <tom@msbit.com.au>
Date: Wed, 14 Dec 2016 14:19:14 +1100
Subject: [PATCH 15/28] 24 - Sticky Nav: reset index and style START

Reset the contents of index-START and style-START to reflect the
contents before running through the video.
---
 24 - Sticky Nav/index-START.html | 15 +--------------
 24 - Sticky Nav/style-START.css  | 13 -------------
 2 files changed, 1 insertion(+), 27 deletions(-)

diff --git a/24 - Sticky Nav/index-START.html b/24 - Sticky Nav/index-START.html
index 4982537eea..e7bc67e9a5 100644
--- a/24 - Sticky Nav/index-START.html	
+++ b/24 - Sticky Nav/index-START.html	
@@ -54,20 +54,7 @@ <h1>A story about getting lost.</h1>
   </div>
 
 <script>
-  const nav = document.querySelector('#main');
-  const topOfNav = nav.offsetTop;
-
-  function fixNav() {
-    if(window.scrollY >= topOfNav) {
-      document.body.style.paddingTop = nav.offsetHeight + 'px';
-      document.body.classList.add('fixed-nav');
-    } else {
-      document.body.style.paddingTop = 0;
-      document.body.classList.remove('fixed-nav');
-    }
-  }
-
-  window.addEventListener('scroll', fixNav);
+
 </script>
 
 </body>
diff --git a/24 - Sticky Nav/style-START.css b/24 - Sticky Nav/style-START.css
index 19961112b4..c6d59a31b3 100644
--- a/24 - Sticky Nav/style-START.css	
+++ b/24 - Sticky Nav/style-START.css	
@@ -23,10 +23,6 @@ body {
   transition: transform 0.5s;
 }
 
-.fixed-nav .site-wrap {
-  transform: scale(1);
-}
-
 header {
   text-align: center;
   height:50vh;
@@ -52,11 +48,6 @@ nav {
   z-index: 1;
 }
 
-.fixed-nav nav {
-  position: fixed;
-  box-shadow: 0 5px rgba(0,0,0,0.1)
-}
-
 nav ul {
   margin: 0;
   padding:0;
@@ -81,10 +72,6 @@ li.logo {
   font-size: 30px;
 }
 
-.fixed-nav li.logo {
-  max-width:500px;
-}
-
 li.logo a {
   color:black;
 }

From 1e0da6f3156c020d891870771312024b072cf157 Mon Sep 17 00:00:00 2001
From: the-wazz <wazz4444@yahoo.com>
Date: Wed, 14 Dec 2016 01:30:07 -0500
Subject: [PATCH 16/28] Update index.html

spelling.
---
 01 - JavaScript Drum Kit/index.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/01 - JavaScript Drum Kit/index.html b/01 - JavaScript Drum Kit/index.html
index 246639f990..8b4fd26880 100644
--- a/01 - JavaScript Drum Kit/index.html	
+++ b/01 - JavaScript Drum Kit/index.html	
@@ -63,7 +63,7 @@
   function playSound(e) {
     const audio = document.querySelector(`audio[data-key="${e.keyCode}"]`);
     const key = document.querySelector(`.key[data-key="${e.keyCode}"]`);
-    if (!audio) return; // stop the function from running all together
+    if (!audio) return; // stop the function from running altogether
     audio.currentTime = 0; // rewind to the start
     audio.play();
     key.classList.add('playing');

From d14a2b7b832a504ab154e20e8c2cdabc1028fc7c Mon Sep 17 00:00:00 2001
From: Beau Smith <beau@beausmith.com>
Date: Wed, 14 Dec 2016 19:02:58 +0530
Subject: [PATCH 17/28] copy-pasta typo

---
 02 - JS + CSS Clock/index-FINISHED.html | 2 +-
 02 - JS + CSS Clock/index.html          | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/02 - JS + CSS Clock/index-FINISHED.html b/02 - JS + CSS Clock/index-FINISHED.html
index d4cb3b56a8..db653a5340 100644
--- a/02 - JS + CSS Clock/index-FINISHED.html	
+++ b/02 - JS + CSS Clock/index-FINISHED.html	
@@ -85,7 +85,7 @@
     minsHand.style.transform = `rotate(${minsDegrees}deg)`;
 
     const hour = now.getHours();
-    const hourDegrees = ((mins / 12) * 360) + 90;
+    const hourDegrees = ((hour / 12) * 360) + 90;
     hourHand.style.transform = `rotate(${hourDegrees}deg)`;
   }
 
diff --git a/02 - JS + CSS Clock/index.html b/02 - JS + CSS Clock/index.html
index 1c777557da..ae8908f3c9 100644
--- a/02 - JS + CSS Clock/index.html	
+++ b/02 - JS + CSS Clock/index.html	
@@ -84,8 +84,8 @@
     const minsDegrees = ((mins / 60) * 360) + 90;
     minsHand.style.transform = `rotate(${minsDegrees}deg)`;
 
-    const hour = now.getMinutes();
-    const hourDegrees = ((mins / 12) * 360) + 90;
+    const hour = now.getHours();
+    const hourDegrees = ((hour / 12) * 360) + 90;
     hourHand.style.transform = `rotate(${hourDegrees}deg)`;
   }
 

From b9b37ed3406f9d9b095558a32ca6237519c732e8 Mon Sep 17 00:00:00 2001
From: Beau Smith <beau@beausmith.com>
Date: Wed, 14 Dec 2016 20:43:52 +0530
Subject: [PATCH 18/28] Only START and FINISHED files are necessary.

---
 02 - JS + CSS Clock/index.html | 96 ----------------------------------
 1 file changed, 96 deletions(-)
 delete mode 100644 02 - JS + CSS Clock/index.html

diff --git a/02 - JS + CSS Clock/index.html b/02 - JS + CSS Clock/index.html
deleted file mode 100644
index ae8908f3c9..0000000000
--- a/02 - JS + CSS Clock/index.html	
+++ /dev/null
@@ -1,96 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <title>JS + CSS Clock</title>
-</head>
-<body>
-
-
-    <div class="clock">
-      <div class="clock-face">
-        <div class="hand hour-hand"></div>
-        <div class="hand min-hand"></div>
-        <div class="hand second-hand"></div>
-      </div>
-    </div>
-
-
-  <style>
-    html {
-      background:#018DED url(http://unsplash.it/1500/1000?image=881&blur=50);
-      background-size:cover;
-      font-family:'helvetica neue';
-      text-align: center;
-      font-size: 10px;
-    }
-
-    body {
-      font-size: 2rem;
-      display:flex;
-      flex:1;
-      min-height: 100vh;
-      align-items: center;
-    }
-
-    .clock {
-      width: 30rem;
-      height: 30rem;
-      border:20px solid white;
-      border-radius:50%;
-      margin:50px auto;
-      position: relative;
-      padding:2rem;
-      box-shadow:
-        0 0 0 4px rgba(0,0,0,0.1),
-        inset 0 0 0 3px #EFEFEF,
-        inset 0 0 10px black,
-        0 0 10px rgba(0,0,0,0.2);
-    }
-
-    .clock-face {
-      position: relative;
-      width: 100%;
-      height: 100%;
-      transform: translateY(-3px); /* account for the height of the clock hands */
-    }
-
-    .hand {
-      width:50%;
-      height:6px;
-      background:black;
-      position: absolute;
-      top:50%;
-      transform-origin: 100%;
-      transform: rotate(90deg);
-      transition: all 0.05s;
-      transition-timing-function: cubic-bezier(0.1, 2.7, 0.58, 1);
-    }
-</style>
-
-<script>
-  const secondHand = document.querySelector('.second-hand');
-  const minsHand = document.querySelector('.min-hand');
-  const hourHand = document.querySelector('.hour-hand');
-
-  function setDate() {
-    const now = new Date();
-
-    const seconds = now.getSeconds();
-    const secondsDegrees = ((seconds / 60) * 360) + 90;
-    secondHand.style.transform = `rotate(${secondsDegrees}deg)`;
-
-    const mins = now.getMinutes();
-    const minsDegrees = ((mins / 60) * 360) + 90;
-    minsHand.style.transform = `rotate(${minsDegrees}deg)`;
-
-    const hour = now.getHours();
-    const hourDegrees = ((hour / 12) * 360) + 90;
-    hourHand.style.transform = `rotate(${hourDegrees}deg)`;
-  }
-
-  setInterval(setDate, 1000);
-
-</script>
-</body>
-</html>

From 74f9110052ebc7ca2563df0b80f77eba04b0f48f Mon Sep 17 00:00:00 2001
From: Tamara Temple <tamouse@gmail.com>
Date: Wed, 14 Dec 2016 21:31:47 -0600
Subject: [PATCH 19/28] Remove Exercise 01 index.html file

This doesn't seem like it belongs here. The other exercises have the start
and finish files, this one seems like it's already been done for us.
---
 01 - JavaScript Drum Kit/index.html | 83 -----------------------------
 1 file changed, 83 deletions(-)
 delete mode 100644 01 - JavaScript Drum Kit/index.html

diff --git a/01 - JavaScript Drum Kit/index.html b/01 - JavaScript Drum Kit/index.html
deleted file mode 100644
index 8b4fd26880..0000000000
--- a/01 - JavaScript Drum Kit/index.html	
+++ /dev/null
@@ -1,83 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <title>JS Drum Kit</title>
-  <link rel="stylesheet" href="style.css">
-</head>
-<body>
-
-
-  <div class="keys">
-    <div data-key="65" class="key">
-      <kbd>A</kbd>
-      <span class="sound">clap</span>
-    </div>
-    <div data-key="83" class="key">
-      <kbd>S</kbd>
-      <span class="sound">hihat</span>
-    </div>
-    <div data-key="68" class="key">
-      <kbd>D</kbd>
-      <span class="sound">kick</span>
-    </div>
-    <div data-key="70" class="key">
-      <kbd>F</kbd>
-      <span class="sound">openhat</span>
-    </div>
-    <div data-key="71" class="key">
-      <kbd>G</kbd>
-      <span class="sound">boom</span>
-    </div>
-    <div data-key="72" class="key">
-      <kbd>H</kbd>
-      <span class="sound">ride</span>
-    </div>
-    <div data-key="74" class="key">
-      <kbd>J</kbd>
-      <span class="sound">snare</span>
-    </div>
-    <div data-key="75" class="key">
-      <kbd>K</kbd>
-      <span class="sound">tom</span>
-    </div>
-    <div data-key="76" class="key">
-      <kbd>L</kbd>
-      <span class="sound">tink</span>
-    </div>
-  </div>
-
-  <audio data-key="65" src="sounds/clap.wav"></audio>
-  <audio data-key="83" src="sounds/hihat.wav"></audio>
-  <audio data-key="68" src="sounds/kick.wav"></audio>
-  <audio data-key="70" src="sounds/openhat.wav"></audio>
-  <audio data-key="71" src="sounds/boom.wav"></audio>
-  <audio data-key="72" src="sounds/ride.wav"></audio>
-  <audio data-key="74" src="sounds/snare.wav"></audio>
-  <audio data-key="75" src="sounds/tom.wav"></audio>
-  <audio data-key="76" src="sounds/tink.wav"></audio>
-
-<script>
-
-
-  function playSound(e) {
-    const audio = document.querySelector(`audio[data-key="${e.keyCode}"]`);
-    const key = document.querySelector(`.key[data-key="${e.keyCode}"]`);
-    if (!audio) return; // stop the function from running altogether
-    audio.currentTime = 0; // rewind to the start
-    audio.play();
-    key.classList.add('playing');
-  }
-  function removeTransition(e) {
-    if (e.propertyName !== 'transform') return; // skip it if it's not a transform
-    this.classList.remove('playing');
-  }
-
-  const keys = document.querySelectorAll('.key');
-  keys.forEach(key => key.addEventListener('transitionend', removeTransition));
-  window.addEventListener('keydown', playSound);
-
-</script>
-
-</body>
-</html>

From c25612af9ab127bed370d90a8a0a8f8215087019 Mon Sep 17 00:00:00 2001
From: Aristotle Rovithis <aristotle.rovithis@gmail.com>
Date: Fri, 16 Dec 2016 06:21:09 -0500
Subject: [PATCH 20/28] removed answer code from index-START.html Ex 13

---
 13 - Slide in on Scroll/index-START.html | 20 --------------------
 1 file changed, 20 deletions(-)

diff --git a/13 - Slide in on Scroll/index-START.html b/13 - Slide in on Scroll/index-START.html
index 12591bad30..0b9fb8fccb 100644
--- a/13 - Slide in on Scroll/index-START.html	
+++ b/13 - Slide in on Scroll/index-START.html	
@@ -58,26 +58,6 @@ <h1>Slide in on Scroll</h1>
       };
     }
 
-    const sliderImages = document.querySelectorAll('.slide-in');
-
-    function checkSlide(e) {
-      sliderImages.forEach(sliderImage => {
-        // half way through the image
-        const slideInAt = (window.scrollY + window.innerHeight) - sliderImage.height / 2;
-        // bottom of the image
-        const imageBottom = sliderImage.offsetTop + sliderImage.height;
-        const isHalfShown = slideInAt > sliderImage.offsetTop;
-        const isNotScrolledPast = window.scrollY < imageBottom;
-        if (isHalfShown && isNotScrolledPast) {
-          sliderImage.classList.add('active');
-        } else {
-          sliderImage.classList.remove('active');
-        }
-      });
-    }
-
-    window.addEventListener('scroll', debounce(checkSlide));
-
   </script>
 
   <style>

From 1d6493759a5a8f08002d8d046dda12a6eff2dd94 Mon Sep 17 00:00:00 2001
From: dvdrtrgn <dvdrtrgn@gmail.com>
Date: Mon, 19 Dec 2016 22:03:32 -0600
Subject: [PATCH 21/28] attempt range clicker

---
 .../index-START.html                          | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/10 - Hold Shift and Check Checkboxes/index-START.html b/10 - Hold Shift and Check Checkboxes/index-START.html
index eb7ed310bb..8db0c9a1d7 100644
--- a/10 - Hold Shift and Check Checkboxes/index-START.html	
+++ b/10 - Hold Shift and Check Checkboxes/index-START.html	
@@ -104,6 +104,39 @@
   </div>
 
 <script>
+var Api = (function () {
+  var $ = (sel) => Array.from(document.querySelectorAll(sel));
+  var boxlist = $('.item input');
+  var indexes = {};
+  var self;
+
+  function reverser(bool) {
+    var [start, end] = [indexes.last, indexes.this].sort();
+    var arr = boxlist.slice(start, end + 1);
+    arr.forEach(el => el.checked = bool);
+  }
+
+  function updateLast(evt, num) {
+    indexes.last = evt.shiftKey ? indexes.this : num;
+    indexes.this = num;
+    reverser(evt.target.checked);
+  }
+
+  function doBinding(arr) {
+    arr.forEach((ele, idx) => {
+      ele.addEventListener('click', (evt) => updateLast(evt, idx));
+    });
+    return self;
+  }
+
+  self = {
+    init: doBinding,
+    boxlist, indexes,
+  };
+
+  return self.init(boxlist);
+}());
+
 </script>
 </body>
 </html>

From e9dde7fa28aa49c51e65548fbb6f3fea1d807a90 Mon Sep 17 00:00:00 2001
From: dvdrtrgn <dvdrtrgn@gmail.com>
Date: Tue, 20 Dec 2016 11:33:22 -0600
Subject: [PATCH 22/28] doc and clarify

---
 .../index-START.html                          | 20 ++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/10 - Hold Shift and Check Checkboxes/index-START.html b/10 - Hold Shift and Check Checkboxes/index-START.html
index 8db0c9a1d7..0802cc4337 100644
--- a/10 - Hold Shift and Check Checkboxes/index-START.html	
+++ b/10 - Hold Shift and Check Checkboxes/index-START.html	
@@ -105,26 +105,28 @@
 
 <script>
 var Api = (function () {
+  // polyfill for jQuery
   var $ = (sel) => Array.from(document.querySelectorAll(sel));
   var boxlist = $('.item input');
-  var indexes = {};
+  var indexes = {}; // memory for box clicks
   var self;
 
-  function reverser(bool) {
-    var [start, end] = [indexes.last, indexes.this].sort();
+  function setChecked(bool) {
+    // ensure lower index comes first
+    var [start, end] = [indexes.last, indexes.next].sort();
     var arr = boxlist.slice(start, end + 1);
-    arr.forEach(el => el.checked = bool);
+    arr.forEach((el) => el.checked = bool);
   }
 
-  function updateLast(evt, num) {
-    indexes.last = evt.shiftKey ? indexes.this : num;
-    indexes.this = num;
-    reverser(evt.target.checked);
+  function revIndexes(evt, num) {
+    indexes.last = evt.shiftKey ? indexes.next : num;
+    indexes.next = num;
+    setChecked(evt.target.checked); // replicate this state
   }
 
   function doBinding(arr) {
     arr.forEach((ele, idx) => {
-      ele.addEventListener('click', (evt) => updateLast(evt, idx));
+      ele.addEventListener('click', (evt) => revIndexes(evt, idx));
     });
     return self;
   }

From a1862a427422073628106a71232467a294bdcaae Mon Sep 17 00:00:00 2001
From: dvdrtrgn <dvdrtrgn@gmail.com>
Date: Tue, 20 Dec 2016 13:10:14 -0600
Subject: [PATCH 23/28] make index intrinsic

---
 10 - Hold Shift and Check Checkboxes/index-START.html | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/10 - Hold Shift and Check Checkboxes/index-START.html b/10 - Hold Shift and Check Checkboxes/index-START.html
index 0802cc4337..89828e49c4 100644
--- a/10 - Hold Shift and Check Checkboxes/index-START.html	
+++ b/10 - Hold Shift and Check Checkboxes/index-START.html	
@@ -118,15 +118,16 @@
     arr.forEach((el) => el.checked = bool);
   }
 
-  function revIndexes(evt, num) {
+  function revIndexes(evt) {
+    var num = boxlist.indexOf(evt.target);
     indexes.last = evt.shiftKey ? indexes.next : num;
     indexes.next = num;
     setChecked(evt.target.checked); // replicate this state
   }
 
   function doBinding(arr) {
-    arr.forEach((ele, idx) => {
-      ele.addEventListener('click', (evt) => revIndexes(evt, idx));
+    arr.forEach((ele) => {
+      ele.addEventListener('click', revIndexes);
     });
     return self;
   }

From c0835127cdc9d0c62cef1923701629872d01392c Mon Sep 17 00:00:00 2001
From: dvdrtrgn <dvdrtrgn@gmail.com>
Date: Tue, 20 Dec 2016 16:17:13 -0600
Subject: [PATCH 24/28] allow boxlist updates

---
 .../index-START.html                          | 22 +++++++++++++------
 1 file changed, 15 insertions(+), 7 deletions(-)

diff --git a/10 - Hold Shift and Check Checkboxes/index-START.html b/10 - Hold Shift and Check Checkboxes/index-START.html
index 89828e49c4..eba6069210 100644
--- a/10 - Hold Shift and Check Checkboxes/index-START.html	
+++ b/10 - Hold Shift and Check Checkboxes/index-START.html	
@@ -107,7 +107,7 @@
 var Api = (function () {
   // polyfill for jQuery
   var $ = (sel) => Array.from(document.querySelectorAll(sel));
-  var boxlist = $('.item input');
+  var boxlist = $();
   var indexes = {}; // memory for box clicks
   var self;
 
@@ -125,21 +125,29 @@
     setChecked(evt.target.checked); // replicate this state
   }
 
-  function doBinding(arr) {
-    arr.forEach((ele) => {
-      ele.addEventListener('click', revIndexes);
-    });
+  function detach() {
+    boxlist.forEach((ele) => ele.removeEventListener('click', revIndexes));
+    boxlist.splice(0, Infinity);
+    return self;
+  }
+
+  function doBinding(arg) {
+    detach(); // clean up
+    var arr = arg.split ? $(arg) : arg; // query if string
+    boxlist.push.apply(boxlist, arr); // swap in new boxlist
+    boxlist.forEach((ele) => ele.addEventListener('click', revIndexes));
     return self;
   }
 
   self = {
     init: doBinding,
+    select: $,
     boxlist, indexes,
   };
 
-  return self.init(boxlist);
+  return doBinding('.item input');
 }());
-
+console.log(Api);
 </script>
 </body>
 </html>

From 6a0a1d9dd21f2cabc9519a7f098d74d0db9665f2 Mon Sep 17 00:00:00 2001
From: dvdrtrgn <dvdrtrgn@gmail.com>
Date: Fri, 30 Dec 2016 18:15:23 -0600
Subject: [PATCH 25/28] add libs

---
 19 - Webcam Fun/main.js  |   52 +
 19 - Webcam Fun/vid.html |   16 +
 libs/require.js          | 2129 ++++++++++++++++++++++++++++++++++++++
 libs/util.js             |    3 +
 libs/vid.js              |   73 ++
 5 files changed, 2273 insertions(+)
 create mode 100644 19 - Webcam Fun/main.js
 create mode 100644 19 - Webcam Fun/vid.html
 create mode 100644 libs/require.js
 create mode 100644 libs/util.js
 create mode 100644 libs/vid.js

diff --git a/19 - Webcam Fun/main.js b/19 - Webcam Fun/main.js
new file mode 100644
index 0000000000..d11fbda306
--- /dev/null
+++ b/19 - Webcam Fun/main.js	
@@ -0,0 +1,52 @@
+'use strict';
+
+require.config({
+  baseUrl: '../libs',
+  paths: {
+    lodash: '../vendors/lodash.js/lodash',
+  },
+  shim: {
+    foo: {
+      deps: ['lodash'],
+      exports: 'Foo',
+    },
+  },
+});
+
+function init($, V) {
+  var cfg = {
+    _: 'init()',
+    $play: $('button.play'),
+    $photo: $('canvas.photo'),
+    $video: $('video.player'),
+    $snap: $('button.shot'),
+  };
+
+  cfg.camera2video = V.camera2video(cfg.$video);
+
+  cfg.$video.addEventListener('canplay', evt => {
+    if (!cfg.video2canvas) {
+      cfg.video2canvas = V.video2canvas(cfg.$video, cfg.$photo);
+    }
+  });
+
+  cfg.$play.addEventListener('click', evt => {
+    if (!cfg.camera2video.playing) {
+      cfg.camera2video.start();
+    } else {
+      cfg.camera2video.stop();
+    }
+  });
+
+  cfg.$snap.setAttribute('onclick', '');
+  cfg.$snap.addEventListener('click', evt => {
+    let name = `snapCanvas@${Date.now()}`;
+    cfg[name] = V.snapCanvas(cfg.$photo, name);
+    console.log(cfg);
+  });
+
+  window.drt = cfg;
+  return cfg;
+}
+
+require(['./util', './vid'], init);
diff --git a/19 - Webcam Fun/vid.html b/19 - Webcam Fun/vid.html
new file mode 100644
index 0000000000..2788447114
--- /dev/null
+++ b/19 - Webcam Fun/vid.html	
@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>vid test</title>
+    <script src="../libs/require.js" data-main="./main"></script>
+  </head>
+  <body>
+    <br>
+    <canvas class="photo"></canvas>
+    <video class="player"></video>
+    <hr>
+    <button class="play">Play/Pause</button>
+    <button class="shot">Snapshot</button>
+  </body>
+</html>
diff --git a/libs/require.js b/libs/require.js
new file mode 100644
index 0000000000..e33c7dded7
--- /dev/null
+++ b/libs/require.js
@@ -0,0 +1,2129 @@
+/** vim: et:ts=4:sw=4:sts=4
+ * @license RequireJS 2.1.22 Copyright (c) 2010-2015, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+//Not using strict: uneven strict support in browsers, #392, and causes
+//problems with requirejs.exec()/transpiler plugins that may not be strict.
+/*jslint regexp: true, nomen: true, sloppy: true */
+/*global window, navigator, document, importScripts, setTimeout, opera */
+
+var requirejs, require, define;
+(function (global) {
+    var req, s, head, baseElement, dataMain, src,
+        interactiveScript, currentlyAddingScript, mainScript, subPath,
+        version = '2.1.22',
+        commentRegExp = /(\/\*([\s\S]*?)\*\/|([^:]|^)\/\/(.*)$)/mg,
+        cjsRequireRegExp = /[^.]\s*require\s*\(\s*["']([^'"\s]+)["']\s*\)/g,
+        jsSuffixRegExp = /\.js$/,
+        currDirRegExp = /^\.\//,
+        op = Object.prototype,
+        ostring = op.toString,
+        hasOwn = op.hasOwnProperty,
+        ap = Array.prototype,
+        isBrowser = !!(typeof window !== 'undefined' && typeof navigator !== 'undefined' && window.document),
+        isWebWorker = !isBrowser && typeof importScripts !== 'undefined',
+        //PS3 indicates loaded and complete, but need to wait for complete
+        //specifically. Sequence is 'loading', 'loaded', execution,
+        // then 'complete'. The UA check is unfortunate, but not sure how
+        //to feature test w/o causing perf issues.
+        readyRegExp = isBrowser && navigator.platform === 'PLAYSTATION 3' ?
+                      /^complete$/ : /^(complete|loaded)$/,
+        defContextName = '_',
+        //Oh the tragedy, detecting opera. See the usage of isOpera for reason.
+        isOpera = typeof opera !== 'undefined' && opera.toString() === '[object Opera]',
+        contexts = {},
+        cfg = {},
+        globalDefQueue = [],
+        useInteractive = false;
+
+    function isFunction(it) {
+        return ostring.call(it) === '[object Function]';
+    }
+
+    function isArray(it) {
+        return ostring.call(it) === '[object Array]';
+    }
+
+    /**
+     * Helper function for iterating over an array. If the func returns
+     * a true value, it will break out of the loop.
+     */
+    function each(ary, func) {
+        if (ary) {
+            var i;
+            for (i = 0; i < ary.length; i += 1) {
+                if (ary[i] && func(ary[i], i, ary)) {
+                    break;
+                }
+            }
+        }
+    }
+
+    /**
+     * Helper function for iterating over an array backwards. If the func
+     * returns a true value, it will break out of the loop.
+     */
+    function eachReverse(ary, func) {
+        if (ary) {
+            var i;
+            for (i = ary.length - 1; i > -1; i -= 1) {
+                if (ary[i] && func(ary[i], i, ary)) {
+                    break;
+                }
+            }
+        }
+    }
+
+    function hasProp(obj, prop) {
+        return hasOwn.call(obj, prop);
+    }
+
+    function getOwn(obj, prop) {
+        return hasProp(obj, prop) && obj[prop];
+    }
+
+    /**
+     * Cycles over properties in an object and calls a function for each
+     * property value. If the function returns a truthy value, then the
+     * iteration is stopped.
+     */
+    function eachProp(obj, func) {
+        var prop;
+        for (prop in obj) {
+            if (hasProp(obj, prop)) {
+                if (func(obj[prop], prop)) {
+                    break;
+                }
+            }
+        }
+    }
+
+    /**
+     * Simple function to mix in properties from source into target,
+     * but only if target does not already have a property of the same name.
+     */
+    function mixin(target, source, force, deepStringMixin) {
+        if (source) {
+            eachProp(source, function (value, prop) {
+                if (force || !hasProp(target, prop)) {
+                    if (deepStringMixin && typeof value === 'object' && value &&
+                        !isArray(value) && !isFunction(value) &&
+                        !(value instanceof RegExp)) {
+
+                        if (!target[prop]) {
+                            target[prop] = {};
+                        }
+                        mixin(target[prop], value, force, deepStringMixin);
+                    } else {
+                        target[prop] = value;
+                    }
+                }
+            });
+        }
+        return target;
+    }
+
+    //Similar to Function.prototype.bind, but the 'this' object is specified
+    //first, since it is easier to read/figure out what 'this' will be.
+    function bind(obj, fn) {
+        return function () {
+            return fn.apply(obj, arguments);
+        };
+    }
+
+    function scripts() {
+        return document.getElementsByTagName('script');
+    }
+
+    function defaultOnError(err) {
+        throw err;
+    }
+
+    //Allow getting a global that is expressed in
+    //dot notation, like 'a.b.c'.
+    function getGlobal(value) {
+        if (!value) {
+            return value;
+        }
+        var g = global;
+        each(value.split('.'), function (part) {
+            g = g[part];
+        });
+        return g;
+    }
+
+    /**
+     * Constructs an error with a pointer to an URL with more information.
+     * @param {String} id the error ID that maps to an ID on a web page.
+     * @param {String} message human readable error.
+     * @param {Error} [err] the original error, if there is one.
+     *
+     * @returns {Error}
+     */
+    function makeError(id, msg, err, requireModules) {
+        var e = new Error(msg + '\nhttp://requirejs.org/docs/errors.html#' + id);
+        e.requireType = id;
+        e.requireModules = requireModules;
+        if (err) {
+            e.originalError = err;
+        }
+        return e;
+    }
+
+    if (typeof define !== 'undefined') {
+        //If a define is already in play via another AMD loader,
+        //do not overwrite.
+        return;
+    }
+
+    if (typeof requirejs !== 'undefined') {
+        if (isFunction(requirejs)) {
+            //Do not overwrite an existing requirejs instance.
+            return;
+        }
+        cfg = requirejs;
+        requirejs = undefined;
+    }
+
+    //Allow for a require config object
+    if (typeof require !== 'undefined' && !isFunction(require)) {
+        //assume it is a config object.
+        cfg = require;
+        require = undefined;
+    }
+
+    function newContext(contextName) {
+        var inCheckLoaded, Module, context, handlers,
+            checkLoadedTimeoutId,
+            config = {
+                //Defaults. Do not set a default for map
+                //config to speed up normalize(), which
+                //will run faster if there is no default.
+                waitSeconds: 7,
+                baseUrl: './',
+                paths: {},
+                bundles: {},
+                pkgs: {},
+                shim: {},
+                config: {}
+            },
+            registry = {},
+            //registry of just enabled modules, to speed
+            //cycle breaking code when lots of modules
+            //are registered, but not activated.
+            enabledRegistry = {},
+            undefEvents = {},
+            defQueue = [],
+            defined = {},
+            urlFetched = {},
+            bundlesMap = {},
+            requireCounter = 1,
+            unnormalizedCounter = 1;
+
+        /**
+         * Trims the . and .. from an array of path segments.
+         * It will keep a leading path segment if a .. will become
+         * the first path segment, to help with module name lookups,
+         * which act like paths, but can be remapped. But the end result,
+         * all paths that use this function should look normalized.
+         * NOTE: this method MODIFIES the input array.
+         * @param {Array} ary the array of path segments.
+         */
+        function trimDots(ary) {
+            var i, part;
+            for (i = 0; i < ary.length; i++) {
+                part = ary[i];
+                if (part === '.') {
+                    ary.splice(i, 1);
+                    i -= 1;
+                } else if (part === '..') {
+                    // If at the start, or previous value is still ..,
+                    // keep them so that when converted to a path it may
+                    // still work when converted to a path, even though
+                    // as an ID it is less than ideal. In larger point
+                    // releases, may be better to just kick out an error.
+                    if (i === 0 || (i === 1 && ary[2] === '..') || ary[i - 1] === '..') {
+                        continue;
+                    } else if (i > 0) {
+                        ary.splice(i - 1, 2);
+                        i -= 2;
+                    }
+                }
+            }
+        }
+
+        /**
+         * Given a relative module name, like ./something, normalize it to
+         * a real name that can be mapped to a path.
+         * @param {String} name the relative name
+         * @param {String} baseName a real name that the name arg is relative
+         * to.
+         * @param {Boolean} applyMap apply the map config to the value. Should
+         * only be done if this normalization is for a dependency ID.
+         * @returns {String} normalized name
+         */
+        function normalize(name, baseName, applyMap) {
+            var pkgMain, mapValue, nameParts, i, j, nameSegment, lastIndex,
+                foundMap, foundI, foundStarMap, starI, normalizedBaseParts,
+                baseParts = (baseName && baseName.split('/')),
+                map = config.map,
+                starMap = map && map['*'];
+
+            //Adjust any relative paths.
+            if (name) {
+                name = name.split('/');
+                lastIndex = name.length - 1;
+
+                // If wanting node ID compatibility, strip .js from end
+                // of IDs. Have to do this here, and not in nameToUrl
+                // because node allows either .js or non .js to map
+                // to same file.
+                if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {
+                    name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, '');
+                }
+
+                // Starts with a '.' so need the baseName
+                if (name[0].charAt(0) === '.' && baseParts) {
+                    //Convert baseName to array, and lop off the last part,
+                    //so that . matches that 'directory' and not name of the baseName's
+                    //module. For instance, baseName of 'one/two/three', maps to
+                    //'one/two/three.js', but we want the directory, 'one/two' for
+                    //this normalization.
+                    normalizedBaseParts = baseParts.slice(0, baseParts.length - 1);
+                    name = normalizedBaseParts.concat(name);
+                }
+
+                trimDots(name);
+                name = name.join('/');
+            }
+
+            //Apply map config if available.
+            if (applyMap && map && (baseParts || starMap)) {
+                nameParts = name.split('/');
+
+                outerLoop: for (i = nameParts.length; i > 0; i -= 1) {
+                    nameSegment = nameParts.slice(0, i).join('/');
+
+                    if (baseParts) {
+                        //Find the longest baseName segment match in the config.
+                        //So, do joins on the biggest to smallest lengths of baseParts.
+                        for (j = baseParts.length; j > 0; j -= 1) {
+                            mapValue = getOwn(map, baseParts.slice(0, j).join('/'));
+
+                            //baseName segment has config, find if it has one for
+                            //this name.
+                            if (mapValue) {
+                                mapValue = getOwn(mapValue, nameSegment);
+                                if (mapValue) {
+                                    //Match, update name to the new value.
+                                    foundMap = mapValue;
+                                    foundI = i;
+                                    break outerLoop;
+                                }
+                            }
+                        }
+                    }
+
+                    //Check for a star map match, but just hold on to it,
+                    //if there is a shorter segment match later in a matching
+                    //config, then favor over this star map.
+                    if (!foundStarMap && starMap && getOwn(starMap, nameSegment)) {
+                        foundStarMap = getOwn(starMap, nameSegment);
+                        starI = i;
+                    }
+                }
+
+                if (!foundMap && foundStarMap) {
+                    foundMap = foundStarMap;
+                    foundI = starI;
+                }
+
+                if (foundMap) {
+                    nameParts.splice(0, foundI, foundMap);
+                    name = nameParts.join('/');
+                }
+            }
+
+            // If the name points to a package's name, use
+            // the package main instead.
+            pkgMain = getOwn(config.pkgs, name);
+
+            return pkgMain ? pkgMain : name;
+        }
+
+        function removeScript(name) {
+            if (isBrowser) {
+                each(scripts(), function (scriptNode) {
+                    if (scriptNode.getAttribute('data-requiremodule') === name &&
+                            scriptNode.getAttribute('data-requirecontext') === context.contextName) {
+                        scriptNode.parentNode.removeChild(scriptNode);
+                        return true;
+                    }
+                });
+            }
+        }
+
+        function hasPathFallback(id) {
+            var pathConfig = getOwn(config.paths, id);
+            if (pathConfig && isArray(pathConfig) && pathConfig.length > 1) {
+                //Pop off the first array value, since it failed, and
+                //retry
+                pathConfig.shift();
+                context.require.undef(id);
+
+                //Custom require that does not do map translation, since
+                //ID is "absolute", already mapped/resolved.
+                context.makeRequire(null, {
+                    skipMap: true
+                })([id]);
+
+                return true;
+            }
+        }
+
+        //Turns a plugin!resource to [plugin, resource]
+        //with the plugin being undefined if the name
+        //did not have a plugin prefix.
+        function splitPrefix(name) {
+            var prefix,
+                index = name ? name.indexOf('!') : -1;
+            if (index > -1) {
+                prefix = name.substring(0, index);
+                name = name.substring(index + 1, name.length);
+            }
+            return [prefix, name];
+        }
+
+        /**
+         * Creates a module mapping that includes plugin prefix, module
+         * name, and path. If parentModuleMap is provided it will
+         * also normalize the name via require.normalize()
+         *
+         * @param {String} name the module name
+         * @param {String} [parentModuleMap] parent module map
+         * for the module name, used to resolve relative names.
+         * @param {Boolean} isNormalized: is the ID already normalized.
+         * This is true if this call is done for a define() module ID.
+         * @param {Boolean} applyMap: apply the map config to the ID.
+         * Should only be true if this map is for a dependency.
+         *
+         * @returns {Object}
+         */
+        function makeModuleMap(name, parentModuleMap, isNormalized, applyMap) {
+            var url, pluginModule, suffix, nameParts,
+                prefix = null,
+                parentName = parentModuleMap ? parentModuleMap.name : null,
+                originalName = name,
+                isDefine = true,
+                normalizedName = '';
+
+            //If no name, then it means it is a require call, generate an
+            //internal name.
+            if (!name) {
+                isDefine = false;
+                name = '_@r' + (requireCounter += 1);
+            }
+
+            nameParts = splitPrefix(name);
+            prefix = nameParts[0];
+            name = nameParts[1];
+
+            if (prefix) {
+                prefix = normalize(prefix, parentName, applyMap);
+                pluginModule = getOwn(defined, prefix);
+            }
+
+            //Account for relative paths if there is a base name.
+            if (name) {
+                if (prefix) {
+                    if (pluginModule && pluginModule.normalize) {
+                        //Plugin is loaded, use its normalize method.
+                        normalizedName = pluginModule.normalize(name, function (name) {
+                            return normalize(name, parentName, applyMap);
+                        });
+                    } else {
+                        // If nested plugin references, then do not try to
+                        // normalize, as it will not normalize correctly. This
+                        // places a restriction on resourceIds, and the longer
+                        // term solution is not to normalize until plugins are
+                        // loaded and all normalizations to allow for async
+                        // loading of a loader plugin. But for now, fixes the
+                        // common uses. Details in #1131
+                        normalizedName = name.indexOf('!') === -1 ?
+                                         normalize(name, parentName, applyMap) :
+                                         name;
+                    }
+                } else {
+                    //A regular module.
+                    normalizedName = normalize(name, parentName, applyMap);
+
+                    //Normalized name may be a plugin ID due to map config
+                    //application in normalize. The map config values must
+                    //already be normalized, so do not need to redo that part.
+                    nameParts = splitPrefix(normalizedName);
+                    prefix = nameParts[0];
+                    normalizedName = nameParts[1];
+                    isNormalized = true;
+
+                    url = context.nameToUrl(normalizedName);
+                }
+            }
+
+            //If the id is a plugin id that cannot be determined if it needs
+            //normalization, stamp it with a unique ID so two matching relative
+            //ids that may conflict can be separate.
+            suffix = prefix && !pluginModule && !isNormalized ?
+                     '_unnormalized' + (unnormalizedCounter += 1) :
+                     '';
+
+            return {
+                prefix: prefix,
+                name: normalizedName,
+                parentMap: parentModuleMap,
+                unnormalized: !!suffix,
+                url: url,
+                originalName: originalName,
+                isDefine: isDefine,
+                id: (prefix ?
+                        prefix + '!' + normalizedName :
+                        normalizedName) + suffix
+            };
+        }
+
+        function getModule(depMap) {
+            var id = depMap.id,
+                mod = getOwn(registry, id);
+
+            if (!mod) {
+                mod = registry[id] = new context.Module(depMap);
+            }
+
+            return mod;
+        }
+
+        function on(depMap, name, fn) {
+            var id = depMap.id,
+                mod = getOwn(registry, id);
+
+            if (hasProp(defined, id) &&
+                    (!mod || mod.defineEmitComplete)) {
+                if (name === 'defined') {
+                    fn(defined[id]);
+                }
+            } else {
+                mod = getModule(depMap);
+                if (mod.error && name === 'error') {
+                    fn(mod.error);
+                } else {
+                    mod.on(name, fn);
+                }
+            }
+        }
+
+        function onError(err, errback) {
+            var ids = err.requireModules,
+                notified = false;
+
+            if (errback) {
+                errback(err);
+            } else {
+                each(ids, function (id) {
+                    var mod = getOwn(registry, id);
+                    if (mod) {
+                        //Set error on module, so it skips timeout checks.
+                        mod.error = err;
+                        if (mod.events.error) {
+                            notified = true;
+                            mod.emit('error', err);
+                        }
+                    }
+                });
+
+                if (!notified) {
+                    req.onError(err);
+                }
+            }
+        }
+
+        /**
+         * Internal method to transfer globalQueue items to this context's
+         * defQueue.
+         */
+        function takeGlobalQueue() {
+            //Push all the globalDefQueue items into the context's defQueue
+            if (globalDefQueue.length) {
+                each(globalDefQueue, function(queueItem) {
+                    var id = queueItem[0];
+                    if (typeof id === 'string') {
+                        context.defQueueMap[id] = true;
+                    }
+                    defQueue.push(queueItem);
+                });
+                globalDefQueue = [];
+            }
+        }
+
+        handlers = {
+            'require': function (mod) {
+                if (mod.require) {
+                    return mod.require;
+                } else {
+                    return (mod.require = context.makeRequire(mod.map));
+                }
+            },
+            'exports': function (mod) {
+                mod.usingExports = true;
+                if (mod.map.isDefine) {
+                    if (mod.exports) {
+                        return (defined[mod.map.id] = mod.exports);
+                    } else {
+                        return (mod.exports = defined[mod.map.id] = {});
+                    }
+                }
+            },
+            'module': function (mod) {
+                if (mod.module) {
+                    return mod.module;
+                } else {
+                    return (mod.module = {
+                        id: mod.map.id,
+                        uri: mod.map.url,
+                        config: function () {
+                            return getOwn(config.config, mod.map.id) || {};
+                        },
+                        exports: mod.exports || (mod.exports = {})
+                    });
+                }
+            }
+        };
+
+        function cleanRegistry(id) {
+            //Clean up machinery used for waiting modules.
+            delete registry[id];
+            delete enabledRegistry[id];
+        }
+
+        function breakCycle(mod, traced, processed) {
+            var id = mod.map.id;
+
+            if (mod.error) {
+                mod.emit('error', mod.error);
+            } else {
+                traced[id] = true;
+                each(mod.depMaps, function (depMap, i) {
+                    var depId = depMap.id,
+                        dep = getOwn(registry, depId);
+
+                    //Only force things that have not completed
+                    //being defined, so still in the registry,
+                    //and only if it has not been matched up
+                    //in the module already.
+                    if (dep && !mod.depMatched[i] && !processed[depId]) {
+                        if (getOwn(traced, depId)) {
+                            mod.defineDep(i, defined[depId]);
+                            mod.check(); //pass false?
+                        } else {
+                            breakCycle(dep, traced, processed);
+                        }
+                    }
+                });
+                processed[id] = true;
+            }
+        }
+
+        function checkLoaded() {
+            var err, usingPathFallback,
+                waitInterval = config.waitSeconds * 1000,
+                //It is possible to disable the wait interval by using waitSeconds of 0.
+                expired = waitInterval && (context.startTime + waitInterval) < new Date().getTime(),
+                noLoads = [],
+                reqCalls = [],
+                stillLoading = false,
+                needCycleCheck = true;
+
+            //Do not bother if this call was a result of a cycle break.
+            if (inCheckLoaded) {
+                return;
+            }
+
+            inCheckLoaded = true;
+
+            //Figure out the state of all the modules.
+            eachProp(enabledRegistry, function (mod) {
+                var map = mod.map,
+                    modId = map.id;
+
+                //Skip things that are not enabled or in error state.
+                if (!mod.enabled) {
+                    return;
+                }
+
+                if (!map.isDefine) {
+                    reqCalls.push(mod);
+                }
+
+                if (!mod.error) {
+                    //If the module should be executed, and it has not
+                    //been inited and time is up, remember it.
+                    if (!mod.inited && expired) {
+                        if (hasPathFallback(modId)) {
+                            usingPathFallback = true;
+                            stillLoading = true;
+                        } else {
+                            noLoads.push(modId);
+                            removeScript(modId);
+                        }
+                    } else if (!mod.inited && mod.fetched && map.isDefine) {
+                        stillLoading = true;
+                        if (!map.prefix) {
+                            //No reason to keep looking for unfinished
+                            //loading. If the only stillLoading is a
+                            //plugin resource though, keep going,
+                            //because it may be that a plugin resource
+                            //is waiting on a non-plugin cycle.
+                            return (needCycleCheck = false);
+                        }
+                    }
+                }
+            });
+
+            if (expired && noLoads.length) {
+                //If wait time expired, throw error of unloaded modules.
+                err = makeError('timeout', 'Load timeout for modules: ' + noLoads, null, noLoads);
+                err.contextName = context.contextName;
+                return onError(err);
+            }
+
+            //Not expired, check for a cycle.
+            if (needCycleCheck) {
+                each(reqCalls, function (mod) {
+                    breakCycle(mod, {}, {});
+                });
+            }
+
+            //If still waiting on loads, and the waiting load is something
+            //other than a plugin resource, or there are still outstanding
+            //scripts, then just try back later.
+            if ((!expired || usingPathFallback) && stillLoading) {
+                //Something is still waiting to load. Wait for it, but only
+                //if a timeout is not already in effect.
+                if ((isBrowser || isWebWorker) && !checkLoadedTimeoutId) {
+                    checkLoadedTimeoutId = setTimeout(function () {
+                        checkLoadedTimeoutId = 0;
+                        checkLoaded();
+                    }, 50);
+                }
+            }
+
+            inCheckLoaded = false;
+        }
+
+        Module = function (map) {
+            this.events = getOwn(undefEvents, map.id) || {};
+            this.map = map;
+            this.shim = getOwn(config.shim, map.id);
+            this.depExports = [];
+            this.depMaps = [];
+            this.depMatched = [];
+            this.pluginMaps = {};
+            this.depCount = 0;
+
+            /* this.exports this.factory
+               this.depMaps = [],
+               this.enabled, this.fetched
+            */
+        };
+
+        Module.prototype = {
+            init: function (depMaps, factory, errback, options) {
+                options = options || {};
+
+                //Do not do more inits if already done. Can happen if there
+                //are multiple define calls for the same module. That is not
+                //a normal, common case, but it is also not unexpected.
+                if (this.inited) {
+                    return;
+                }
+
+                this.factory = factory;
+
+                if (errback) {
+                    //Register for errors on this module.
+                    this.on('error', errback);
+                } else if (this.events.error) {
+                    //If no errback already, but there are error listeners
+                    //on this module, set up an errback to pass to the deps.
+                    errback = bind(this, function (err) {
+                        this.emit('error', err);
+                    });
+                }
+
+                //Do a copy of the dependency array, so that
+                //source inputs are not modified. For example
+                //"shim" deps are passed in here directly, and
+                //doing a direct modification of the depMaps array
+                //would affect that config.
+                this.depMaps = depMaps && depMaps.slice(0);
+
+                this.errback = errback;
+
+                //Indicate this module has be initialized
+                this.inited = true;
+
+                this.ignore = options.ignore;
+
+                //Could have option to init this module in enabled mode,
+                //or could have been previously marked as enabled. However,
+                //the dependencies are not known until init is called. So
+                //if enabled previously, now trigger dependencies as enabled.
+                if (options.enabled || this.enabled) {
+                    //Enable this module and dependencies.
+                    //Will call this.check()
+                    this.enable();
+                } else {
+                    this.check();
+                }
+            },
+
+            defineDep: function (i, depExports) {
+                //Because of cycles, defined callback for a given
+                //export can be called more than once.
+                if (!this.depMatched[i]) {
+                    this.depMatched[i] = true;
+                    this.depCount -= 1;
+                    this.depExports[i] = depExports;
+                }
+            },
+
+            fetch: function () {
+                if (this.fetched) {
+                    return;
+                }
+                this.fetched = true;
+
+                context.startTime = (new Date()).getTime();
+
+                var map = this.map;
+
+                //If the manager is for a plugin managed resource,
+                //ask the plugin to load it now.
+                if (this.shim) {
+                    context.makeRequire(this.map, {
+                        enableBuildCallback: true
+                    })(this.shim.deps || [], bind(this, function () {
+                        return map.prefix ? this.callPlugin() : this.load();
+                    }));
+                } else {
+                    //Regular dependency.
+                    return map.prefix ? this.callPlugin() : this.load();
+                }
+            },
+
+            load: function () {
+                var url = this.map.url;
+
+                //Regular dependency.
+                if (!urlFetched[url]) {
+                    urlFetched[url] = true;
+                    context.load(this.map.id, url);
+                }
+            },
+
+            /**
+             * Checks if the module is ready to define itself, and if so,
+             * define it.
+             */
+            check: function () {
+                if (!this.enabled || this.enabling) {
+                    return;
+                }
+
+                var err, cjsModule,
+                    id = this.map.id,
+                    depExports = this.depExports,
+                    exports = this.exports,
+                    factory = this.factory;
+
+                if (!this.inited) {
+                    // Only fetch if not already in the defQueue.
+                    if (!hasProp(context.defQueueMap, id)) {
+                        this.fetch();
+                    }
+                } else if (this.error) {
+                    this.emit('error', this.error);
+                } else if (!this.defining) {
+                    //The factory could trigger another require call
+                    //that would result in checking this module to
+                    //define itself again. If already in the process
+                    //of doing that, skip this work.
+                    this.defining = true;
+
+                    if (this.depCount < 1 && !this.defined) {
+                        if (isFunction(factory)) {
+                            try {
+                                exports = context.execCb(id, factory, depExports, exports);
+                            } catch (e) {
+                                err = e;
+                            }
+
+                            // Favor return value over exports. If node/cjs in play,
+                            // then will not have a return value anyway. Favor
+                            // module.exports assignment over exports object.
+                            if (this.map.isDefine && exports === undefined) {
+                                cjsModule = this.module;
+                                if (cjsModule) {
+                                    exports = cjsModule.exports;
+                                } else if (this.usingExports) {
+                                    //exports already set the defined value.
+                                    exports = this.exports;
+                                }
+                            }
+
+                            if (err) {
+                                // If there is an error listener, favor passing
+                                // to that instead of throwing an error. However,
+                                // only do it for define()'d  modules. require
+                                // errbacks should not be called for failures in
+                                // their callbacks (#699). However if a global
+                                // onError is set, use that.
+                                if ((this.events.error && this.map.isDefine) ||
+                                    req.onError !== defaultOnError) {
+                                    err.requireMap = this.map;
+                                    err.requireModules = this.map.isDefine ? [this.map.id] : null;
+                                    err.requireType = this.map.isDefine ? 'define' : 'require';
+                                    return onError((this.error = err));
+                                } else if (typeof console !== 'undefined' &&
+                                           console.error) {
+                                    // Log the error for debugging. If promises could be
+                                    // used, this would be different, but making do.
+                                    console.error(err);
+                                } else {
+                                    // Do not want to completely lose the error. While this
+                                    // will mess up processing and lead to similar results
+                                    // as bug 1440, it at least surfaces the error.
+                                    req.onError(err);
+                                }
+                            }
+                        } else {
+                            //Just a literal value
+                            exports = factory;
+                        }
+
+                        this.exports = exports;
+
+                        if (this.map.isDefine && !this.ignore) {
+                            defined[id] = exports;
+
+                            if (req.onResourceLoad) {
+                                var resLoadMaps = [];
+                                each(this.depMaps, function (depMap) {
+                                    resLoadMaps.push(depMap.normalizedMap || depMap);
+                                });
+                                req.onResourceLoad(context, this.map, resLoadMaps);
+                            }
+                        }
+
+                        //Clean up
+                        cleanRegistry(id);
+
+                        this.defined = true;
+                    }
+
+                    //Finished the define stage. Allow calling check again
+                    //to allow define notifications below in the case of a
+                    //cycle.
+                    this.defining = false;
+
+                    if (this.defined && !this.defineEmitted) {
+                        this.defineEmitted = true;
+                        this.emit('defined', this.exports);
+                        this.defineEmitComplete = true;
+                    }
+
+                }
+            },
+
+            callPlugin: function () {
+                var map = this.map,
+                    id = map.id,
+                    //Map already normalized the prefix.
+                    pluginMap = makeModuleMap(map.prefix);
+
+                //Mark this as a dependency for this plugin, so it
+                //can be traced for cycles.
+                this.depMaps.push(pluginMap);
+
+                on(pluginMap, 'defined', bind(this, function (plugin) {
+                    var load, normalizedMap, normalizedMod,
+                        bundleId = getOwn(bundlesMap, this.map.id),
+                        name = this.map.name,
+                        parentName = this.map.parentMap ? this.map.parentMap.name : null,
+                        localRequire = context.makeRequire(map.parentMap, {
+                            enableBuildCallback: true
+                        });
+
+                    //If current map is not normalized, wait for that
+                    //normalized name to load instead of continuing.
+                    if (this.map.unnormalized) {
+                        //Normalize the ID if the plugin allows it.
+                        if (plugin.normalize) {
+                            name = plugin.normalize(name, function (name) {
+                                return normalize(name, parentName, true);
+                            }) || '';
+                        }
+
+                        //prefix and name should already be normalized, no need
+                        //for applying map config again either.
+                        normalizedMap = makeModuleMap(map.prefix + '!' + name,
+                                                      this.map.parentMap);
+                        on(normalizedMap,
+                            'defined', bind(this, function (value) {
+                                this.map.normalizedMap = normalizedMap;
+                                this.init([], function () { return value; }, null, {
+                                    enabled: true,
+                                    ignore: true
+                                });
+                            }));
+
+                        normalizedMod = getOwn(registry, normalizedMap.id);
+                        if (normalizedMod) {
+                            //Mark this as a dependency for this plugin, so it
+                            //can be traced for cycles.
+                            this.depMaps.push(normalizedMap);
+
+                            if (this.events.error) {
+                                normalizedMod.on('error', bind(this, function (err) {
+                                    this.emit('error', err);
+                                }));
+                            }
+                            normalizedMod.enable();
+                        }
+
+                        return;
+                    }
+
+                    //If a paths config, then just load that file instead to
+                    //resolve the plugin, as it is built into that paths layer.
+                    if (bundleId) {
+                        this.map.url = context.nameToUrl(bundleId);
+                        this.load();
+                        return;
+                    }
+
+                    load = bind(this, function (value) {
+                        this.init([], function () { return value; }, null, {
+                            enabled: true
+                        });
+                    });
+
+                    load.error = bind(this, function (err) {
+                        this.inited = true;
+                        this.error = err;
+                        err.requireModules = [id];
+
+                        //Remove temp unnormalized modules for this module,
+                        //since they will never be resolved otherwise now.
+                        eachProp(registry, function (mod) {
+                            if (mod.map.id.indexOf(id + '_unnormalized') === 0) {
+                                cleanRegistry(mod.map.id);
+                            }
+                        });
+
+                        onError(err);
+                    });
+
+                    //Allow plugins to load other code without having to know the
+                    //context or how to 'complete' the load.
+                    load.fromText = bind(this, function (text, textAlt) {
+                        /*jslint evil: true */
+                        var moduleName = map.name,
+                            moduleMap = makeModuleMap(moduleName),
+                            hasInteractive = useInteractive;
+
+                        //As of 2.1.0, support just passing the text, to reinforce
+                        //fromText only being called once per resource. Still
+                        //support old style of passing moduleName but discard
+                        //that moduleName in favor of the internal ref.
+                        if (textAlt) {
+                            text = textAlt;
+                        }
+
+                        //Turn off interactive script matching for IE for any define
+                        //calls in the text, then turn it back on at the end.
+                        if (hasInteractive) {
+                            useInteractive = false;
+                        }
+
+                        //Prime the system by creating a module instance for
+                        //it.
+                        getModule(moduleMap);
+
+                        //Transfer any config to this other module.
+                        if (hasProp(config.config, id)) {
+                            config.config[moduleName] = config.config[id];
+                        }
+
+                        try {
+                            req.exec(text);
+                        } catch (e) {
+                            return onError(makeError('fromtexteval',
+                                             'fromText eval for ' + id +
+                                            ' failed: ' + e,
+                                             e,
+                                             [id]));
+                        }
+
+                        if (hasInteractive) {
+                            useInteractive = true;
+                        }
+
+                        //Mark this as a dependency for the plugin
+                        //resource
+                        this.depMaps.push(moduleMap);
+
+                        //Support anonymous modules.
+                        context.completeLoad(moduleName);
+
+                        //Bind the value of that module to the value for this
+                        //resource ID.
+                        localRequire([moduleName], load);
+                    });
+
+                    //Use parentName here since the plugin's name is not reliable,
+                    //could be some weird string with no path that actually wants to
+                    //reference the parentName's path.
+                    plugin.load(map.name, localRequire, load, config);
+                }));
+
+                context.enable(pluginMap, this);
+                this.pluginMaps[pluginMap.id] = pluginMap;
+            },
+
+            enable: function () {
+                enabledRegistry[this.map.id] = this;
+                this.enabled = true;
+
+                //Set flag mentioning that the module is enabling,
+                //so that immediate calls to the defined callbacks
+                //for dependencies do not trigger inadvertent load
+                //with the depCount still being zero.
+                this.enabling = true;
+
+                //Enable each dependency
+                each(this.depMaps, bind(this, function (depMap, i) {
+                    var id, mod, handler;
+
+                    if (typeof depMap === 'string') {
+                        //Dependency needs to be converted to a depMap
+                        //and wired up to this module.
+                        depMap = makeModuleMap(depMap,
+                                               (this.map.isDefine ? this.map : this.map.parentMap),
+                                               false,
+                                               !this.skipMap);
+                        this.depMaps[i] = depMap;
+
+                        handler = getOwn(handlers, depMap.id);
+
+                        if (handler) {
+                            this.depExports[i] = handler(this);
+                            return;
+                        }
+
+                        this.depCount += 1;
+
+                        on(depMap, 'defined', bind(this, function (depExports) {
+                            if (this.undefed) {
+                                return;
+                            }
+                            this.defineDep(i, depExports);
+                            this.check();
+                        }));
+
+                        if (this.errback) {
+                            on(depMap, 'error', bind(this, this.errback));
+                        } else if (this.events.error) {
+                            // No direct errback on this module, but something
+                            // else is listening for errors, so be sure to
+                            // propagate the error correctly.
+                            on(depMap, 'error', bind(this, function(err) {
+                                this.emit('error', err);
+                            }));
+                        }
+                    }
+
+                    id = depMap.id;
+                    mod = registry[id];
+
+                    //Skip special modules like 'require', 'exports', 'module'
+                    //Also, don't call enable if it is already enabled,
+                    //important in circular dependency cases.
+                    if (!hasProp(handlers, id) && mod && !mod.enabled) {
+                        context.enable(depMap, this);
+                    }
+                }));
+
+                //Enable each plugin that is used in
+                //a dependency
+                eachProp(this.pluginMaps, bind(this, function (pluginMap) {
+                    var mod = getOwn(registry, pluginMap.id);
+                    if (mod && !mod.enabled) {
+                        context.enable(pluginMap, this);
+                    }
+                }));
+
+                this.enabling = false;
+
+                this.check();
+            },
+
+            on: function (name, cb) {
+                var cbs = this.events[name];
+                if (!cbs) {
+                    cbs = this.events[name] = [];
+                }
+                cbs.push(cb);
+            },
+
+            emit: function (name, evt) {
+                each(this.events[name], function (cb) {
+                    cb(evt);
+                });
+                if (name === 'error') {
+                    //Now that the error handler was triggered, remove
+                    //the listeners, since this broken Module instance
+                    //can stay around for a while in the registry.
+                    delete this.events[name];
+                }
+            }
+        };
+
+        function callGetModule(args) {
+            //Skip modules already defined.
+            if (!hasProp(defined, args[0])) {
+                getModule(makeModuleMap(args[0], null, true)).init(args[1], args[2]);
+            }
+        }
+
+        function removeListener(node, func, name, ieName) {
+            //Favor detachEvent because of IE9
+            //issue, see attachEvent/addEventListener comment elsewhere
+            //in this file.
+            if (node.detachEvent && !isOpera) {
+                //Probably IE. If not it will throw an error, which will be
+                //useful to know.
+                if (ieName) {
+                    node.detachEvent(ieName, func);
+                }
+            } else {
+                node.removeEventListener(name, func, false);
+            }
+        }
+
+        /**
+         * Given an event from a script node, get the requirejs info from it,
+         * and then removes the event listeners on the node.
+         * @param {Event} evt
+         * @returns {Object}
+         */
+        function getScriptData(evt) {
+            //Using currentTarget instead of target for Firefox 2.0's sake. Not
+            //all old browsers will be supported, but this one was easy enough
+            //to support and still makes sense.
+            var node = evt.currentTarget || evt.srcElement;
+
+            //Remove the listeners once here.
+            removeListener(node, context.onScriptLoad, 'load', 'onreadystatechange');
+            removeListener(node, context.onScriptError, 'error');
+
+            return {
+                node: node,
+                id: node && node.getAttribute('data-requiremodule')
+            };
+        }
+
+        function intakeDefines() {
+            var args;
+
+            //Any defined modules in the global queue, intake them now.
+            takeGlobalQueue();
+
+            //Make sure any remaining defQueue items get properly processed.
+            while (defQueue.length) {
+                args = defQueue.shift();
+                if (args[0] === null) {
+                    return onError(makeError('mismatch', 'Mismatched anonymous define() module: ' +
+                        args[args.length - 1]));
+                } else {
+                    //args are id, deps, factory. Should be normalized by the
+                    //define() function.
+                    callGetModule(args);
+                }
+            }
+            context.defQueueMap = {};
+        }
+
+        context = {
+            config: config,
+            contextName: contextName,
+            registry: registry,
+            defined: defined,
+            urlFetched: urlFetched,
+            defQueue: defQueue,
+            defQueueMap: {},
+            Module: Module,
+            makeModuleMap: makeModuleMap,
+            nextTick: req.nextTick,
+            onError: onError,
+
+            /**
+             * Set a configuration for the context.
+             * @param {Object} cfg config object to integrate.
+             */
+            configure: function (cfg) {
+                //Make sure the baseUrl ends in a slash.
+                if (cfg.baseUrl) {
+                    if (cfg.baseUrl.charAt(cfg.baseUrl.length - 1) !== '/') {
+                        cfg.baseUrl += '/';
+                    }
+                }
+
+                //Save off the paths since they require special processing,
+                //they are additive.
+                var shim = config.shim,
+                    objs = {
+                        paths: true,
+                        bundles: true,
+                        config: true,
+                        map: true
+                    };
+
+                eachProp(cfg, function (value, prop) {
+                    if (objs[prop]) {
+                        if (!config[prop]) {
+                            config[prop] = {};
+                        }
+                        mixin(config[prop], value, true, true);
+                    } else {
+                        config[prop] = value;
+                    }
+                });
+
+                //Reverse map the bundles
+                if (cfg.bundles) {
+                    eachProp(cfg.bundles, function (value, prop) {
+                        each(value, function (v) {
+                            if (v !== prop) {
+                                bundlesMap[v] = prop;
+                            }
+                        });
+                    });
+                }
+
+                //Merge shim
+                if (cfg.shim) {
+                    eachProp(cfg.shim, function (value, id) {
+                        //Normalize the structure
+                        if (isArray(value)) {
+                            value = {
+                                deps: value
+                            };
+                        }
+                        if ((value.exports || value.init) && !value.exportsFn) {
+                            value.exportsFn = context.makeShimExports(value);
+                        }
+                        shim[id] = value;
+                    });
+                    config.shim = shim;
+                }
+
+                //Adjust packages if necessary.
+                if (cfg.packages) {
+                    each(cfg.packages, function (pkgObj) {
+                        var location, name;
+
+                        pkgObj = typeof pkgObj === 'string' ? {name: pkgObj} : pkgObj;
+
+                        name = pkgObj.name;
+                        location = pkgObj.location;
+                        if (location) {
+                            config.paths[name] = pkgObj.location;
+                        }
+
+                        //Save pointer to main module ID for pkg name.
+                        //Remove leading dot in main, so main paths are normalized,
+                        //and remove any trailing .js, since different package
+                        //envs have different conventions: some use a module name,
+                        //some use a file name.
+                        config.pkgs[name] = pkgObj.name + '/' + (pkgObj.main || 'main')
+                                     .replace(currDirRegExp, '')
+                                     .replace(jsSuffixRegExp, '');
+                    });
+                }
+
+                //If there are any "waiting to execute" modules in the registry,
+                //update the maps for them, since their info, like URLs to load,
+                //may have changed.
+                eachProp(registry, function (mod, id) {
+                    //If module already has init called, since it is too
+                    //late to modify them, and ignore unnormalized ones
+                    //since they are transient.
+                    if (!mod.inited && !mod.map.unnormalized) {
+                        mod.map = makeModuleMap(id, null, true);
+                    }
+                });
+
+                //If a deps array or a config callback is specified, then call
+                //require with those args. This is useful when require is defined as a
+                //config object before require.js is loaded.
+                if (cfg.deps || cfg.callback) {
+                    context.require(cfg.deps || [], cfg.callback);
+                }
+            },
+
+            makeShimExports: function (value) {
+                function fn() {
+                    var ret;
+                    if (value.init) {
+                        ret = value.init.apply(global, arguments);
+                    }
+                    return ret || (value.exports && getGlobal(value.exports));
+                }
+                return fn;
+            },
+
+            makeRequire: function (relMap, options) {
+                options = options || {};
+
+                function localRequire(deps, callback, errback) {
+                    var id, map, requireMod;
+
+                    if (options.enableBuildCallback && callback && isFunction(callback)) {
+                        callback.__requireJsBuild = true;
+                    }
+
+                    if (typeof deps === 'string') {
+                        if (isFunction(callback)) {
+                            //Invalid call
+                            return onError(makeError('requireargs', 'Invalid require call'), errback);
+                        }
+
+                        //If require|exports|module are requested, get the
+                        //value for them from the special handlers. Caveat:
+                        //this only works while module is being defined.
+                        if (relMap && hasProp(handlers, deps)) {
+                            return handlers[deps](registry[relMap.id]);
+                        }
+
+                        //Synchronous access to one module. If require.get is
+                        //available (as in the Node adapter), prefer that.
+                        if (req.get) {
+                            return req.get(context, deps, relMap, localRequire);
+                        }
+
+                        //Normalize module name, if it contains . or ..
+                        map = makeModuleMap(deps, relMap, false, true);
+                        id = map.id;
+
+                        if (!hasProp(defined, id)) {
+                            return onError(makeError('notloaded', 'Module name "' +
+                                        id +
+                                        '" has not been loaded yet for context: ' +
+                                        contextName +
+                                        (relMap ? '' : '. Use require([])')));
+                        }
+                        return defined[id];
+                    }
+
+                    //Grab defines waiting in the global queue.
+                    intakeDefines();
+
+                    //Mark all the dependencies as needing to be loaded.
+                    context.nextTick(function () {
+                        //Some defines could have been added since the
+                        //require call, collect them.
+                        intakeDefines();
+
+                        requireMod = getModule(makeModuleMap(null, relMap));
+
+                        //Store if map config should be applied to this require
+                        //call for dependencies.
+                        requireMod.skipMap = options.skipMap;
+
+                        requireMod.init(deps, callback, errback, {
+                            enabled: true
+                        });
+
+                        checkLoaded();
+                    });
+
+                    return localRequire;
+                }
+
+                mixin(localRequire, {
+                    isBrowser: isBrowser,
+
+                    /**
+                     * Converts a module name + .extension into an URL path.
+                     * *Requires* the use of a module name. It does not support using
+                     * plain URLs like nameToUrl.
+                     */
+                    toUrl: function (moduleNamePlusExt) {
+                        var ext,
+                            index = moduleNamePlusExt.lastIndexOf('.'),
+                            segment = moduleNamePlusExt.split('/')[0],
+                            isRelative = segment === '.' || segment === '..';
+
+                        //Have a file extension alias, and it is not the
+                        //dots from a relative path.
+                        if (index !== -1 && (!isRelative || index > 1)) {
+                            ext = moduleNamePlusExt.substring(index, moduleNamePlusExt.length);
+                            moduleNamePlusExt = moduleNamePlusExt.substring(0, index);
+                        }
+
+                        return context.nameToUrl(normalize(moduleNamePlusExt,
+                                                relMap && relMap.id, true), ext,  true);
+                    },
+
+                    defined: function (id) {
+                        return hasProp(defined, makeModuleMap(id, relMap, false, true).id);
+                    },
+
+                    specified: function (id) {
+                        id = makeModuleMap(id, relMap, false, true).id;
+                        return hasProp(defined, id) || hasProp(registry, id);
+                    }
+                });
+
+                //Only allow undef on top level require calls
+                if (!relMap) {
+                    localRequire.undef = function (id) {
+                        //Bind any waiting define() calls to this context,
+                        //fix for #408
+                        takeGlobalQueue();
+
+                        var map = makeModuleMap(id, relMap, true),
+                            mod = getOwn(registry, id);
+
+                        mod.undefed = true;
+                        removeScript(id);
+
+                        delete defined[id];
+                        delete urlFetched[map.url];
+                        delete undefEvents[id];
+
+                        //Clean queued defines too. Go backwards
+                        //in array so that the splices do not
+                        //mess up the iteration.
+                        eachReverse(defQueue, function(args, i) {
+                            if (args[0] === id) {
+                                defQueue.splice(i, 1);
+                            }
+                        });
+                        delete context.defQueueMap[id];
+
+                        if (mod) {
+                            //Hold on to listeners in case the
+                            //module will be attempted to be reloaded
+                            //using a different config.
+                            if (mod.events.defined) {
+                                undefEvents[id] = mod.events;
+                            }
+
+                            cleanRegistry(id);
+                        }
+                    };
+                }
+
+                return localRequire;
+            },
+
+            /**
+             * Called to enable a module if it is still in the registry
+             * awaiting enablement. A second arg, parent, the parent module,
+             * is passed in for context, when this method is overridden by
+             * the optimizer. Not shown here to keep code compact.
+             */
+            enable: function (depMap) {
+                var mod = getOwn(registry, depMap.id);
+                if (mod) {
+                    getModule(depMap).enable();
+                }
+            },
+
+            /**
+             * Internal method used by environment adapters to complete a load event.
+             * A load event could be a script load or just a load pass from a synchronous
+             * load call.
+             * @param {String} moduleName the name of the module to potentially complete.
+             */
+            completeLoad: function (moduleName) {
+                var found, args, mod,
+                    shim = getOwn(config.shim, moduleName) || {},
+                    shExports = shim.exports;
+
+                takeGlobalQueue();
+
+                while (defQueue.length) {
+                    args = defQueue.shift();
+                    if (args[0] === null) {
+                        args[0] = moduleName;
+                        //If already found an anonymous module and bound it
+                        //to this name, then this is some other anon module
+                        //waiting for its completeLoad to fire.
+                        if (found) {
+                            break;
+                        }
+                        found = true;
+                    } else if (args[0] === moduleName) {
+                        //Found matching define call for this script!
+                        found = true;
+                    }
+
+                    callGetModule(args);
+                }
+                context.defQueueMap = {};
+
+                //Do this after the cycle of callGetModule in case the result
+                //of those calls/init calls changes the registry.
+                mod = getOwn(registry, moduleName);
+
+                if (!found && !hasProp(defined, moduleName) && mod && !mod.inited) {
+                    if (config.enforceDefine && (!shExports || !getGlobal(shExports))) {
+                        if (hasPathFallback(moduleName)) {
+                            return;
+                        } else {
+                            return onError(makeError('nodefine',
+                                             'No define call for ' + moduleName,
+                                             null,
+                                             [moduleName]));
+                        }
+                    } else {
+                        //A script that does not call define(), so just simulate
+                        //the call for it.
+                        callGetModule([moduleName, (shim.deps || []), shim.exportsFn]);
+                    }
+                }
+
+                checkLoaded();
+            },
+
+            /**
+             * Converts a module name to a file path. Supports cases where
+             * moduleName may actually be just an URL.
+             * Note that it **does not** call normalize on the moduleName,
+             * it is assumed to have already been normalized. This is an
+             * internal API, not a public one. Use toUrl for the public API.
+             */
+            nameToUrl: function (moduleName, ext, skipExt) {
+                var paths, syms, i, parentModule, url,
+                    parentPath, bundleId,
+                    pkgMain = getOwn(config.pkgs, moduleName);
+
+                if (pkgMain) {
+                    moduleName = pkgMain;
+                }
+
+                bundleId = getOwn(bundlesMap, moduleName);
+
+                if (bundleId) {
+                    return context.nameToUrl(bundleId, ext, skipExt);
+                }
+
+                //If a colon is in the URL, it indicates a protocol is used and it is just
+                //an URL to a file, or if it starts with a slash, contains a query arg (i.e. ?)
+                //or ends with .js, then assume the user meant to use an url and not a module id.
+                //The slash is important for protocol-less URLs as well as full paths.
+                if (req.jsExtRegExp.test(moduleName)) {
+                    //Just a plain path, not module name lookup, so just return it.
+                    //Add extension if it is included. This is a bit wonky, only non-.js things pass
+                    //an extension, this method probably needs to be reworked.
+                    url = moduleName + (ext || '');
+                } else {
+                    //A module that needs to be converted to a path.
+                    paths = config.paths;
+
+                    syms = moduleName.split('/');
+                    //For each module name segment, see if there is a path
+                    //registered for it. Start with most specific name
+                    //and work up from it.
+                    for (i = syms.length; i > 0; i -= 1) {
+                        parentModule = syms.slice(0, i).join('/');
+
+                        parentPath = getOwn(paths, parentModule);
+                        if (parentPath) {
+                            //If an array, it means there are a few choices,
+                            //Choose the one that is desired
+                            if (isArray(parentPath)) {
+                                parentPath = parentPath[0];
+                            }
+                            syms.splice(0, i, parentPath);
+                            break;
+                        }
+                    }
+
+                    //Join the path parts together, then figure out if baseUrl is needed.
+                    url = syms.join('/');
+                    url += (ext || (/^data\:|\?/.test(url) || skipExt ? '' : '.js'));
+                    url = (url.charAt(0) === '/' || url.match(/^[\w\+\.\-]+:/) ? '' : config.baseUrl) + url;
+                }
+
+                return config.urlArgs ? url +
+                                        ((url.indexOf('?') === -1 ? '?' : '&') +
+                                         config.urlArgs) : url;
+            },
+
+            //Delegates to req.load. Broken out as a separate function to
+            //allow overriding in the optimizer.
+            load: function (id, url) {
+                req.load(context, id, url);
+            },
+
+            /**
+             * Executes a module callback function. Broken out as a separate function
+             * solely to allow the build system to sequence the files in the built
+             * layer in the right sequence.
+             *
+             * @private
+             */
+            execCb: function (name, callback, args, exports) {
+                return callback.apply(exports, args);
+            },
+
+            /**
+             * callback for script loads, used to check status of loading.
+             *
+             * @param {Event} evt the event from the browser for the script
+             * that was loaded.
+             */
+            onScriptLoad: function (evt) {
+                //Using currentTarget instead of target for Firefox 2.0's sake. Not
+                //all old browsers will be supported, but this one was easy enough
+                //to support and still makes sense.
+                if (evt.type === 'load' ||
+                        (readyRegExp.test((evt.currentTarget || evt.srcElement).readyState))) {
+                    //Reset interactive script so a script node is not held onto for
+                    //to long.
+                    interactiveScript = null;
+
+                    //Pull out the name of the module and the context.
+                    var data = getScriptData(evt);
+                    context.completeLoad(data.id);
+                }
+            },
+
+            /**
+             * Callback for script errors.
+             */
+            onScriptError: function (evt) {
+                var data = getScriptData(evt);
+                if (!hasPathFallback(data.id)) {
+                    var parents = [];
+                    eachProp(registry, function(value, key) {
+                        if (key.indexOf('_@r') !== 0) {
+                            each(value.depMaps, function(depMap) {
+                                if (depMap.id === data.id) {
+                                    parents.push(key);
+                                }
+                                return true;
+                            });
+                        }
+                    });
+                    return onError(makeError('scripterror', 'Script error for "' + data.id +
+                                             (parents.length ?
+                                             '", needed by: ' + parents.join(', ') :
+                                             '"'), evt, [data.id]));
+                }
+            }
+        };
+
+        context.require = context.makeRequire();
+        return context;
+    }
+
+    /**
+     * Main entry point.
+     *
+     * If the only argument to require is a string, then the module that
+     * is represented by that string is fetched for the appropriate context.
+     *
+     * If the first argument is an array, then it will be treated as an array
+     * of dependency string names to fetch. An optional function callback can
+     * be specified to execute when all of those dependencies are available.
+     *
+     * Make a local req variable to help Caja compliance (it assumes things
+     * on a require that are not standardized), and to give a short
+     * name for minification/local scope use.
+     */
+    req = requirejs = function (deps, callback, errback, optional) {
+
+        //Find the right context, use default
+        var context, config,
+            contextName = defContextName;
+
+        // Determine if have config object in the call.
+        if (!isArray(deps) && typeof deps !== 'string') {
+            // deps is a config object
+            config = deps;
+            if (isArray(callback)) {
+                // Adjust args if there are dependencies
+                deps = callback;
+                callback = errback;
+                errback = optional;
+            } else {
+                deps = [];
+            }
+        }
+
+        if (config && config.context) {
+            contextName = config.context;
+        }
+
+        context = getOwn(contexts, contextName);
+        if (!context) {
+            context = contexts[contextName] = req.s.newContext(contextName);
+        }
+
+        if (config) {
+            context.configure(config);
+        }
+
+        return context.require(deps, callback, errback);
+    };
+
+    /**
+     * Support require.config() to make it easier to cooperate with other
+     * AMD loaders on globally agreed names.
+     */
+    req.config = function (config) {
+        return req(config);
+    };
+
+    /**
+     * Execute something after the current tick
+     * of the event loop. Override for other envs
+     * that have a better solution than setTimeout.
+     * @param  {Function} fn function to execute later.
+     */
+    req.nextTick = typeof setTimeout !== 'undefined' ? function (fn) {
+        setTimeout(fn, 4);
+    } : function (fn) { fn(); };
+
+    /**
+     * Export require as a global, but only if it does not already exist.
+     */
+    if (!require) {
+        require = req;
+    }
+
+    req.version = version;
+
+    //Used to filter out dependencies that are already paths.
+    req.jsExtRegExp = /^\/|:|\?|\.js$/;
+    req.isBrowser = isBrowser;
+    s = req.s = {
+        contexts: contexts,
+        newContext: newContext
+    };
+
+    //Create default context.
+    req({});
+
+    //Exports some context-sensitive methods on global require.
+    each([
+        'toUrl',
+        'undef',
+        'defined',
+        'specified'
+    ], function (prop) {
+        //Reference from contexts instead of early binding to default context,
+        //so that during builds, the latest instance of the default context
+        //with its config gets used.
+        req[prop] = function () {
+            var ctx = contexts[defContextName];
+            return ctx.require[prop].apply(ctx, arguments);
+        };
+    });
+
+    if (isBrowser) {
+        head = s.head = document.getElementsByTagName('head')[0];
+        //If BASE tag is in play, using appendChild is a problem for IE6.
+        //When that browser dies, this can be removed. Details in this jQuery bug:
+        //http://dev.jquery.com/ticket/2709
+        baseElement = document.getElementsByTagName('base')[0];
+        if (baseElement) {
+            head = s.head = baseElement.parentNode;
+        }
+    }
+
+    /**
+     * Any errors that require explicitly generates will be passed to this
+     * function. Intercept/override it if you want custom error handling.
+     * @param {Error} err the error object.
+     */
+    req.onError = defaultOnError;
+
+    /**
+     * Creates the node for the load command. Only used in browser envs.
+     */
+    req.createNode = function (config, moduleName, url) {
+        var node = config.xhtml ?
+                document.createElementNS('http://www.w3.org/1999/xhtml', 'html:script') :
+                document.createElement('script');
+        node.type = config.scriptType || 'text/javascript';
+        node.charset = 'utf-8';
+        node.async = true;
+        return node;
+    };
+
+    /**
+     * Does the request to load a module for the browser case.
+     * Make this a separate function to allow other environments
+     * to override it.
+     *
+     * @param {Object} context the require context to find state.
+     * @param {String} moduleName the name of the module.
+     * @param {Object} url the URL to the module.
+     */
+    req.load = function (context, moduleName, url) {
+        var config = (context && context.config) || {},
+            node;
+        if (isBrowser) {
+            //In the browser so use a script tag
+            node = req.createNode(config, moduleName, url);
+            if (config.onNodeCreated) {
+                config.onNodeCreated(node, config, moduleName, url);
+            }
+
+            node.setAttribute('data-requirecontext', context.contextName);
+            node.setAttribute('data-requiremodule', moduleName);
+
+            //Set up load listener. Test attachEvent first because IE9 has
+            //a subtle issue in its addEventListener and script onload firings
+            //that do not match the behavior of all other browsers with
+            //addEventListener support, which fire the onload event for a
+            //script right after the script execution. See:
+            //https://connect.microsoft.com/IE/feedback/details/648057/script-onload-event-is-not-fired-immediately-after-script-execution
+            //UNFORTUNATELY Opera implements attachEvent but does not follow the script
+            //script execution mode.
+            if (node.attachEvent &&
+                    //Check if node.attachEvent is artificially added by custom script or
+                    //natively supported by browser
+                    //read https://github.com/jrburke/requirejs/issues/187
+                    //if we can NOT find [native code] then it must NOT natively supported.
+                    //in IE8, node.attachEvent does not have toString()
+                    //Note the test for "[native code" with no closing brace, see:
+                    //https://github.com/jrburke/requirejs/issues/273
+                    !(node.attachEvent.toString && node.attachEvent.toString().indexOf('[native code') < 0) &&
+                    !isOpera) {
+                //Probably IE. IE (at least 6-8) do not fire
+                //script onload right after executing the script, so
+                //we cannot tie the anonymous define call to a name.
+                //However, IE reports the script as being in 'interactive'
+                //readyState at the time of the define call.
+                useInteractive = true;
+
+                node.attachEvent('onreadystatechange', context.onScriptLoad);
+                //It would be great to add an error handler here to catch
+                //404s in IE9+. However, onreadystatechange will fire before
+                //the error handler, so that does not help. If addEventListener
+                //is used, then IE will fire error before load, but we cannot
+                //use that pathway given the connect.microsoft.com issue
+                //mentioned above about not doing the 'script execute,
+                //then fire the script load event listener before execute
+                //next script' that other browsers do.
+                //Best hope: IE10 fixes the issues,
+                //and then destroys all installs of IE 6-9.
+                //node.attachEvent('onerror', context.onScriptError);
+            } else {
+                node.addEventListener('load', context.onScriptLoad, false);
+                node.addEventListener('error', context.onScriptError, false);
+            }
+            node.src = url;
+
+            //For some cache cases in IE 6-8, the script executes before the end
+            //of the appendChild execution, so to tie an anonymous define
+            //call to the module name (which is stored on the node), hold on
+            //to a reference to this node, but clear after the DOM insertion.
+            currentlyAddingScript = node;
+            if (baseElement) {
+                head.insertBefore(node, baseElement);
+            } else {
+                head.appendChild(node);
+            }
+            currentlyAddingScript = null;
+
+            return node;
+        } else if (isWebWorker) {
+            try {
+                //In a web worker, use importScripts. This is not a very
+                //efficient use of importScripts, importScripts will block until
+                //its script is downloaded and evaluated. However, if web workers
+                //are in play, the expectation is that a build has been done so
+                //that only one script needs to be loaded anyway. This may need
+                //to be reevaluated if other use cases become common.
+                importScripts(url);
+
+                //Account for anonymous modules
+                context.completeLoad(moduleName);
+            } catch (e) {
+                context.onError(makeError('importscripts',
+                                'importScripts failed for ' +
+                                    moduleName + ' at ' + url,
+                                e,
+                                [moduleName]));
+            }
+        }
+    };
+
+    function getInteractiveScript() {
+        if (interactiveScript && interactiveScript.readyState === 'interactive') {
+            return interactiveScript;
+        }
+
+        eachReverse(scripts(), function (script) {
+            if (script.readyState === 'interactive') {
+                return (interactiveScript = script);
+            }
+        });
+        return interactiveScript;
+    }
+
+    //Look for a data-main script attribute, which could also adjust the baseUrl.
+    if (isBrowser && !cfg.skipDataMain) {
+        //Figure out baseUrl. Get it from the script tag with require.js in it.
+        eachReverse(scripts(), function (script) {
+            //Set the 'head' where we can append children by
+            //using the script's parent.
+            if (!head) {
+                head = script.parentNode;
+            }
+
+            //Look for a data-main attribute to set main script for the page
+            //to load. If it is there, the path to data main becomes the
+            //baseUrl, if it is not already set.
+            dataMain = script.getAttribute('data-main');
+            if (dataMain) {
+                //Preserve dataMain in case it is a path (i.e. contains '?')
+                mainScript = dataMain;
+
+                //Set final baseUrl if there is not already an explicit one.
+                if (!cfg.baseUrl) {
+                    //Pull off the directory of data-main for use as the
+                    //baseUrl.
+                    src = mainScript.split('/');
+                    mainScript = src.pop();
+                    subPath = src.length ? src.join('/')  + '/' : './';
+
+                    cfg.baseUrl = subPath;
+                }
+
+                //Strip off any trailing .js since mainScript is now
+                //like a module name.
+                mainScript = mainScript.replace(jsSuffixRegExp, '');
+
+                //If mainScript is still a path, fall back to dataMain
+                if (req.jsExtRegExp.test(mainScript)) {
+                    mainScript = dataMain;
+                }
+
+                //Put the data-main script in the files to load.
+                cfg.deps = cfg.deps ? cfg.deps.concat(mainScript) : [mainScript];
+
+                return true;
+            }
+        });
+    }
+
+    /**
+     * The function that handles definitions of modules. Differs from
+     * require() in that a string for the module should be the first argument,
+     * and the function to execute after dependencies are loaded should
+     * return a value to define the module corresponding to the first argument's
+     * name.
+     */
+    define = function (name, deps, callback) {
+        var node, context;
+
+        //Allow for anonymous modules
+        if (typeof name !== 'string') {
+            //Adjust args appropriately
+            callback = deps;
+            deps = name;
+            name = null;
+        }
+
+        //This module may not have dependencies
+        if (!isArray(deps)) {
+            callback = deps;
+            deps = null;
+        }
+
+        //If no name, and callback is a function, then figure out if it a
+        //CommonJS thing with dependencies.
+        if (!deps && isFunction(callback)) {
+            deps = [];
+            //Remove comments from the callback string,
+            //look for require calls, and pull them into the dependencies,
+            //but only if there are function args.
+            if (callback.length) {
+                callback
+                    .toString()
+                    .replace(commentRegExp, '')
+                    .replace(cjsRequireRegExp, function (match, dep) {
+                        deps.push(dep);
+                    });
+
+                //May be a CommonJS thing even without require calls, but still
+                //could use exports, and module. Avoid doing exports and module
+                //work though if it just needs require.
+                //REQUIRES the function to expect the CommonJS variables in the
+                //order listed below.
+                deps = (callback.length === 1 ? ['require'] : ['require', 'exports', 'module']).concat(deps);
+            }
+        }
+
+        //If in IE 6-8 and hit an anonymous define() call, do the interactive
+        //work.
+        if (useInteractive) {
+            node = currentlyAddingScript || getInteractiveScript();
+            if (node) {
+                if (!name) {
+                    name = node.getAttribute('data-requiremodule');
+                }
+                context = contexts[node.getAttribute('data-requirecontext')];
+            }
+        }
+
+        //Always save off evaluating the def call until the script onload handler.
+        //This allows multiple modules to be in a file without prematurely
+        //tracing dependencies, and allows for anonymous module support,
+        //where the module name is not known until the script onload event
+        //occurs. If no context, use the global queue, and get it processed
+        //in the onscript load callback.
+        if (context) {
+            context.defQueue.push([name, deps, callback]);
+            context.defQueueMap[name] = true;
+        } else {
+            globalDefQueue.push([name, deps, callback]);
+        }
+    };
+
+    define.amd = {
+        jQuery: true
+    };
+
+    /**
+     * Executes the text. Normally just uses eval, but can be modified
+     * to use a better, environment-specific call. Only used for transpiling
+     * loader plugins, not for plain JS modules.
+     * @param {String} text the text to execute/evaluate.
+     */
+    req.exec = function (text) {
+        /*jslint evil: true */
+        return eval(text);
+    };
+
+    //Set up with config info.
+    req(cfg);
+}(this));
diff --git a/libs/util.js b/libs/util.js
new file mode 100644
index 0000000000..8f44207dd2
--- /dev/null
+++ b/libs/util.js
@@ -0,0 +1,3 @@
+define(function () {
+  return (sel) => document.querySelector(sel);
+});
diff --git a/libs/vid.js b/libs/vid.js
new file mode 100644
index 0000000000..cdd14cd401
--- /dev/null
+++ b/libs/vid.js
@@ -0,0 +1,73 @@
+define(['util'], function ($) {
+
+  function camera2video(_video = {}) {
+    if (_video.tagName !== 'VIDEO') {
+      throw Error('Pipes only to video elements');
+    }
+    var self = {
+      stop: foo => {
+        self.stream.getTracks().map(x => x.stop());
+        self.playing = false;
+        _video.src = '';
+        return self;
+      },
+      pipe: stream => {
+        self.stream = stream;
+        self.source = window.URL.createObjectURL(stream);
+        self.playing = true;
+        _video.src = self.source;
+        _video.play();
+        return self;
+      },
+      start: foo => {
+        navigator.mediaDevices.getUserMedia({
+          video: true,
+        }).then(self.pipe).catch(err => console.error(err));
+        return self;
+      },
+    };
+
+    return self.start();
+  }
+
+  function video2canvas(_video, _canvas) {
+    var context, height, width, interval;
+
+    context = _canvas.getContext('2d');
+    height = _canvas.height = _video.videoHeight;
+    width = _canvas.width = _video.videoWidth;
+    interval = setInterval(foo => {
+      context.drawImage(_video, 0, 0, width, height);
+    });
+    _video.hidden = true;
+
+    return {
+      _: 'video2canvas',
+      _video, _canvas, context, height, width, interval,
+    };
+  }
+
+  function snapCanvas(_canvas, _blurb) {
+    var data, link;
+
+    data = _canvas.toDataURL('image/jpeg');
+    link = document.createElement('a');
+
+    link.href = data;
+    link.setAttribute('download', _blurb);
+    link.innerHTML = `<image src="${data}" alt="${_blurb}" width=100>`;
+
+    $('body').insertBefore(link, $('body').firstChild);
+
+    return {
+      _: 'snapCanvas',
+      _canvas, _blurb, data, link,
+    };
+  }
+
+  return {
+    camera2video,
+    video2canvas,
+    snapCanvas,
+  };
+});

From 2bfbbf29371dfece44c3de54b015fd26c247a753 Mon Sep 17 00:00:00 2001
From: dvdrtrgn <dvdrtrgn@gmail.com>
Date: Sat, 31 Dec 2016 15:40:18 -0600
Subject: [PATCH 26/28] update libs

---
 19 - Webcam Fun/main.js | 27 +++++++++--------
 libs/interval.js        | 64 +++++++++++++++++++++++++++++++++++++++++
 libs/util.js            | 12 ++++++--
 libs/vid.js             | 14 ++++-----
 4 files changed, 93 insertions(+), 24 deletions(-)
 create mode 100644 libs/interval.js

diff --git a/19 - Webcam Fun/main.js b/19 - Webcam Fun/main.js
index d11fbda306..99066d3e10 100644
--- a/19 - Webcam Fun/main.js	
+++ b/19 - Webcam Fun/main.js	
@@ -5,36 +5,35 @@ require.config({
   paths: {
     lodash: '../vendors/lodash.js/lodash',
   },
-  shim: {
-    foo: {
-      deps: ['lodash'],
-      exports: 'Foo',
-    },
-  },
 });
 
-function init($, V) {
+function init($, V, Ival) {
+
   var cfg = {
     _: 'init()',
     $play: $('button.play'),
     $photo: $('canvas.photo'),
     $video: $('video.player'),
     $snap: $('button.shot'),
+    interval: Ival.create($.noop, 999),
+    cameraObj: null,
+    canvasObj: null,
   };
 
-  cfg.camera2video = V.camera2video(cfg.$video);
+  cfg.cameraObj = V.pipeCameraTo(cfg.$video);
 
   cfg.$video.addEventListener('canplay', evt => {
-    if (!cfg.video2canvas) {
-      cfg.video2canvas = V.video2canvas(cfg.$video, cfg.$photo);
+    if (!cfg.canvasObj) {
+      cfg.canvasObj = V.video2canvas(cfg.$video, cfg.$photo);
+      cfg.interval.setAction(cfg.canvasObj.draw);
     }
   });
 
   cfg.$play.addEventListener('click', evt => {
-    if (!cfg.camera2video.playing) {
-      cfg.camera2video.start();
+    if (!cfg.cameraObj.playing) {
+      cfg.cameraObj.start();
     } else {
-      cfg.camera2video.stop();
+      cfg.cameraObj.stop();
     }
   });
 
@@ -49,4 +48,4 @@ function init($, V) {
   return cfg;
 }
 
-require(['./util', './vid'], init);
+require(['util', 'vid', 'interval'], init);
diff --git a/libs/interval.js b/libs/interval.js
new file mode 100644
index 0000000000..5145bea59d
--- /dev/null
+++ b/libs/interval.js
@@ -0,0 +1,64 @@
+define(['util'], {
+  create: function (_fn, _ms, _once) {
+    var count, interval, action, rate, self;
+
+    function _clear() {
+      interval = window.clearInterval(interval);
+    }
+
+    function _makeInterval(once) {
+      interval = window.setInterval((foo) => {
+        if (once && count) return _clear();
+        count++;
+        action(foo);
+      }, rate > 9 ? rate : 99);
+    }
+
+    function _reload() {
+      _clear();
+      _makeInterval();
+    }
+
+    function _create(fn, ms, once) {
+      count = 0;
+      _clear();
+      setAction(fn);
+      setRate(ms);
+      _makeInterval(once);
+      return self;
+    }
+    /*
+
+    PUBLIC
+
+    */
+    function setAction(fn) {
+      action = fn;
+    }
+
+    function setRate(ms) {
+      rate = ms;
+      if (interval) _reload();
+    }
+
+    function start() {
+      _reload();
+    }
+
+    function stop() {
+      _clear();
+    }
+
+    self = Object.create({
+      get count() {
+        return count;
+      },
+      setAction,
+      setRate,
+      start,
+      stop,
+    });
+
+    return _create(_fn, _ms, _once);
+  }
+});
diff --git a/libs/util.js b/libs/util.js
index 8f44207dd2..a19e32fad3 100644
--- a/libs/util.js
+++ b/libs/util.js
@@ -1,3 +1,9 @@
-define(function () {
-  return (sel) => document.querySelector(sel);
-});
+function PolyJQ() {
+  let polyjq = (sel) => document.querySelector(sel);
+  polyjq.noop = () => {};
+  return polyjq;
+};
+
+define(PolyJQ);
+
+polyjq = PolyJQ();
diff --git a/libs/vid.js b/libs/vid.js
index cdd14cd401..e5a7792410 100644
--- a/libs/vid.js
+++ b/libs/vid.js
@@ -1,6 +1,6 @@
 define(['util'], function ($) {
 
-  function camera2video(_video = {}) {
+  function pipeCameraTo(_video = {}) {
     if (_video.tagName !== 'VIDEO') {
       throw Error('Pipes only to video elements');
     }
@@ -31,19 +31,19 @@ define(['util'], function ($) {
   }
 
   function video2canvas(_video, _canvas) {
-    var context, height, width, interval;
+    var context, height, width;
 
     context = _canvas.getContext('2d');
     height = _canvas.height = _video.videoHeight;
     width = _canvas.width = _video.videoWidth;
-    interval = setInterval(foo => {
-      context.drawImage(_video, 0, 0, width, height);
-    });
     _video.hidden = true;
 
     return {
       _: 'video2canvas',
-      _video, _canvas, context, height, width, interval,
+      _video, _canvas, context, height, width,
+      draw: foo => {
+        context.drawImage(_video, 0, 0, width, height);
+      },
     };
   }
 
@@ -66,7 +66,7 @@ define(['util'], function ($) {
   }
 
   return {
-    camera2video,
+    pipeCameraTo,
     video2canvas,
     snapCanvas,
   };

From a9d02854b89538189e807a4d56e677d979e49793 Mon Sep 17 00:00:00 2001
From: dvdrtrgn <dvdrtrgn@gmail.com>
Date: Mon, 2 Jan 2017 21:51:58 -0600
Subject: [PATCH 27/28] shuffle libs

---
 19 - Webcam Fun/main.js          | 8 ++++----
 {libs => 19 - Webcam Fun}/vid.js | 2 +-
 libs/interval.js                 | 2 +-
 3 files changed, 6 insertions(+), 6 deletions(-)
 rename {libs => 19 - Webcam Fun}/vid.js (97%)

diff --git a/19 - Webcam Fun/main.js b/19 - Webcam Fun/main.js
index 99066d3e10..e97487ad7c 100644
--- a/19 - Webcam Fun/main.js	
+++ b/19 - Webcam Fun/main.js	
@@ -1,13 +1,13 @@
 'use strict';
 
 require.config({
-  baseUrl: '../libs',
+  baseUrl: '.',
   paths: {
-    lodash: '../vendors/lodash.js/lodash',
+    lib: '../libs/',
   },
 });
 
-function init($, V, Ival) {
+function init($, Ival, V) {
 
   var cfg = {
     _: 'init()',
@@ -48,4 +48,4 @@ function init($, V, Ival) {
   return cfg;
 }
 
-require(['util', 'vid', 'interval'], init);
+require(['lib/util', 'lib/interval', 'vid'], init);
diff --git a/libs/vid.js b/19 - Webcam Fun/vid.js
similarity index 97%
rename from libs/vid.js
rename to 19 - Webcam Fun/vid.js
index e5a7792410..be18f0022d 100644
--- a/libs/vid.js
+++ b/19 - Webcam Fun/vid.js	
@@ -1,4 +1,4 @@
-define(['util'], function ($) {
+define(['lib/util'], function ($) {
 
   function pipeCameraTo(_video = {}) {
     if (_video.tagName !== 'VIDEO') {
diff --git a/libs/interval.js b/libs/interval.js
index 5145bea59d..38c044add5 100644
--- a/libs/interval.js
+++ b/libs/interval.js
@@ -1,4 +1,4 @@
-define(['util'], {
+define(['lib/util'], {
   create: function (_fn, _ms, _once) {
     var count, interval, action, rate, self;
 

From 229620b6454966264ecf1b09bcea58ba826badb1 Mon Sep 17 00:00:00 2001
From: dvdrtrgn <dvdrtrgn@gmail.com>
Date: Mon, 2 Jan 2017 21:59:10 -0600
Subject: [PATCH 28/28] hijack provided index

---
 19 - Webcam Fun/index.html          | 14 +++++++++-----
 19 - Webcam Fun/scripts-FINISHED.js |  3 ++-
 19 - Webcam Fun/vid.html            | 16 ----------------
 3 files changed, 11 insertions(+), 22 deletions(-)
 delete mode 100644 19 - Webcam Fun/vid.html

diff --git a/19 - Webcam Fun/index.html b/19 - Webcam Fun/index.html
index d4ffc4dc2a..192370eb47 100755
--- a/19 - Webcam Fun/index.html	
+++ b/19 - Webcam Fun/index.html	
@@ -4,13 +4,17 @@
   <meta charset="UTF-8">
   <title>Get User Media Code Along!</title>
   <link rel="stylesheet" href="style.css">
+  <script src="../libs/require.js" data-main="./main"></script>
 </head>
 <body>
 
   <div class="photobooth">
     <div class="controls">
-      <button onClick="takePhoto()">Take Photo</button>
-<!--       <div class="rgb">
+      <!-- <button onClick="takePhoto()">Take Photo</button> -->
+      <button class="play">Play/Pause</button>
+      <button class="shot">Snapshot</button>
+
+      <!-- <div class="rgb">
         <label for="rmin">Red Min:</label>
         <input type="range" min=0 max=255 name="rmin">
         <label for="rmax">Red Max:</label>
@@ -29,8 +33,8 @@
         <input type="range" min=0 max=255 name="bmin">
         <label for="bmax">Blue Max:</label>
         <input type="range" min=0 max=255 name="bmax">
-      </div> -->
-    </div>
+      </div>
+    </div> -->
 
     <canvas class="photo"></canvas>
     <video class="player"></video>
@@ -39,7 +43,7 @@
 
   <audio class="snap" src="http://wesbos.com/demos/photobooth/snap.mp3" hidden></audio>
 
-  <script src="scripts.js"></script>
+  <!-- <script src="scripts-FINISHED.js"></script> -->
 
 </body>
 </html>
diff --git a/19 - Webcam Fun/scripts-FINISHED.js b/19 - Webcam Fun/scripts-FINISHED.js
index 0d62c8dc23..5eb2ee2270 100755
--- a/19 - Webcam Fun/scripts-FINISHED.js	
+++ b/19 - Webcam Fun/scripts-FINISHED.js	
@@ -23,13 +23,14 @@ function paintToCanavas() {
   canvas.height = height;
 
   return setInterval(() => {
+    if (!window.go) return;
     ctx.drawImage(video, 0, 0, width, height);
     // take the pixels out
     let pixels = ctx.getImageData(0, 0, width, height);
     // mess with them
     // pixels = redEffect(pixels);
 
-    pixels = rgbSplit(pixels);
+    pixels = greenScreen(pixels);
     // ctx.globalAlpha = 0.8;
 
     // pixels = greenScreen(pixels);
diff --git a/19 - Webcam Fun/vid.html b/19 - Webcam Fun/vid.html
deleted file mode 100644
index 2788447114..0000000000
--- a/19 - Webcam Fun/vid.html	
+++ /dev/null
@@ -1,16 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <head>
-    <meta charset="utf-8">
-    <title>vid test</title>
-    <script src="../libs/require.js" data-main="./main"></script>
-  </head>
-  <body>
-    <br>
-    <canvas class="photo"></canvas>
-    <video class="player"></video>
-    <hr>
-    <button class="play">Play/Pause</button>
-    <button class="shot">Snapshot</button>
-  </body>
-</html>