first commit

public/bower_components/messenger/docs/intro.md

@@ -0,0 +1,318 @@
+<script type="text/javascript" src="build/js/messenger.js"></script>
+<script type="text/javascript" src="build/js/messenger-theme-future.js"></script>
+<link rel="stylesheet" type="text/css" media="screen" href="build/css/messenger.css">
+<link rel="stylesheet" type="text/css" media="screen" href="build/css/messenger-theme-future.css">
+
+# Messenger
+
+#### [Demo and Usage](http://hubspot.github.com/messenger/docs/welcome)
+
+- Show messages in your app.
+- Wrap AJAX requests with progress, success and error messages, and add retry to your failed requests.
+- Add actions (undo, cancel, etc.) to your messages.
+
+Messenger is different from other solutions for a few reasons:
+
+- Each message can be updated after being posted without losing it's place
+- Actions and events can be bound to messages
+- It's completely themeable with CSS
+- A 'tray' element exists to allow you to style the box around the messages, and limit the number
+of messages on the screen
+
+### Messenger Object
+
+Messenger is accessed through a global `Messenger` object.  The object is called at each usage to give
+it a chance to instantiate if necessary.
+
+The most basic usage is to post a message:
+
+```javascript
+Messenger().post({ options })
+```
+
+Options can be a string representing the body of the message:
+
+```javascript
+Messenger().post("Welcome to the darkside (tm)")
+```
+
+It can also be an object:
+
+```javascript
+Messenger().post({
+  message: "How's it going?",
+  type: "error"
+})
+```
+
+The full list of options:
+
+- `message`: The text of the message
+- `type`: `info`, `error` or `success` are understood by the provided themes. You can also pass your
+own string, and that class will be added.
+- `theme`: What theme class should be applied to the message? Defaults to the theme set for Messenger in
+general.
+- `id`: A unique id.  If supplied, only one message with that ID will be shown at a time.
+- `singleton`: Hide the newer message if there is an `id` collision, as opposed to the older message.
+- `actions`: Action links to put in the message, see the 'Actions' section on this page.
+- `hideAfter`: Hide the message after the provided number of seconds
+- `hideOnNavigate`: Hide the message if Backbone client-side navigation occurs
+- `showCloseButton`: Should a close button be added to the message?
+- `closeButtonText`: Specify the text the close button should use (default: &times;)
+- `escapeText`: Should messenger escape message text? (default: false)
+- `onClickClose`: Function that executes when the close button is clicked
+
+Messenger also includes aliases which set the `type` for you: `Messenger().error()`, `Messenger().success()`, and `Messenger().info()`.
+
+### Updating Messages
+
+Rather than posting a new message when progress occurs, it can be nice to update an existing message.
+
+`.post`, along with the other message posting methods, provide a `Message` instance which has the
+following methods:
+
+- `show()`: Show the message, if it's hidden
+- `hide()`: Hide the message, if it's shown
+- `cancel()`: If the message is associated with an ajax request or is counting down to retry, cancel it
+- `update({ options })`: Update the message with the provided options
+
+Any option, such as `type` or `message` can be changed with `update`:
+
+```javascript
+message = Messenger().post("Calculating position")
+message.update({
+  type: "error",
+  message: "Error calculating position"
+})
+```
+
+### Messenger Object
+
+When `Messenger` is called, it creates, if necessary, a container for future messages to be placed into.
+`Messenger` can be passed options to configure the container when it's first called, future calls will
+alter the existing container.
+
+`Messenger` options:
+
+- `extraClasses`: Extra classes to be appended to the container.  These can be used to configure the active theme.
+If you'd like the messenger box to be overlayed on the screen, you should provide the `messenger-fixed` class along with any of
+the following positioning classes: `messenger-on-bottom`, `messenger-on-top`, `messenger-on-left`, `messenger-on-right`.
+Adding the `top` or `bottom` class along with a `left` or `right` will move the messenger dialog into the specified corner.
+- `maxMessages`: The maximum number of messages to show at once
+- `parentLocations`: Which locations should be tried when inserting the message container into the page.  The default is `['body']`.
+It accepts a list to allow you to try a variety of places when deciding what the optimal location is on any given page.  This should
+generally not need to be changed unless you are inserting the messages into the flow of the document, rather than using `messenger-fixed`.
+- `theme`: What theme are you using? Some themes have associated javascript, specifing this allows that js to run.
+- `messageDefaults`: Default options for created messages
+
+```javascript
+Messenger({
+  parentLocations: ['.page'], // Let's insert it into the page
+  extraClasses: ''            // And not add the fixed classes
+})
+
+// Future calls just need to refer to Messenger(), they'll get the same instance
+```
+
+```javascript
+Messenger({
+  // Let's put the messenger in the top left corner
+  extraClasses: 'messenger-fixed messenger-on-left messenger-on-top'
+});
+```
+
+The object provided by `Messenger()` also has a couple of additional methods:
+
+- `hideAll`: Hide all messages
+- `run`: See 'Running Things' below
+- `ajax`: See 'Running Things' below
+- `expectPromise`: See 'Running Things' below
+- `hookBackboneAjax`: See Backbone below
+
+### Running Things
+
+One of the most common use cases for messenger is to show the progress and success or error of an asynchronous action, like an ajax request.
+Messenger includes a method to help with that, `run`.
+
+`run({ messageOptions }, { actionOptions })`
+
+messageOptions:
+
+- `action`: The function which should be passed `actionOptions`.  `success` and `error` callbacks will be added to `actionOptions`
+and used to show the appropriate messages.
+- `successMessage`: What message should be shown if the action is a success?  Can be a string, or false if no message should be shown.  Can also
+be a function returning a string, message options object, or false.
+- `errorMessage`: Same as success message, but shown after the `error` callback is called.
+- `progressMessage`: A message to be shown while the action is underway, or false.
+- `showSuccessWithoutError`: Set to false if you only want the success message to be shown if the success comes after a failure
+- `ignoredErrorCodes`: By default the error handler looks for `xhr.status`, assuming the action is $.ajax.  If it is, this can be set to an
+array of HTTP status codes which should _not_ be considered an error.
+- `returnsPromise`: If true, instead of wrapping the `success` and `error` callbacks passed to `action`, we expect `action` to return to
+us a promise, and use that to show the appropriate messages.
+- `retry`: Set to false to not have the action retried if it fails.  Or set it to an object with the following options:
+  - `allow`: Should we show a manual 'Retry' button?
+  - `auto`: Should we automatically start the retry timer after a failure?
+- Any other message options
+
+Your success and error handlers can return false if they don't wish the message to be shown.  They can also return a string to change the
+message, or an object to change more message options.
+
+```javascript
+Messenger().run({
+  action: $.ajax,
+
+  successMessage: 'Contact saved',
+  errorMessage: 'Error saving contact',
+  progressMessage: 'Saving contact...'
+}, {
+  /* These options are provided to $.ajax, with success and error wrapped */
+  url: '/contact',
+  data: contact,
+
+  error: function(resp){
+    if (resp.status === 409)
+      return "A contact with that email already exists";
+  }
+});
+```
+
+We also provide a couple of aliases:
+
+- `Messenger().ajax({ messageOptions }, { actionOptions })`:  Call `run` with `$.ajax` as the action (which is already the default).
+- `Messenger().expectPromise(action, { messageOptions })`: Call `run` with a function which returns a promise, so actionOptions aren't necessary.
+
+```javascript
+Messenger().expectPromise(function(){
+  return $.ajax({
+    url: '/aliens/44',
+    type: 'DELETE'
+  });
+}, {
+  successMessage: 'Alien Destroyed!',
+  progressMessage: false
+});
+```
+
+All three methods return a `Message` instance.  You can call `message.cancel()` to stop the retrying, if necessary.
+
+### Actions
+
+You can pass messages a hash of actions the user can execute on the message.  For example, `run` will add 'Retry' and 'Cancel'
+buttons to error messages which have retry enabled.
+
+Actions are provided as the `actions` hash to `post` or `run`:
+
+```javascript
+msg = Messenger().post({
+  message: "Are you sure you'd like to delete this contact?",
+
+  actions: {
+    delete: {
+      label: "Delete",
+      action: function(){
+        delete()
+        msg.hide()
+      }
+    },
+
+    cancel: {
+      action: function(){
+        msg.hide()
+      }
+    }
+  }
+})
+```
+
+### Events
+
+You can add DOM event handlers to the message itself, or any element within it.  For example, you might wish to do
+something when the user clicks on the message.
+
+The format of the event key is: "`[type] event [selector]`"
+
+Type is a message type, like `success`, `error`, or `info`, or skip to ignore the type.  It's useful with `run` where
+the same options are getting applied to the `success` and `error` messages.
+Event is the DOM event to bind to.
+Selector is any jQuery selector, or skip to bind to the message element itsef.
+
+```javascript
+Messenger().post({
+  message: "Click me to explode!",
+
+  events: {
+    "click": function(e){
+      explode();
+    },
+    "hover a.button": function(e){
+      e.stopPropagation();
+    }
+  }
+});
+```
+
+### Backbone.js
+
+Messenger includes a function to hook into Backbone.js' sync method.  To enable it, call `Messenger().hookBackboneAjax({ defaultOptions })`
+before making any Backbone requests (but after bringing in the Backbone.js js file).
+
+You can pass it any default message options you would like to apply to your requests.  You can also set those options as `messenger` in
+your save and fetch calls.
+
+```javascript
+Messenger().hookBackboneAjax({
+  errorMessage: 'Error syncing with the server',
+  retry: false
+});
+
+// Later on:
+myModel.save({
+  errorMessage: 'Error saving contact'
+});
+```
+
+### Classes
+
+Each message can have the following classes:
+
+- `messenger-hidden` (message): Applied when a message is hidden
+- `messenger-will-hide-after` (message): Applied if the `hideAfter` option is not false
+- `messenger-will-hide-on-navigate` (message): Applied if the `hideOnNavigate` option is not false
+- `messenger-clickable` (message): Applied if a 'click' event is included in the events hash
+- `messenger-message` (message): Applied to all messages
+- `messenger-{type}` (message): Applied based on the message's `type` (usually 'success', 'error', or 'info')
+- `message`, `alert`, `alert-{type}` (message): Added for compatiblity with external CSS
+- `messenger-retry-soon` (message): Added when the next retry will occur in less than or equal to 10s
+- `messenger-retry-later` (message): Added when the next retry will occur in greater than 10s (usually 5min)
+
+Every message lives in a slot, which is a li in the list of all the messages which have been created:
+
+- `messenger-first` (slot): Added when this slot is the first shown slot in the list
+- `messenger-last` (slot): Added when this slot is the last shown slot in the list
+- `messenger-shown` (slot): Added when this slot is visible
+
+All the slots are in a tray element:
+
+- `messenger-empty` (tray): Added when there are no visible messages
+- `messenger-theme-{theme}` (tray): Added based on the passed in `theme` option
+
+### Multiple Messenger Trays
+
+You can have multiple messenger trays on the page at the same time.  Manually create them using the
+jQuery method:
+
+```javascript
+instance = $('.myContainer').messenger();
+```
+
+You can then pass your instance into the messenger methods:
+
+```javascript
+Messenger({instance: instance}).post("My awesome message")
+```
+
+### Contributing
+
+The build process requires nodejs and grunt-cli.
+You can build the output files by running `grunt`.
+The automated tests can be run by opening SpecRunner.html in a browser.

public/bower_components/messenger/docs/welcome/iframe-demo.html

@@ -0,0 +1,120 @@
+<!DOCTYPE html>
+<html>
+
+  <head>
+    <meta charset='utf-8' />
+    <meta http-equiv="X-UA-Compatible" content="chrome=1" />
+    <meta name="description" content="Messenger : Alerts for the 21st century" />
+
+    <link rel="stylesheet" type="text/css" media="screen" href="stylesheets/stylesheet.css">
+    <link rel="stylesheet" type="text/css" media="screen" href="stylesheets/location-sel.css">
+    <link rel="stylesheet" type="text/css" media="screen" href="stylesheets/theme-sel.css">
+    <link rel="stylesheet" type="text/css" media="screen" href="stylesheets/demo.css">
+    <link rel="stylesheet" type="text/css" media="screen" href="../../build/css/messenger.css">
+    <link rel="stylesheet" type="text/css" media="screen" href="../../build/css/messenger-theme-block.css">
+    <link rel="stylesheet" type="text/css" media="screen" href="../../build/css/messenger-theme-future.css">
+    <link rel="stylesheet" type="text/css" media="screen" href="../../build/css/messenger-theme-air.css">
+    <link rel="stylesheet" type="text/css" media="screen" href="../../build/css/messenger-theme-ice.css">
+    <link rel="stylesheet" type="text/css" media="screen" href="../../build/css/messenger-theme-flat.css">
+    <link rel="stylesheet" type="text/css" media="screen" href="lib/executr/build/css/executr.css">
+    <link rel="stylesheet" type="text/css" media="screen" href="lib/executr/lib/CodeMirror/codemirror.css">
+
+    <script type="text/javascript" src="http://cdnjs.cloudflare.com/ajax/libs/jquery/1.9.0/jquery.min.js"></script>
+    <script type="text/javascript" src="http://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.4.3/underscore-min.js"></script>
+    <script type="text/javascript" src="http://cdnjs.cloudflare.com/ajax/libs/backbone.js/0.9.10/backbone-min.js"></script>
+    <script type="text/javascript" src="../../build/js/messenger.min.js"></script>
+    <script type="text/javascript" src="../../build/js/messenger-theme-future.js"></script>
+
+    <script type="text/javascript" src="javascripts/location-sel.js"></script>
+    <script type="text/javascript" src="javascripts/theme-sel.js"></script>
+
+    <script type="text/javascript" src="lib/executr/lib/CodeMirror/codemirror.js"></script>
+    <script type="text/javascript" src="lib/executr/lib/CodeMirror/mode/coffeescript/coffeescript.js"></script>
+    <script type="text/javascript" src="lib/executr/lib/CodeMirror/mode/javascript/javascript.js"></script>
+    <script type="text/javascript" src="lib/executr/build/js/executr.js"></script>
+    <script type="text/javascript" src="lib/executr/lib/coffee-script.js"></script>
+
+    <script type="text/javascript">
+      $(function(){
+
+        Messenger.options = {
+          extraClasses: "messenger-fixed messenger-on-bottom",
+          theme: "air"
+        };
+
+        var alienAttemptMsg;
+
+        var steps = [
+          function() {
+            var msg = Messenger().post({
+              message: 'Launching thermonuclear war...',
+              type: 'info',
+              actions: {
+                cancel: {
+                  label: 'cancel launch',
+                  action: function() {
+                    msg.update({
+                      message: 'Thermonuclear war averted.',
+                      type: 'success',
+                      actions: false
+                    });
+                  }
+                }
+              }
+            });
+            setTimeout(function(){
+              msg.update({
+                message: 'Thermonuclear war averted.',
+                type: 'success',
+                actions: false
+              });
+            }, 4000);
+            setTimeout(function(){ msg.hide(); }, 8000);
+          },
+          function() {
+            alienAttemptMsg = Messenger().post({
+              message: 'Attempting to destory alien planet...',
+              type: 'info'
+            });
+          },
+          function() {
+            var i = 0;
+            alienAttemptMsg.hide();
+            Messenger().run({
+              errorMessage: 'Error destroying alien planet',
+              successMessage: 'Alien planet destroyed!',
+              action: function(opts) {
+                if (++i < 3) {
+                  return opts.error({
+                    status: 500,
+                    readyState: 0,
+                    responseText: 0
+                  });
+                } else {
+                  return opts.success();
+                }
+              }
+            });
+          },
+          function() {
+            //Pause
+          }
+        ];
+
+        var i = 1;
+
+        steps[0]();
+        setInterval(function(){
+          steps[i]();
+          i = (i + 1) % steps.length;
+        }, 6000);
+
+      });
+    </script>
+
+    <title>Messenger &ndash; Demo</title>
+  </head>
+
+  <body style="background: #fff">
+  </body>
+</html>

public/bower_components/messenger/docs/welcome/index.html

@@ -0,0 +1,440 @@
+<!DOCTYPE html>
+<html>
+
+  <head>
+    <meta charset='utf-8' />
+    <meta http-equiv="X-UA-Compatible" content="chrome=1" />
+    <meta name="description" content="Messenger : Alerts for the 21st century" />
+
+    <link rel="stylesheet" type="text/css" media="screen" href="stylesheets/stylesheet.css">
+    <link rel="stylesheet" type="text/css" media="screen" href="stylesheets/location-sel.css">
+    <link rel="stylesheet" type="text/css" media="screen" href="stylesheets/theme-sel.css">
+    <link rel="stylesheet" type="text/css" media="screen" href="stylesheets/demo.css">
+    <link rel="stylesheet" type="text/css" media="screen" href="../../build/css/messenger.css">
+    <link rel="stylesheet" type="text/css" media="screen" href="../../build/css/messenger-theme-block.css">
+    <link rel="stylesheet" type="text/css" media="screen" href="../../build/css/messenger-theme-future.css">
+    <link rel="stylesheet" type="text/css" media="screen" href="../../build/css/messenger-theme-air.css">
+    <link rel="stylesheet" type="text/css" media="screen" href="../../build/css/messenger-theme-ice.css">
+    <link rel="stylesheet" type="text/css" media="screen" href="../../build/css/messenger-theme-flat.css">
+    <link rel="stylesheet" type="text/css" media="screen" href="lib/executr/build/css/executr.css">
+    <link rel="stylesheet" type="text/css" media="screen" href="lib/executr/lib/CodeMirror/codemirror.css">
+
+    <script type="text/javascript" src="http://cdnjs.cloudflare.com/ajax/libs/jquery/1.9.0/jquery.min.js"></script>
+    <script type="text/javascript" src="http://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.4.3/underscore-min.js"></script>
+    <script type="text/javascript" src="http://cdnjs.cloudflare.com/ajax/libs/backbone.js/0.9.10/backbone-min.js"></script>
+    <script type="text/javascript" src="http://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/2.2.2/bootstrap.min.js"></script>
+    <script type="text/javascript" src="../../build/js/messenger.js"></script>
+    <script type="text/javascript" src="../../build/js/messenger-theme-future.js"></script>
+    <script type="text/javascript" src="../../build/js/messenger-theme-flat.js"></script>
+
+    <script type="text/javascript" src="javascripts/location-sel.js"></script>
+    <script type="text/javascript" src="javascripts/theme-sel.js"></script>
+    <script type="text/javascript" src="javascripts/demo.js"></script>
+
+    <script type="text/javascript" src="lib/executr/lib/CodeMirror/codemirror.js"></script>
+    <script type="text/javascript" src="lib/executr/lib/CodeMirror/mode/coffeescript/coffeescript.js"></script>
+    <script type="text/javascript" src="lib/executr/lib/CodeMirror/mode/javascript/javascript.js"></script>
+    <script type="text/javascript" src="lib/executr/build/js/executr.js"></script>
+    <script type="text/javascript" src="lib/executr/lib/coffee-script.js"></script>
+
+    <script type="text/javascript">
+      $(function(){
+          $('body').executr();
+      });
+    </script>
+
+    <title>Messenger - Alerts for the 21st Century</title>
+  </head>
+
+  <body>
+
+    <!-- HEADER -->
+    <div id="header_wrap" class="outer">
+        <header class="inner">
+          <a id="forkme_banner" href="https://github.com/HubSpot/messenger">View on GitHub</a>
+
+          <div class="social">
+            <iframe src="http://ghbtns.com/github-btn.html?user=HubSpot&repo=messenger&type=watch"
+                allowtransparency="true" frameborder="0" scrolling="0" width="62" height="20"></iframe>
+
+            <a href="https://twitter.com/share" class="twitter-share-button" data-via="HubSpotDev" data-count="none" data-url="http://github.hubspot.com/messenger/">Tweet</a>
+            <script>!function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0];if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src="http://platform.twitter.com/widgets.js";fjs.parentNode.insertBefore(js,fjs);}}(document,"script","twitter-wjs");</script>
+          </div>
+
+          <h1 id="project_title">Messenger</h1>
+          <h2 id="project_tagline">Alerts for the 21st century</h2>
+
+            <section id="downloads">
+              <a class="zip_download_link" href="https://github.com/HubSpot/messenger/zipball/master">Download this project as a .zip file</a>
+              <a class="tar_download_link" href="https://github.com/HubSpot/messenger/tarball/master">Download this project as a tar.gz file</a>
+            </section>
+        </header>
+    </div>
+
+    <!-- MAIN CONTENT -->
+    <div id="main_content_wrap" class="outer">
+      <section id="main_content" class="inner">
+        <h1>HubSpot Messaging Library</h1>
+
+        <ul>
+          <li>Show transactional messages in your app.
+          <li>Wrap AJAX requests with progress, success and error messages.
+          <li>Add action links to your messages.
+          <li>4kb minified and compressed.
+          <li>Works in everything modern, and IE7 and above.
+        </ul>
+
+<h2>Demo</h2>
+
+<style>
+.iframe-demo {
+  height: 240px;
+  width: 100%;
+  -webkit-box-sizing: border-box;
+  -moz-box-sizing: border-box;
+  box-sizing: border-box;
+  border: 5px solid #f5f5f5;
+  border-top-width: 40px;
+  -webkit-box-shadow: 0 0 0 1px #ccc, 0 0 10px rgba(0, 0, 0 ,.1);
+  -moz-box-shadow: 0 0 0 1px #ccc, 0 0 10px rgba(0, 0, 0 ,.1);
+  box-shadow: 0 0 0 1px #ccc, 0 0 10px rgba(0, 0, 0 ,.1);
+  -webkit-border-radius: 4px;
+  -moz-border-radius: 4px;
+  border-radius: 4px;
+}
+</style>
+<iframe class="iframe-demo" src="iframe-demo.html"></iframe>
+
+<h2>Requires</h2>
+
+<ul>
+<li>jQuery</li>
+<li>Plays well with, but doesn't require, Bootstrap</ul>
+
+<h2>Including</h2>
+
+<h3>JS</h3>
+
+<pre><code>/build/js/messenger.min.js
+/build/js/messenger-theme-future.js
+</code></pre>
+
+<h3>CSS</h3>
+
+<pre><code>/build/css/messenger.css
+/build/css/messenger-theme-future.css
+</code></pre>
+
+<p>
+  Also available as a <a href="https://github.com/benjis/messengerjs-rails">Rails gem</a> and on <a href="http://cdnjs.com/">cdnjs</a>.
+</p>
+
+<h2>Really Quick Usage</h2>
+<pre>
+<code executable>
+# Replace:
+$.ajax
+    url: "/some-url"
+    success: ->
+
+# With:
+Messenger().run
+    errorMessage: "This did not go well."
+,
+    url: "/some-url"
+    success: ->
+</code>
+</pre>
+<h2>Usage <span class="subtitle">Click Code to Edit</span></h2>
+<div class='controls'>
+  <div>
+    <h4>Change Location</h4>
+    <div class='location-selector'></div>
+  </div>
+  <div>
+    <h4>Change Theme</h4>
+    <ul class='theme-selector'></ul>
+  </div>
+  <div>
+    <h4>Change Language</h4>
+    <ul class='selector'>
+      <li class="executr-switch" data-code-type="javascript"/>JavaScript</li>
+      <li class="executr-switch" data-code-type="coffeescript"/>CoffeeScript</li>
+    </ul>
+  </div>
+  <hr class="clear"></hr>
+  <pre><code><output></output></code></pre>
+</div>
+<pre>
+<code executable>
+Messenger().post "Your request has succeded!"
+</code><code executable>
+Messenger().post
+    message: 'There was an explosion while processing your request.'
+    type: 'error'
+    showCloseButton: true
+</code><code executable>
+msg = Messenger().post "My Message"
+msg.update "I changed my mind, this is my message"
+msg.hide()
+</code><code executable>
+# Want to put actions at the end of your messages?
+msg = Messenger().post
+    message: 'Launching thermonuclear war...'
+    type: 'info'
+    actions:
+        cancel:
+            label: 'cancel launch'
+            action: ->
+                msg.update
+                    message: 'Thermonuclear war averted'
+                    type: 'success'
+                    actions: false
+</code><code executable>
+# This guy will 500 a few times, then succeed
+i = 0
+Messenger().run
+  errorMessage: 'Error destroying alien planet'
+  successMessage: 'Alien planet destroyed!'
+
+  action: (opts) ->
+    if (++i < 3)
+      opts.error({status: 500, readyState: 0, responseText: 0})
+    else
+      opts.success()
+
+</code><code executable>
+# Have an error? How about auto retrys with a Gmail-style countdown
+# (hidden in the future theme)?:
+msg = Messenger().post
+    message: "I'm sorry Hal, I just can't do that."
+    actions:
+        retry:
+            label: 'retry now'
+            phrase: 'Retrying TIME'
+            auto: true
+            delay: 10
+            action: ->
+                # Do some retrying...
+
+        cancel:
+            action: ->
+                do msg.cancel
+</code><code executable>
+# You can bind to action events as well:
+msg.on 'action:retry', ->
+    alert('Hey, you retried!')
+</code><code executable>
+# Need more control? You can bind events backbone-style based
+# on the type of message.
+msg.update
+    events:
+        'success click': ->
+            # Will fire when the user clicks the message
+            # in a success state.
+
+        'error click a.awesome-class': ->
+            # Rock on
+</code><code executable>
+# Need your message to hide after a while, or when the Backbone
+# router changes the page?
+Messenger().post
+    message: "Weeeeee"
+
+    hideAfter: 10
+    hideOnNavigate: true
+</code><code executable>
+# You can use the id property to ensure that only one
+# instance of a message will appear on the page at a time
+# (the older message will be hidden).
+Messenger().post
+  message: "Only one at a time!"
+  id: "Only-one-message"
+</code><code executable>
+# When you add the singleton attribute, it ensures that no
+# other messages with that id will ever be shown again
+# (the newer message will be hidden).
+Messenger().post
+  message: "It's just me!"
+  id: '4'
+  singleton: true
+
+Messenger().post
+  message: "You'll never see me"
+  id: '4'
+  singleton: true
+</code><code executable>
+# Rather than hiding and showing multiple messages
+# you can also maintain a single message between
+# requests.
+msg = Messenger().run()
+Messenger().run({messageInstance: msg})
+</code><code executable>
+# Don't want your message hidden on a long page? (Not necessary
+# if you're using the default fixed positioning)
+msg = Messenger().post
+    message: "You'll see me!"
+
+    scrollTo: true
+    # Requires jQuery scrollTo plugin
+</code><code executable>
+msg.scrollTo() # also works
+</code><code executable>
+# Lazy/smart? How about messenger does it all for you?  All the
+# retry magic comes with.
+Messenger().run
+    successMessage: 'Data saved.'
+    errorMessage: 'Error saving data'
+    progressMessage: 'Saving data' # Don't include messages you
+                                   # don't want to appear.
+
+    # Any standard message opts can go here
+,
+    # All the standard jQuery ajax options here
+
+    url: '/data'
+</code><code executable>
+# Need to override the messages based on the response?
+Messenger().run
+    errorMessage: 'Oops'
+,
+    url: '/data'
+    error: (xhr) ->
+        # Whatever you return from your handlers will replace
+        # the default messages
+
+        if xhr?.status is 404
+            return "Data not found"
+
+        # Return true or undefined for your predefined message
+        # Return false to not show any message
+
+        return true
+</code><code executable>
+# Sometimes you only want to show the success message when a
+# retry succeeds, not if a retry wasen't required:
+Messenger().run
+    successMessage: 'Successfully saved.'
+    errorMessage: 'Error saving'
+
+    showSuccessWithoutError: false
+,
+    url: '/data'
+</code><code executable>
+# You don't have to use $.ajax as your action, messenger works
+# great for any async process:
+Messenger().run
+    successMessage: 'Bomb defused successfully'
+
+    action: defuseBomb
+    # You can put options for defuseBomb here
+    # It will be passed success and error callbacks
+</code><code executable>
+# Need to hide all messages?
+Messenger().hideAll()
+</code><code executable>
+# If your action responds with a promise-like thing, its
+# methods will be copied onto the message:
+
+Messenger().run({}, {url: 'a'}).fail(-> alert "Uh oh")
+</code><code executable>
+# Do you use Backbone? Hook all backbone calls:
+Messenger().hookBackboneAjax()
+
+# By default, there will be no error message (just background
+# retries), return an error message from your backbone error handler,
+# or add an errorMessage to the messenger opts to set one.
+# You can override these options by passing them into
+# hookBackboneAjax, or adding a {'messenger': } hash to your
+# fetch call.
+</code><code executable>
+# You don't have to use the global messenger
+$('div#message-container').messenger().post "My message"
+</code><code executable>
+# By default, the global messenger will create an ActionMessenger
+# instance fixed to the bottom-right corner of the screen.
+</code><code executable>
+# You can pass an instance of messenger into globalMessenger
+# to override the default position.
+myAwesomeMessenger = $('.mess').messenger()
+Messenger({instance: myAwesomeMessenger});
+
+Messenger() # <-- Will return your messenger
+</code><code executable>
+Messenger({'parentLocations': ['.page', 'body']});
+# Will try to insert the messenger into the el matching
+# .page before inserting it into the page.
+
+# This can be important if you're not using fixed positioning.
+</code><code executable>
+# All the options for globalMessenger and their defaults:
+
+{
+  'parentLocations': ['body'],
+  'maxMessages': 9,
+  'extraClasses': 'messenger-fixed messenger-on-right messenger-on-bottom messenger-theme-future',
+  'instance': undefined,
+  'messageDefaults': {
+    # Default message options
+    hideAfter: 10,
+    scroll: true,
+    closeButtonText: "&times;",
+    escapeText: false
+  }
+}
+</code><code executable>
+# You can also set default options on the Messenger.options object.
+Messenger.options = {'extraClasses': 'messenger-fixed messenger-on-left'}
+</code>
+</pre>
+
+<h1>Contributing</h1>
+
+<p>We welcome contributors!</p>
+<p>
+The build process requires nodejs and <a href="http://gruntjs.com/getting-started" target="_blank">grunt-cli</a>.
+You can build the output files by running <code>grunt</code>.
+The automated tests can be run by opening SpecRunner.html in a browser.
+</p>
+<p>
+There is plenty to be done, pick an <a href="https://github.com/HubSpot/messenger/issues?state=open">issue</a> and start hacking!
+</p>
+</section>
+    </div>
+
+    <!-- FOOTER  -->
+    <div id="footer_wrap" class="outer">
+      <footer class="inner">
+        <p class="copyright">
+          Messenger maintained by <a href="https://github.com/HubSpot">HubSpot</a>
+          -
+          <a href="http://dev.hubspot.com/jobs?utm_campaign=os&utm_source=referral">We're Hiring</a>
+        </p>
+        <p>Published with <a href="http://pages.github.com">GitHub Pages</a></p>
+        <p>Documentation powered by <a href="https://github.com/Hubspot/executr">Executr</a></p>
+      </footer>
+    </div>
+
+    <!-- Start of Async HubSpot Analytics Code -->
+    <script type="text/javascript">
+        (function(d,s,i,r) {
+            if (d.getElementById(i)){return;}
+            var n=d.createElement(s),e=d.getElementsByTagName(s)[0];
+            n.id=i;n.src='//js.hubspot.com/analytics/'+(Math.ceil(new Date()/r)*r)+'/51294.js';
+            e.parentNode.insertBefore(n, e);
+        })(document,"script","hs-analytics",300000);
+    </script>
+    <!-- End of Async HubSpot Analytics Code -->
+
+    <script>
+      (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
+      (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
+      m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
+      })(window,document,'script','//www.google-analytics.com/analytics.js','ga');
+
+      ga('create', 'UA-45159009-1', 'hubspot.com');
+      ga('send', 'pageview');
+
+    </script>
+  </body>
+</html>

public/bower_components/messenger/docs/welcome/javascripts/demo.js

@@ -0,0 +1,41 @@
+$(function(){
+  Messenger().post("Thanks for checking out Messenger!");
+
+  var loc = ['bottom', 'right'];
+  var style = 'flat';
+
+  var $output = $('.controls output');
+  var $lsel = $('.location-selector');
+  var $tsel = $('.theme-selector');
+
+  var update = function(){
+    var classes = 'messenger-fixed';
+
+    for (var i=0; i < loc.length; i++)
+      classes += ' messenger-on-' + loc[i];
+
+    $.globalMessenger({ extraClasses: classes, theme: style });
+    Messenger.options = { extraClasses: classes, theme: style };
+
+    $output.text("Messenger.options = {\n    extraClasses: '" + classes + "',\n    theme: '" + style + "'\n}");
+  };
+
+  update();
+
+  $lsel.locationSelector()
+    .on('update', function(pos){
+      loc = pos;
+
+      update();
+    })
+  ;
+
+  $tsel.themeSelector({
+    themes: ['flat', 'future', 'block', 'air', 'ice']
+  }).on('update', function(theme){
+    style = theme;
+
+    update();
+  });
+
+});

public/bower_components/messenger/docs/welcome/javascripts/execute.coffee

@@ -0,0 +1,19 @@
+$.fn.executr = (opts) ->
+  defaults =
+    codeSelector: 'code[executable]'
+
+  opts = $.extend {}, defaults, opts
+
+  this.on 'click', opts.codeSelector, (e) ->
+    $target = $ e.target
+    $code = $target.parents(opts.codeSelector)
+
+    ctx = window
+    if opts.setUp?
+      CoffeeScript.run opts.setUp, ctx
+
+    CoffeeScript.run $code.text(), ctx
+
+    if opts.tearDown?
+      CoffeeScript.run opts.tearDown, ctx
+

public/bower_components/messenger/docs/welcome/javascripts/location-sel.coffee

@@ -0,0 +1,41 @@
+class LocationSelector extends Backbone.View
+  className: 'location-selector'
+
+  events:
+    'click .bit': 'handleClick'
+
+  render: ->
+    @$el.html ''
+
+    do @draw
+
+  draw: ->
+    @_addBit 'top left'
+    @_addBit 'top right'
+    @_addBit 'top'
+
+    @_addBit 'bottom left'
+    @_addBit 'bottom right'
+    @_addBit 'bottom'
+
+  _addBit: (classes) ->
+    bit = $ '<div>'
+    bit.addClass "bit #{ classes }"
+    bit.attr 'data-position', classes
+    @$el.append bit
+
+    bit
+
+  handleClick: (e) ->
+    $bit = $ e.target
+
+    @trigger 'update', $bit.attr('data-position').split(' ')
+
+$.fn.locationSelector = (opts) ->
+  loc = new LocationSelector $.extend {}, opts,
+    el: this
+
+  $(this).addClass loc.className
+  loc.render()
+
+  loc

public/bower_components/messenger/docs/welcome/javascripts/location-sel.js

@@ -0,0 +1,63 @@
+(function() {
+  var LocationSelector,
+    __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  LocationSelector = (function(_super) {
+
+    __extends(LocationSelector, _super);
+
+    function LocationSelector() {
+      return LocationSelector.__super__.constructor.apply(this, arguments);
+    }
+
+    LocationSelector.prototype.className = 'location-selector';
+
+    LocationSelector.prototype.events = {
+      'click .bit': 'handleClick'
+    };
+
+    LocationSelector.prototype.render = function() {
+      this.$el.html('');
+      return this.draw();
+    };
+
+    LocationSelector.prototype.draw = function() {
+      this._addBit('top left');
+      this._addBit('top right');
+      this._addBit('top');
+      this._addBit('bottom left');
+      this._addBit('bottom right');
+      return this._addBit('bottom');
+    };
+
+    LocationSelector.prototype._addBit = function(classes) {
+      var bit;
+      bit = $('<div>');
+      bit.addClass("bit " + classes);
+      bit.attr('data-position', classes);
+      this.$el.append(bit);
+      return bit;
+    };
+
+    LocationSelector.prototype.handleClick = function(e) {
+      var $bit;
+      $bit = $(e.target);
+      return this.trigger('update', $bit.attr('data-position').split(' '));
+    };
+
+    return LocationSelector;
+
+  })(Backbone.View);
+
+  $.fn.locationSelector = function(opts) {
+    var loc;
+    loc = new LocationSelector($.extend({}, opts, {
+      el: this
+    }));
+    $(this).addClass(loc.className);
+    loc.render();
+    return loc;
+  };
+
+}).call(this);

public/bower_components/messenger/docs/welcome/javascripts/main.js

@@ -0,0 +1 @@
+console.log('This would be the main JS file.');

public/bower_components/messenger/docs/welcome/javascripts/theme-sel.coffee

@@ -0,0 +1,30 @@
+class ThemeSelector extends Backbone.View
+  tagName: 'ul'
+  className: 'theme-selector'
+
+  events:
+    'click li': 'handleClick'
+
+  render: ->
+    @$el.html ''
+
+    for theme in @options.themes
+      $li = $ '<li>'
+      $li.attr 'data-id', theme
+      $li.text theme
+
+      @$el.append $li
+
+  handleClick: (e) ->
+    $li = $ e.target
+
+    @trigger 'update', $li.attr('data-id')
+
+$.fn.themeSelector = (opts) ->
+  sel = new ThemeSelector $.extend {}, opts,
+    el: this
+
+  $(this).addClass sel.className
+  sel.render()
+
+  sel

public/bower_components/messenger/docs/welcome/javascripts/theme-sel.js

@@ -0,0 +1,57 @@
+(function() {
+  var ThemeSelector,
+    __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  ThemeSelector = (function(_super) {
+
+    __extends(ThemeSelector, _super);
+
+    function ThemeSelector() {
+      return ThemeSelector.__super__.constructor.apply(this, arguments);
+    }
+
+    ThemeSelector.prototype.tagName = 'ul';
+
+    ThemeSelector.prototype.className = 'theme-selector';
+
+    ThemeSelector.prototype.events = {
+      'click li': 'handleClick'
+    };
+
+    ThemeSelector.prototype.render = function() {
+      var $li, theme, _i, _len, _ref, _results;
+      this.$el.html('');
+      _ref = this.options.themes;
+      _results = [];
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        theme = _ref[_i];
+        $li = $('<li>');
+        $li.attr('data-id', theme);
+        $li.text(theme);
+        _results.push(this.$el.append($li));
+      }
+      return _results;
+    };
+
+    ThemeSelector.prototype.handleClick = function(e) {
+      var $li;
+      $li = $(e.target);
+      return this.trigger('update', $li.attr('data-id'));
+    };
+
+    return ThemeSelector;
+
+  })(Backbone.View);
+
+  $.fn.themeSelector = function(opts) {
+    var sel;
+    sel = new ThemeSelector($.extend({}, opts, {
+      el: this
+    }));
+    $(this).addClass(sel.className);
+    sel.render();
+    return sel;
+  };
+
+}).call(this);

public/bower_components/messenger/docs/welcome/lib/executr/LICENSE

@@ -0,0 +1,8 @@
+Copyright (c) 2013 HubSpot, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

public/bower_components/messenger/docs/welcome/lib/executr/README.md

@@ -0,0 +1,93 @@
+## executr
+
+Let your users execute and play with the CoffeeScript and JavaScript in your documentation
+
+### Example
+
+See our messenger documentation for an example: http://hubspot.github.com/messenger/
+
+### Including
+
+````html
+<!-- You should already have jQuery included -->
+
+<!-- Code Mirror is used to make the code blocks editable -->
+<script type="text/javascript" src="lib/CodeMirror/codemirror.js"></script>
+
+<!-- Include the CodeMirror languages you're going to use -->
+<script type="text/javascript" src="lib/CodeMirror/mode/coffeescript/coffeescript.js"></script>
+<script type="text/javascript" src="lib/coffee-script.js"></script>
+
+<script type="text/javascript" src="build/js/executr.js"></script>
+
+<link rel="stylesheet" type="text/css" media="screen" href="lib/CodeMirror/codemirror.css">
+<link rel="stylesheet" type="text/css" media="screen" href="build/css/executr.css">
+````
+
+### Usage
+
+The code blocks you wish to be executable should be wrapped in `<code executable></code>`.
+
+Run `$.executr` on the container of multiple code elements, the body, or a single code block.
+
+The blocks will be converted into CodeMirror Editors, and a run button will be added.  If you're not interested
+in the code being editable, take a look at the v1.1 tag.
+
+Only the text (not tags) in the block will be executed, feel free to wrap your already-syntax-highlighted code.
+
+The code editor will assume the height + 10px and width of the code element.
+
+````html
+<pre><code executable>
+$ ->
+  alert "Testing!"
+</code></pre>
+````
+
+````javascript
+$(function(){
+  $('body').executr();
+});
+````
+
+You can also make javascript executable, by either adding a `data-type="javascript"` attribute to the code
+block, or by adding `defaultType: 'javascript'` to the executr call.
+
+````html
+<code data-type="javascript" executable>
+alert("Testing!");
+</code>
+````
+
+### Other Options
+
+$.executr can be passed the following options
+
+````coffeescript
+{
+    codeSelector: 'code[executable]' # The jQuery selector items to be bound must match
+
+    outputTo: 'div.output' # An element which should receive the output.
+    appendOutput: true # Whether output should replace the contents of outputTo, or append to it
+
+    defaultType: 'coffeescript' # The default source languange, if not supplied as a data-type attribute
+    type: 'coffeescript' # The type to force on all code blocks, even if otherwise specified.  Can also be a function.
+    coffeeOptions: {} # Extra options for the CoffeeScript compiler
+
+    codeMirrorOptions: {} # Extra options for CodeMirror
+
+    setUp: -> # Code to run before each code block
+    tearDown: -> # Code to run after each code block
+}
+````
+
+#### Events
+
+Executr will fire two events on the element it is bound to:
+
+- `executrBeforeExecute(code string, normalized code language, executr options)`
+- `executrAfterExecute(code output, code string, normalized code language, executr options)`
+
+#### Contributing
+
+You can build the project by running `./build.sh`.  It requires the CoffeeScript compiler.

public/bower_components/messenger/docs/welcome/lib/executr/build.sh

@@ -0,0 +1,4 @@
+cp src/css/* build/css
+
+coffee -o build/js src/coffee
+

public/bower_components/messenger/docs/welcome/lib/executr/build/css/executr.css

@@ -0,0 +1,38 @@
+code[executable] {
+  display: block;
+}
+
+.executr-code-editor {
+  overflow: hidden;
+  position: relative;
+  box-sizing: border-box;
+}
+.executr-code-editor .CodeMirror pre {
+  box-shadow: none;
+  border-width: 0;
+  line-height: 1.3;
+  font-family: Monaco, Menlo, Consolas, 'Courier New', monospace;
+  font-size: 13px;
+}
+.executr-code-editor .executr-run-button {
+  width: 84px;
+  padding: 0 10px;
+  font-size: 24px;
+  z-index: 5;
+  border-width: 0;
+  background-color: #DDD;
+
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  right: 0;
+
+  opacity: 0.5;
+}
+.executr-code-editor .executr-run-button:hover {
+  opacity: 0.8;
+}
+
+.CodeMirror {
+  height: auto;
+}

public/bower_components/messenger/docs/welcome/lib/executr/build/js/executr.js

@@ -0,0 +1,217 @@
+(function() {
+  var Editor, converters, getCodeElement, insertOutput, normalizeType, runners;
+  var __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+  runners = {
+    'javascript': function(opts, code) {
+      return eval(code);
+    }
+  };
+  converters = {
+    'coffeescript:javascript': function(opts, code) {
+      var csOptions;
+      csOptions = $.extend({}, opts.coffeeOptions, {
+        bare: true
+      });
+      return CoffeeScript.compile(code, csOptions);
+    },
+    'javascript:coffeescript': function(opts, code) {
+      var out;
+      if (Js2coffee) {
+        return out = Js2coffee.build(code);
+      } else {
+        console.error("Can't convert javascript to coffeescript");
+        return code;
+      }
+    }
+  };
+  normalizeType = function(codeType) {
+    switch (codeType.toLowerCase()) {
+      case 'js':
+      case 'javascript':
+      case 'text/javascript':
+      case 'application/javascript':
+        return 'javascript';
+      case 'cs':
+      case 'coffee':
+      case 'coffeescript':
+      case 'text/coffeescript':
+      case 'application/coffeescript':
+        return 'coffeescript';
+      default:
+        return console.error("Code type " + codeType + " not understood.");
+    }
+  };
+  Editor = (function() {
+    function Editor(args) {
+      this.el = args.el;
+      this.opts = args.opts;
+      this.codeCache = {};
+      this.$el = $(this.el);
+      this.buildEditor();
+      this.addRunButton();
+      this.addListeners();
+    }
+    Editor.prototype.getValue = function() {
+      return this.editor.getValue();
+    };
+    Editor.prototype.addListeners = function() {
+      return this.$el.on('executrSwitchType', __bind(function(e, type) {
+        return this.switchType(type);
+      }, this));
+    };
+    Editor.prototype.addRunButton = function() {
+      this.$runButton = $('<button>');
+      this.$runButton.addClass('executr-run-button');
+      this.$runButton.text(this.opts.buttonText);
+      this.$editorCont.append(this.$runButton);
+      this.$runButton.css({
+        top: "" + (this.$editorCont.height() / 2 - this.$runButton.height() / 2) + "px"
+      });
+      if (this.$editorCont.height() < parseInt(this.$runButton.css('font-size'), 10) + 4) {
+        this.$runButton.css('font-size', "" + (this.$editorCont.height() - 4) + "px");
+      }
+      return this.$runButton.click(__bind(function() {
+        return this.execute();
+      }, this));
+    };
+    Editor.prototype.buildEditor = function() {
+      var code, mirrorOpts, type, _ref, _ref2;
+      this.$editorCont = $('<div>');
+      this.$editorCont.addClass('executr-code-editor');
+      this.$editorCont.css({
+        height: "" + (this.$el.height() + 10) + "px",
+        width: "" + (this.$el.width()) + "px"
+      });
+      this.$editorCont.insertBefore(this.$el);
+      this.$el.detach();
+      if (typeof this.opts.type === 'function') {
+        type = this.opts.type(this.$el, this);
+      } else {
+        type = (_ref = (_ref2 = this.opts.type) != null ? _ref2 : this.$el.attr('data-type')) != null ? _ref : this.opts.defaultType;
+      }
+      type = normalizeType(type);
+      code = this.$el.text();
+      mirrorOpts = {
+        value: code,
+        mode: type
+      };
+      this.codeCache[type] = code;
+      this.editor = CodeMirror(this.$editorCont[0], $.extend(mirrorOpts, this.opts.codeMirrorOptions));
+      return this.editor.on('change', __bind(function(doc, changeObj) {
+        if ((changeObj != null ? changeObj.origin : void 0) && !(changeObj.origin instanceof Object)) {
+          return this.codeCache = {};
+        }
+      }, this));
+    };
+    Editor.prototype.getType = function() {
+      return this.editor.getMode().name;
+    };
+    Editor.prototype.switchType = function(type) {
+      var code, converter, currentType, scrollInfo;
+      type = normalizeType(type);
+      currentType = this.getType();
+      if (type === currentType) {
+        return;
+      }
+      if (this.codeCache[type]) {
+        code = this.codeCache[type];
+      } else {
+        converter = converters["" + currentType + ":" + type];
+        if (converter == null) {
+          console.error("Can't convert " + currentType + " to " + type);
+          return;
+        }
+        code = converter(this.opts, this.editor.getValue());
+        this.codeCache[type] = code;
+      }
+      this.editor.setOption('mode', type);
+      this.editor.setValue(code);
+      this.editor.refresh();
+      scrollInfo = this.editor.getScrollInfo();
+      return this.$editorCont.css({
+        height: "" + scrollInfo.height + "px"
+      });
+    };
+    Editor.prototype.run = function(type, opts, code) {
+      var from, func, key, runner, to, _ref;
+      runner = runners[type];
+      if (runner == null) {
+        for (key in converters) {
+          func = converters[key];
+          _ref = key.split(':'), from = _ref[0], to = _ref[1];
+          if (type === from && runners[to]) {
+            runner = runners[to];
+            code = func(opts, code);
+          }
+        }
+      }
+      if (!(runner != null)) {
+        console.error("Couldn't find a way to run " + type + " block");
+        return;
+      }
+      return runner(opts, code);
+    };
+    Editor.prototype.execute = function() {
+      var code, codeType, output;
+      code = this.getValue();
+      codeType = this.getType();
+      this.$el.trigger('executrBeforeExecute', [code, codeType, this.opts]);
+      if (this.opts.setUp != null) {
+        this.opts.setUp(codeType, this.opts);
+      }
+      output = this.run(codeType, this.opts, code);
+      if (this.opts.tearDown != null) {
+        this.opts.tearDown(output, codeType, this.opts);
+      }
+      this.$el.trigger('executrAfterExecute', [output, code, codeType, this.opts]);
+      return insertOutput(this.opts, output);
+    };
+    return Editor;
+  })();
+  getCodeElement = function(e, opts) {
+    var $code, $target;
+    $target = $(e.target);
+    $code = $target.parents(opts.codeSelector);
+    if (!$code.length && $target.is(opts.codeSelector)) {
+      $code = $target;
+    }
+    return $code;
+  };
+  insertOutput = function(opts, output) {
+    if (opts.outputTo) {
+      if (opts.appendOutput) {
+        return $(opts.outputTo).append($('<div>').text(output));
+      } else {
+        return $(opts.outputTo).text(output);
+      }
+    }
+  };
+  $.fn.executr = function(opts) {
+    var codeSelectors, defaults;
+    defaults = {
+      codeSelector: 'code[executable]',
+      outputTo: false,
+      appendOutput: true,
+      defaultType: 'coffee',
+      buttonText: "RUN"
+    };
+    opts = $.extend({}, defaults, opts);
+    if (this.is(opts.codeSelector)) {
+      opts.codeSelector = null;
+    }
+    codeSelectors = this.find(opts.codeSelector);
+    codeSelectors.each(function(i, el) {
+      return new Editor({
+        el: el,
+        opts: opts
+      });
+    });
+    return $('.executr-switch').click(function() {
+      var $this, codeType;
+      $this = $(this);
+      $this.addClass('selected').siblings().removeClass('selected');
+      codeType = $this.attr('data-code-type');
+      return codeSelectors.trigger('executrSwitchType', codeType);
+    });
+  };
+}).call(this);

public/bower_components/messenger/docs/welcome/lib/executr/demo.html

@@ -0,0 +1,39 @@
+<html>
+  <head>
+    <link rel="stylesheet" type="text/css" media="screen" href="lib/CodeMirror/codemirror.css">
+    <link rel="stylesheet" type="text/css" media="screen" href="build/css/executr.css">
+
+    <script type="text/javascript" src="http://cdnjs.cloudflare.com/ajax/libs/jquery/1.9.0/jquery.min.js"></script>
+
+    <script type="text/javascript" src="lib/CodeMirror/codemirror.js"></script>
+    <script type="text/javascript" src="lib/CodeMirror/mode/coffeescript/coffeescript.js"></script>
+    <script type="text/javascript" src="lib/CodeMirror/mode/javascript/javascript.js"></script>
+    <script type="text/javascript" src="lib/coffee-script.js"></script>
+    <script type="text/javascript" src="lib/underscore.min.js"></script>
+    <script type="text/javascript" src="lib/js2coffee.min.js"></script>
+    <script type="text/javascript" src="build/js/executr.js"></script>
+
+    <script>
+      $(function(){
+        $('body').executr({
+          'outputTo': 'output'
+        });
+      });
+    </script>
+
+  </head>
+  <body>
+    <output></output>
+    <pre>
+<code executable>do ->
+  x = 3 + 12
+  x / 2</code></pre>
+
+    <pre>
+<code data-type="javascript" executable>(function(){
+  return 8;
+})();</code></pre>
+  </body>
+  <button class="executr-switch" data-code-type="javascript">To JavaScript</button>
+  <button class="executr-switch" data-code-type="coffeescript">To CoffeeScript</button>
+</html>

public/bower_components/messenger/docs/welcome/lib/executr/lib/CodeMirror/LICENSE

@@ -0,0 +1,23 @@
+Copyright (C) 2013 by Marijn Haverbeke <marijnh@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+Please note that some subdirectories of the CodeMirror distribution
+include their own LICENSE files, and are released under different
+licences.

public/bower_components/messenger/docs/welcome/lib/executr/lib/CodeMirror/codemirror.css

@@ -0,0 +1,240 @@
+/* BASICS */
+
+.CodeMirror {
+  /* Set height, width, borders, and global font properties here */
+  font-family: monospace;
+  height: 300px;
+}
+.CodeMirror-scroll {
+  /* Set scrolling behaviour here */
+  overflow: auto;
+}
+
+/* PADDING */
+
+.CodeMirror-lines {
+  padding: 4px 0; /* Vertical padding around content */
+}
+.CodeMirror pre {
+  padding: 0 4px; /* Horizontal padding of content */
+}
+
+.CodeMirror-scrollbar-filler {
+  background-color: white; /* The little square between H and V scrollbars */
+}
+
+/* GUTTER */
+
+.CodeMirror-gutters {
+  border-right: 1px solid #ddd;
+  background-color: #f7f7f7;
+}
+.CodeMirror-linenumbers {}
+.CodeMirror-linenumber {
+  padding: 0 3px 0 5px;
+  min-width: 20px;
+  text-align: right;
+  color: #999;
+}
+
+/* CURSOR */
+
+.CodeMirror div.CodeMirror-cursor {
+  border-left: 1px solid black;
+}
+/* Shown when moving in bi-directional text */
+.CodeMirror div.CodeMirror-secondarycursor {
+  border-left: 1px solid silver;
+}
+.CodeMirror.cm-keymap-fat-cursor div.CodeMirror-cursor {
+  width: auto;
+  border: 0;
+  background: transparent;
+  background: rgba(0, 200, 0, .4);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr=#6600c800, endColorstr=#4c00c800);
+}
+/* Kludge to turn off filter in ie9+, which also accepts rgba */
+.CodeMirror.cm-keymap-fat-cursor div.CodeMirror-cursor:not(#nonsense_id) {
+  filter: progid:DXImageTransform.Microsoft.gradient(enabled=false);
+}
+/* Can style cursor different in overwrite (non-insert) mode */
+.CodeMirror div.CodeMirror-cursor.CodeMirror-overwrite {}
+
+/* DEFAULT THEME */
+
+.cm-s-default .cm-keyword {color: #708;}
+.cm-s-default .cm-atom {color: #219;}
+.cm-s-default .cm-number {color: #164;}
+.cm-s-default .cm-def {color: #00f;}
+.cm-s-default .cm-variable {color: black;}
+.cm-s-default .cm-variable-2 {color: #05a;}
+.cm-s-default .cm-variable-3 {color: #085;}
+.cm-s-default .cm-property {color: black;}
+.cm-s-default .cm-operator {color: black;}
+.cm-s-default .cm-comment {color: #a50;}
+.cm-s-default .cm-string {color: #a11;}
+.cm-s-default .cm-string-2 {color: #f50;}
+.cm-s-default .cm-meta {color: #555;}
+.cm-s-default .cm-error {color: #f00;}
+.cm-s-default .cm-qualifier {color: #555;}
+.cm-s-default .cm-builtin {color: #30a;}
+.cm-s-default .cm-bracket {color: #997;}
+.cm-s-default .cm-tag {color: #170;}
+.cm-s-default .cm-attribute {color: #00c;}
+.cm-s-default .cm-header {color: blue;}
+.cm-s-default .cm-quote {color: #090;}
+.cm-s-default .cm-hr {color: #999;}
+.cm-s-default .cm-link {color: #00c;}
+
+.cm-negative {color: #d44;}
+.cm-positive {color: #292;}
+.cm-header, .cm-strong {font-weight: bold;}
+.cm-em {font-style: italic;}
+.cm-emstrong {font-style: italic; font-weight: bold;}
+.cm-link {text-decoration: underline;}
+
+.cm-invalidchar {color: #f00;}
+
+div.CodeMirror span.CodeMirror-matchingbracket {color: #0f0;}
+div.CodeMirror span.CodeMirror-nonmatchingbracket {color: #f22;}
+
+/* STOP */
+
+/* The rest of this file contains styles related to the mechanics of
+   the editor. You probably shouldn't touch them. */
+
+.CodeMirror {
+  line-height: 1;
+  position: relative;
+  overflow: hidden;
+}
+
+.CodeMirror-scroll {
+  /* 30px is the magic margin used to hide the element's real scrollbars */
+  /* See overflow: hidden in .CodeMirror, and the paddings in .CodeMirror-sizer */
+  margin-bottom: -30px; margin-right: -30px;
+  padding-bottom: 30px; padding-right: 30px;
+  height: 100%;
+  outline: none; /* Prevent dragging from highlighting the element */
+  position: relative;
+}
+.CodeMirror-sizer {
+  position: relative;
+}
+
+/* The fake, visible scrollbars. Used to force redraw during scrolling
+   before actuall scrolling happens, thus preventing shaking and
+   flickering artifacts. */
+.CodeMirror-vscrollbar, .CodeMirror-hscrollbar, .CodeMirror-scrollbar-filler {
+  position: absolute;
+  z-index: 6;
+  display: none;
+}
+.CodeMirror-vscrollbar {
+  right: 0; top: 0;
+  overflow-x: hidden;
+  overflow-y: scroll;
+}
+.CodeMirror-hscrollbar {
+  bottom: 0; left: 0;
+  overflow-y: hidden;
+  overflow-x: scroll;
+}
+.CodeMirror-scrollbar-filler {
+  right: 0; bottom: 0;
+  z-index: 6;
+}
+
+.CodeMirror-gutters {
+  position: absolute; left: 0; top: 0;
+  height: 100%;
+  z-index: 3;
+}
+.CodeMirror-gutter {
+  height: 100%;
+  display: inline-block;
+  /* Hack to make IE7 behave */
+  *zoom:1;
+  *display:inline;
+}
+.CodeMirror-gutter-elt {
+  position: absolute;
+  cursor: default;
+  z-index: 4;
+}
+
+.CodeMirror-lines {
+  cursor: text;
+}
+.CodeMirror pre {
+  /* Reset some styles that the rest of the page might have set */
+  -moz-border-radius: 0; -webkit-border-radius: 0; -o-border-radius: 0; border-radius: 0;
+  border-width: 0;
+  background: transparent;
+  font-family: inherit;
+  font-size: inherit;
+  margin: 0;
+  white-space: pre;
+  word-wrap: normal;
+  line-height: inherit;
+  color: inherit;
+  z-index: 2;
+  position: relative;
+  overflow: visible;
+}
+.CodeMirror-wrap pre {
+  word-wrap: break-word;
+  white-space: pre-wrap;
+  word-break: normal;
+}
+.CodeMirror-linebackground {
+  position: absolute;
+  left: 0; right: 0; top: 0; bottom: 0;
+  z-index: 0;
+}
+
+.CodeMirror-linewidget {
+  position: relative;
+  z-index: 2;
+  overflow: auto;
+}
+
+.CodeMirror-wrap .CodeMirror-scroll {
+  overflow-x: hidden;
+}
+
+.CodeMirror-measure {
+  position: absolute;
+  width: 100%; height: 0px;
+  overflow: hidden;
+  visibility: hidden;
+}
+.CodeMirror-measure pre { position: static; }
+
+.CodeMirror div.CodeMirror-cursor {
+  position: absolute;
+  visibility: hidden;
+  border-right: none;
+  width: 0;
+}
+.CodeMirror-focused div.CodeMirror-cursor {
+  visibility: visible;
+}
+
+.CodeMirror-selected { background: #d9d9d9; }
+.CodeMirror-focused .CodeMirror-selected { background: #d7d4f0; }
+
+.cm-searching {
+  background: #ffa;
+  background: rgba(255, 255, 0, .4);
+}
+
+/* IE7 hack to prevent it from returning funny offsetTops on the spans */
+.CodeMirror span { *vertical-align: text-bottom; }
+
+@media print {
+  /* Hide the cursor when printing */
+  .CodeMirror div.CodeMirror-cursor {
+    visibility: hidden;
+  }
+}

public/bower_components/messenger/docs/welcome/lib/executr/lib/CodeMirror/mode/coffeescript/LICENSE

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2011 Jeff Pickhardt
+Modified from the Python CodeMirror mode, Copyright (c) 2010 Timothy Farrell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

public/bower_components/messenger/docs/welcome/lib/executr/lib/CodeMirror/mode/coffeescript/coffeescript.js

@@ -0,0 +1,346 @@
+/**
+ * Link to the project's GitHub page:
+ * https://github.com/pickhardt/coffeescript-codemirror-mode
+ */
+CodeMirror.defineMode('coffeescript', function(conf) {
+    var ERRORCLASS = 'error';
+
+    function wordRegexp(words) {
+        return new RegExp("^((" + words.join(")|(") + "))\\b");
+    }
+
+    var singleOperators = new RegExp("^[\\+\\-\\*/%&|\\^~<>!\?]");
+    var singleDelimiters = new RegExp('^[\\(\\)\\[\\]\\{\\},:`=;\\.]');
+    var doubleOperators = new RegExp("^((\->)|(\=>)|(\\+\\+)|(\\+\\=)|(\\-\\-)|(\\-\\=)|(\\*\\*)|(\\*\\=)|(\\/\\/)|(\\/\\=)|(==)|(!=)|(<=)|(>=)|(<>)|(<<)|(>>)|(//))");
+    var doubleDelimiters = new RegExp("^((\\.\\.)|(\\+=)|(\\-=)|(\\*=)|(%=)|(/=)|(&=)|(\\|=)|(\\^=))");
+    var tripleDelimiters = new RegExp("^((\\.\\.\\.)|(//=)|(>>=)|(<<=)|(\\*\\*=))");
+    var identifiers = new RegExp("^[_A-Za-z$][_A-Za-z$0-9]*");
+    var properties = new RegExp("^(@|this\.)[_A-Za-z$][_A-Za-z$0-9]*");
+
+    var wordOperators = wordRegexp(['and', 'or', 'not',
+                                    'is', 'isnt', 'in',
+                                    'instanceof', 'typeof']);
+    var indentKeywords = ['for', 'while', 'loop', 'if', 'unless', 'else',
+                          'switch', 'try', 'catch', 'finally', 'class'];
+    var commonKeywords = ['break', 'by', 'continue', 'debugger', 'delete',
+                          'do', 'in', 'of', 'new', 'return', 'then',
+                          'this', 'throw', 'when', 'until'];
+
+    var keywords = wordRegexp(indentKeywords.concat(commonKeywords));
+
+    indentKeywords = wordRegexp(indentKeywords);
+
+
+    var stringPrefixes = new RegExp("^('{3}|\"{3}|['\"])");
+    var regexPrefixes = new RegExp("^(/{3}|/)");
+    var commonConstants = ['Infinity', 'NaN', 'undefined', 'null', 'true', 'false', 'on', 'off', 'yes', 'no'];
+    var constants = wordRegexp(commonConstants);
+
+    // Tokenizers
+    function tokenBase(stream, state) {
+        // Handle scope changes
+        if (stream.sol()) {
+            var scopeOffset = state.scopes[0].offset;
+            if (stream.eatSpace()) {
+                var lineOffset = stream.indentation();
+                if (lineOffset > scopeOffset) {
+                    return 'indent';
+                } else if (lineOffset < scopeOffset) {
+                    return 'dedent';
+                }
+                return null;
+            } else {
+                if (scopeOffset > 0) {
+                    dedent(stream, state);
+                }
+            }
+        }
+        if (stream.eatSpace()) {
+            return null;
+        }
+
+        var ch = stream.peek();
+
+        // Handle docco title comment (single line)
+        if (stream.match("####")) {
+            stream.skipToEnd();
+            return 'comment';
+        }
+
+        // Handle multi line comments
+        if (stream.match("###")) {
+            state.tokenize = longComment;
+            return state.tokenize(stream, state);
+        }
+
+        // Single line comment
+        if (ch === '#') {
+            stream.skipToEnd();
+            return 'comment';
+        }
+
+        // Handle number literals
+        if (stream.match(/^-?[0-9\.]/, false)) {
+            var floatLiteral = false;
+            // Floats
+            if (stream.match(/^-?\d*\.\d+(e[\+\-]?\d+)?/i)) {
+              floatLiteral = true;
+            }
+            if (stream.match(/^-?\d+\.\d*/)) {
+              floatLiteral = true;
+            }
+            if (stream.match(/^-?\.\d+/)) {
+              floatLiteral = true;
+            }
+
+            if (floatLiteral) {
+                // prevent from getting extra . on 1..
+                if (stream.peek() == "."){
+                    stream.backUp(1);
+                }
+                return 'number';
+            }
+            // Integers
+            var intLiteral = false;
+            // Hex
+            if (stream.match(/^-?0x[0-9a-f]+/i)) {
+              intLiteral = true;
+            }
+            // Decimal
+            if (stream.match(/^-?[1-9]\d*(e[\+\-]?\d+)?/)) {
+                intLiteral = true;
+            }
+            // Zero by itself with no other piece of number.
+            if (stream.match(/^-?0(?![\dx])/i)) {
+              intLiteral = true;
+            }
+            if (intLiteral) {
+                return 'number';
+            }
+        }
+
+        // Handle strings
+        if (stream.match(stringPrefixes)) {
+            state.tokenize = tokenFactory(stream.current(), 'string');
+            return state.tokenize(stream, state);
+        }
+        // Handle regex literals
+        if (stream.match(regexPrefixes)) {
+            if (stream.current() != '/' || stream.match(/^.*\//, false)) { // prevent highlight of division
+                state.tokenize = tokenFactory(stream.current(), 'string-2');
+                return state.tokenize(stream, state);
+            } else {
+                stream.backUp(1);
+            }
+        }
+
+        // Handle operators and delimiters
+        if (stream.match(tripleDelimiters) || stream.match(doubleDelimiters)) {
+            return 'punctuation';
+        }
+        if (stream.match(doubleOperators)
+            || stream.match(singleOperators)
+            || stream.match(wordOperators)) {
+            return 'operator';
+        }
+        if (stream.match(singleDelimiters)) {
+            return 'punctuation';
+        }
+
+        if (stream.match(constants)) {
+            return 'atom';
+        }
+
+        if (stream.match(keywords)) {
+            return 'keyword';
+        }
+
+        if (stream.match(identifiers)) {
+            return 'variable';
+        }
+        
+        if (stream.match(properties)) {
+            return 'property';
+        }
+
+        // Handle non-detected items
+        stream.next();
+        return ERRORCLASS;
+    }
+
+    function tokenFactory(delimiter, outclass) {
+        var singleline = delimiter.length == 1;
+        return function tokenString(stream, state) {
+            while (!stream.eol()) {
+                stream.eatWhile(/[^'"\/\\]/);
+                if (stream.eat('\\')) {
+                    stream.next();
+                    if (singleline && stream.eol()) {
+                        return outclass;
+                    }
+                } else if (stream.match(delimiter)) {
+                    state.tokenize = tokenBase;
+                    return outclass;
+                } else {
+                    stream.eat(/['"\/]/);
+                }
+            }
+            if (singleline) {
+                if (conf.mode.singleLineStringErrors) {
+                    outclass = ERRORCLASS;
+                } else {
+                    state.tokenize = tokenBase;
+                }
+            }
+            return outclass;
+        };
+    }
+
+    function longComment(stream, state) {
+        while (!stream.eol()) {
+            stream.eatWhile(/[^#]/);
+            if (stream.match("###")) {
+                state.tokenize = tokenBase;
+                break;
+            }
+            stream.eatWhile("#");
+        }
+        return "comment";
+    }
+
+    function indent(stream, state, type) {
+        type = type || 'coffee';
+        var indentUnit = 0;
+        if (type === 'coffee') {
+            for (var i = 0; i < state.scopes.length; i++) {
+                if (state.scopes[i].type === 'coffee') {
+                    indentUnit = state.scopes[i].offset + conf.indentUnit;
+                    break;
+                }
+            }
+        } else {
+            indentUnit = stream.column() + stream.current().length;
+        }
+        state.scopes.unshift({
+            offset: indentUnit,
+            type: type
+        });
+    }
+
+    function dedent(stream, state) {
+        if (state.scopes.length == 1) return;
+        if (state.scopes[0].type === 'coffee') {
+            var _indent = stream.indentation();
+            var _indent_index = -1;
+            for (var i = 0; i < state.scopes.length; ++i) {
+                if (_indent === state.scopes[i].offset) {
+                    _indent_index = i;
+                    break;
+                }
+            }
+            if (_indent_index === -1) {
+                return true;
+            }
+            while (state.scopes[0].offset !== _indent) {
+                state.scopes.shift();
+            }
+            return false;
+        } else {
+            state.scopes.shift();
+            return false;
+        }
+    }
+
+    function tokenLexer(stream, state) {
+        var style = state.tokenize(stream, state);
+        var current = stream.current();
+
+        // Handle '.' connected identifiers
+        if (current === '.') {
+            style = state.tokenize(stream, state);
+            current = stream.current();
+            if (style === 'variable') {
+                return 'variable';
+            } else {
+                return ERRORCLASS;
+            }
+        }
+
+        // Handle scope changes.
+        if (current === 'return') {
+            state.dedent += 1;
+        }
+        if (((current === '->' || current === '=>') &&
+                  !state.lambda &&
+                  state.scopes[0].type == 'coffee' &&
+                  stream.peek() === '')
+               || style === 'indent') {
+            indent(stream, state);
+        }
+        var delimiter_index = '[({'.indexOf(current);
+        if (delimiter_index !== -1) {
+            indent(stream, state, '])}'.slice(delimiter_index, delimiter_index+1));
+        }
+        if (indentKeywords.exec(current)){
+            indent(stream, state);
+        }
+        if (current == 'then'){
+            dedent(stream, state);
+        }
+
+
+        if (style === 'dedent') {
+            if (dedent(stream, state)) {
+                return ERRORCLASS;
+            }
+        }
+        delimiter_index = '])}'.indexOf(current);
+        if (delimiter_index !== -1) {
+            if (dedent(stream, state)) {
+                return ERRORCLASS;
+            }
+        }
+        if (state.dedent > 0 && stream.eol() && state.scopes[0].type == 'coffee') {
+            if (state.scopes.length > 1) state.scopes.shift();
+            state.dedent -= 1;
+        }
+
+        return style;
+    }
+
+    var external = {
+        startState: function(basecolumn) {
+            return {
+              tokenize: tokenBase,
+              scopes: [{offset:basecolumn || 0, type:'coffee'}],
+              lastToken: null,
+              lambda: false,
+              dedent: 0
+          };
+        },
+
+        token: function(stream, state) {
+            var style = tokenLexer(stream, state);
+
+            state.lastToken = {style:style, content: stream.current()};
+
+            if (stream.eol() && stream.lambda) {
+                state.lambda = false;
+            }
+
+            return style;
+        },
+
+        indent: function(state) {
+            if (state.tokenize != tokenBase) {
+                return 0;
+            }
+
+            return state.scopes[0].offset;
+        }
+
+    };
+    return external;
+});
+
+CodeMirror.defineMIME('text/x-coffeescript', 'coffeescript');

public/bower_components/messenger/docs/welcome/lib/executr/lib/CodeMirror/mode/coffeescript/index.html

@@ -0,0 +1,728 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>CodeMirror: CoffeeScript mode</title>
+    <link rel="stylesheet" href="../../lib/codemirror.css">
+    <script src="../../lib/codemirror.js"></script>
+    <script src="coffeescript.js"></script>
+    <style>.CodeMirror {border-top: 1px solid silver; border-bottom: 1px solid silver;}</style>
+    <link rel="stylesheet" href="../../doc/docs.css">
+  </head>
+  <body>
+    <h1>CodeMirror: CoffeeScript mode</h1>
+    <form><textarea id="code" name="code">
+# CoffeeScript mode for CodeMirror
+# Copyright (c) 2011 Jeff Pickhardt, released under
+# the MIT License.
+#
+# Modified from the Python CodeMirror mode, which also is 
+# under the MIT License Copyright (c) 2010 Timothy Farrell.
+#
+# The following script, Underscore.coffee, is used to 
+# demonstrate CoffeeScript mode for CodeMirror.
+#
+# To download CoffeeScript mode for CodeMirror, go to:
+# https://github.com/pickhardt/coffeescript-codemirror-mode
+
+# **Underscore.coffee
+# (c) 2011 Jeremy Ashkenas, DocumentCloud Inc.**
+# Underscore is freely distributable under the terms of the
+# [MIT license](http://en.wikipedia.org/wiki/MIT_License).
+# Portions of Underscore are inspired by or borrowed from
+# [Prototype.js](http://prototypejs.org/api), Oliver Steele's
+# [Functional](http://osteele.com), and John Resig's
+# [Micro-Templating](http://ejohn.org).
+# For all details and documentation:
+# http://documentcloud.github.com/underscore/
+
+
+# Baseline setup
+# --------------
+
+# Establish the root object, `window` in the browser, or `global` on the server.
+root = this
+
+
+# Save the previous value of the `_` variable.
+previousUnderscore = root._
+
+### Multiline
+    comment
+###
+
+# Establish the object that gets thrown to break out of a loop iteration.
+# `StopIteration` is SOP on Mozilla.
+breaker = if typeof(StopIteration) is 'undefined' then '__break__' else StopIteration
+
+
+#### Docco style single line comment (title)
+
+
+# Helper function to escape **RegExp** contents, because JS doesn't have one.
+escapeRegExp = (string) -> string.replace(/([.*+?^${}()|[\]\/\\])/g, '\\$1')
+
+
+# Save bytes in the minified (but not gzipped) version:
+ArrayProto = Array.prototype
+ObjProto = Object.prototype
+
+
+# Create quick reference variables for speed access to core prototypes.
+slice = ArrayProto.slice
+unshift = ArrayProto.unshift
+toString = ObjProto.toString
+hasOwnProperty = ObjProto.hasOwnProperty
+propertyIsEnumerable = ObjProto.propertyIsEnumerable
+
+
+# All **ECMA5** native implementations we hope to use are declared here.
+nativeForEach = ArrayProto.forEach
+nativeMap = ArrayProto.map
+nativeReduce = ArrayProto.reduce
+nativeReduceRight = ArrayProto.reduceRight
+nativeFilter = ArrayProto.filter
+nativeEvery = ArrayProto.every
+nativeSome = ArrayProto.some
+nativeIndexOf = ArrayProto.indexOf
+nativeLastIndexOf = ArrayProto.lastIndexOf
+nativeIsArray = Array.isArray
+nativeKeys = Object.keys
+
+
+# Create a safe reference to the Underscore object for use below.
+_ = (obj) -> new wrapper(obj)
+
+
+# Export the Underscore object for **CommonJS**.
+if typeof(exports) != 'undefined' then exports._ = _
+
+
+# Export Underscore to global scope.
+root._ = _
+
+
+# Current version.
+_.VERSION = '1.1.0'
+
+
+# Collection Functions
+# --------------------
+
+# The cornerstone, an **each** implementation.
+# Handles objects implementing **forEach**, arrays, and raw objects.
+_.each = (obj, iterator, context) ->
+  try
+    if nativeForEach and obj.forEach is nativeForEach
+      obj.forEach iterator, context
+    else if _.isNumber obj.length
+      iterator.call context, obj[i], i, obj for i in [0...obj.length]
+    else
+      iterator.call context, val, key, obj for own key, val of obj
+  catch e
+    throw e if e isnt breaker
+  obj
+
+
+# Return the results of applying the iterator to each element. Use JavaScript
+# 1.6's version of **map**, if possible.
+_.map = (obj, iterator, context) ->
+  return obj.map(iterator, context) if nativeMap and obj.map is nativeMap
+  results = []
+  _.each obj, (value, index, list) ->
+    results.push iterator.call context, value, index, list
+  results
+
+
+# **Reduce** builds up a single result from a list of values. Also known as
+# **inject**, or **foldl**. Uses JavaScript 1.8's version of **reduce**, if possible.
+_.reduce = (obj, iterator, memo, context) ->
+  if nativeReduce and obj.reduce is nativeReduce
+    iterator = _.bind iterator, context if context
+    return obj.reduce iterator, memo
+  _.each obj, (value, index, list) ->
+    memo = iterator.call context, memo, value, index, list
+  memo
+
+
+# The right-associative version of **reduce**, also known as **foldr**. Uses
+# JavaScript 1.8's version of **reduceRight**, if available.
+_.reduceRight = (obj, iterator, memo, context) ->
+  if nativeReduceRight and obj.reduceRight is nativeReduceRight
+    iterator = _.bind iterator, context if context
+    return obj.reduceRight iterator, memo
+  reversed = _.clone(_.toArray(obj)).reverse()
+  _.reduce reversed, iterator, memo, context
+
+
+# Return the first value which passes a truth test.
+_.detect = (obj, iterator, context) ->
+  result = null
+  _.each obj, (value, index, list) ->
+    if iterator.call context, value, index, list
+      result = value
+      _.breakLoop()
+  result
+
+
+# Return all the elements that pass a truth test. Use JavaScript 1.6's
+# **filter**, if it exists.
+_.filter = (obj, iterator, context) ->
+  return obj.filter iterator, context if nativeFilter and obj.filter is nativeFilter
+  results = []
+  _.each obj, (value, index, list) ->
+    results.push value if iterator.call context, value, index, list
+  results
+
+
+# Return all the elements for which a truth test fails.
+_.reject = (obj, iterator, context) ->
+  results = []
+  _.each obj, (value, index, list) ->
+    results.push value if not iterator.call context, value, index, list
+  results
+
+
+# Determine whether all of the elements match a truth test. Delegate to
+# JavaScript 1.6's **every**, if it is present.
+_.every = (obj, iterator, context) ->
+  iterator ||= _.identity
+  return obj.every iterator, context if nativeEvery and obj.every is nativeEvery
+  result = true
+  _.each obj, (value, index, list) ->
+    _.breakLoop() unless (result = result and iterator.call(context, value, index, list))
+  result
+
+
+# Determine if at least one element in the object matches a truth test. Use
+# JavaScript 1.6's **some**, if it exists.
+_.some = (obj, iterator, context) ->
+  iterator ||= _.identity
+  return obj.some iterator, context if nativeSome and obj.some is nativeSome
+  result = false
+  _.each obj, (value, index, list) ->
+    _.breakLoop() if (result = iterator.call(context, value, index, list))
+  result
+
+
+# Determine if a given value is included in the array or object,
+# based on `===`.
+_.include = (obj, target) ->
+  return _.indexOf(obj, target) isnt -1 if nativeIndexOf and obj.indexOf is nativeIndexOf
+  return true for own key, val of obj when val is target
+  false
+
+
+# Invoke a method with arguments on every item in a collection.
+_.invoke = (obj, method) ->
+  args = _.rest arguments, 2
+  (if method then val[method] else val).apply(val, args) for val in obj
+
+
+# Convenience version of a common use case of **map**: fetching a property.
+_.pluck = (obj, key) ->
+  _.map(obj, (val) -> val[key])
+
+
+# Return the maximum item or (item-based computation).
+_.max = (obj, iterator, context) ->
+  return Math.max.apply(Math, obj) if not iterator and _.isArray(obj)
+  result = computed: -Infinity
+  _.each obj, (value, index, list) ->
+    computed = if iterator then iterator.call(context, value, index, list) else value
+    computed >= result.computed and (result = {value: value, computed: computed})
+  result.value
+
+
+# Return the minimum element (or element-based computation).
+_.min = (obj, iterator, context) ->
+  return Math.min.apply(Math, obj) if not iterator and _.isArray(obj)
+  result = computed: Infinity
+  _.each obj, (value, index, list) ->
+    computed = if iterator then iterator.call(context, value, index, list) else value
+    computed < result.computed and (result = {value: value, computed: computed})
+  result.value
+
+
+# Sort the object's values by a criterion produced by an iterator.
+_.sortBy = (obj, iterator, context) ->
+  _.pluck(((_.map obj, (value, index, list) ->
+    {value: value, criteria: iterator.call(context, value, index, list)}
+  ).sort((left, right) ->
+    a = left.criteria; b = right.criteria
+    if a < b then -1 else if a > b then 1 else 0
+  )), 'value')
+
+
+# Use a comparator function to figure out at what index an object should
+# be inserted so as to maintain order. Uses binary search.
+_.sortedIndex = (array, obj, iterator) ->
+  iterator ||= _.identity
+  low = 0
+  high = array.length
+  while low < high
+    mid = (low + high) >> 1
+    if iterator(array[mid]) < iterator(obj) then low = mid + 1 else high = mid
+  low
+
+
+# Convert anything iterable into a real, live array.
+_.toArray = (iterable) ->
+  return [] if (!iterable)
+  return iterable.toArray() if (iterable.toArray)
+  return iterable if (_.isArray(iterable))
+  return slice.call(iterable) if (_.isArguments(iterable))
+  _.values(iterable)
+
+
+# Return the number of elements in an object.
+_.size = (obj) -> _.toArray(obj).length
+
+
+# Array Functions
+# ---------------
+
+# Get the first element of an array. Passing `n` will return the first N
+# values in the array. Aliased as **head**. The `guard` check allows it to work
+# with **map**.
+_.first = (array, n, guard) ->
+  if n and not guard then slice.call(array, 0, n) else array[0]
+
+
+# Returns everything but the first entry of the array. Aliased as **tail**.
+# Especially useful on the arguments object. Passing an `index` will return
+# the rest of the values in the array from that index onward. The `guard`
+# check allows it to work with **map**.
+_.rest = (array, index, guard) ->
+  slice.call(array, if _.isUndefined(index) or guard then 1 else index)
+
+
+# Get the last element of an array.
+_.last = (array) -> array[array.length - 1]
+
+
+# Trim out all falsy values from an array.
+_.compact = (array) -> item for item in array when item
+
+
+# Return a completely flattened version of an array.
+_.flatten = (array) ->
+  _.reduce array, (memo, value) ->
+    return memo.concat(_.flatten(value)) if _.isArray value
+    memo.push value
+    memo
+  , []
+
+
+# Return a version of the array that does not contain the specified value(s).
+_.without = (array) ->
+  values = _.rest arguments
+  val for val in _.toArray(array) when not _.include values, val
+
+
+# Produce a duplicate-free version of the array. If the array has already
+# been sorted, you have the option of using a faster algorithm.
+_.uniq = (array, isSorted) ->
+  memo = []
+  for el, i in _.toArray array
+    memo.push el if i is 0 || (if isSorted is true then _.last(memo) isnt el else not _.include(memo, el))
+  memo
+
+
+# Produce an array that contains every item shared between all the
+# passed-in arrays.
+_.intersect = (array) ->
+  rest = _.rest arguments
+  _.select _.uniq(array), (item) ->
+    _.all rest, (other) ->
+      _.indexOf(other, item) >= 0
+
+
+# Zip together multiple lists into a single array -- elements that share
+# an index go together.
+_.zip = ->
+  length = _.max _.pluck arguments, 'length'
+  results = new Array length
+  for i in [0...length]
+    results[i] = _.pluck arguments, String i
+  results
+
+
+# If the browser doesn't supply us with **indexOf** (I'm looking at you, MSIE),
+# we need this function. Return the position of the first occurrence of an
+# item in an array, or -1 if the item is not included in the array.
+_.indexOf = (array, item) ->
+  return array.indexOf item if nativeIndexOf and array.indexOf is nativeIndexOf
+  i = 0; l = array.length
+  while l - i
+    if array[i] is item then return i else i++
+  -1
+
+
+# Provide JavaScript 1.6's **lastIndexOf**, delegating to the native function,
+# if possible.
+_.lastIndexOf = (array, item) ->
+  return array.lastIndexOf(item) if nativeLastIndexOf and array.lastIndexOf is nativeLastIndexOf
+  i = array.length
+  while i
+    if array[i] is item then return i else i--
+  -1
+
+
+# Generate an integer Array containing an arithmetic progression. A port of
+# [the native Python **range** function](http://docs.python.org/library/functions.html#range).
+_.range = (start, stop, step) ->
+  a = arguments
+  solo = a.length <= 1
+  i = start = if solo then 0 else a[0]
+  stop = if solo then a[0] else a[1]
+  step = a[2] or 1
+  len = Math.ceil((stop - start) / step)
+  return [] if len <= 0
+  range = new Array len
+  idx = 0
+  loop
+    return range if (if step > 0 then i - stop else stop - i) >= 0
+    range[idx] = i
+    idx++
+    i+= step
+
+
+# Function Functions
+# ------------------
+
+# Create a function bound to a given object (assigning `this`, and arguments,
+# optionally). Binding with arguments is also known as **curry**.
+_.bind = (func, obj) ->
+  args = _.rest arguments, 2
+  -> func.apply obj or root, args.concat arguments
+
+
+# Bind all of an object's methods to that object. Useful for ensuring that
+# all callbacks defined on an object belong to it.
+_.bindAll = (obj) ->
+  funcs = if arguments.length > 1 then _.rest(arguments) else _.functions(obj)
+  _.each funcs, (f) -> obj[f] = _.bind obj[f], obj
+  obj
+
+
+# Delays a function for the given number of milliseconds, and then calls
+# it with the arguments supplied.
+_.delay = (func, wait) ->
+  args = _.rest arguments, 2
+  setTimeout((-> func.apply(func, args)), wait)
+
+
+# Memoize an expensive function by storing its results.
+_.memoize = (func, hasher) ->
+  memo = {}
+  hasher or= _.identity
+  ->
+    key = hasher.apply this, arguments
+    return memo[key] if key of memo
+    memo[key] = func.apply this, arguments
+
+
+# Defers a function, scheduling it to run after the current call stack has
+# cleared.
+_.defer = (func) ->
+  _.delay.apply _, [func, 1].concat _.rest arguments
+
+
+# Returns the first function passed as an argument to the second,
+# allowing you to adjust arguments, run code before and after, and
+# conditionally execute the original function.
+_.wrap = (func, wrapper) ->
+  -> wrapper.apply wrapper, [func].concat arguments
+
+
+# Returns a function that is the composition of a list of functions, each
+# consuming the return value of the function that follows.
+_.compose = ->
+  funcs = arguments
+  ->
+    args = arguments
+    for i in [funcs.length - 1..0] by -1
+      args = [funcs[i].apply(this, args)]
+    args[0]
+
+
+# Object Functions
+# ----------------
+
+# Retrieve the names of an object's properties.
+_.keys = nativeKeys or (obj) ->
+  return _.range 0, obj.length if _.isArray(obj)
+  key for key, val of obj
+
+
+# Retrieve the values of an object's properties.
+_.values = (obj) ->
+  _.map obj, _.identity
+
+
+# Return a sorted list of the function names available in Underscore.
+_.functions = (obj) ->
+  _.filter(_.keys(obj), (key) -> _.isFunction(obj[key])).sort()
+
+
+# Extend a given object with all of the properties in a source object.
+_.extend = (obj) ->
+  for source in _.rest(arguments)
+    obj[key] = val for key, val of source
+  obj
+
+
+# Create a (shallow-cloned) duplicate of an object.
+_.clone = (obj) ->
+  return obj.slice 0 if _.isArray obj
+  _.extend {}, obj
+
+
+# Invokes interceptor with the obj, and then returns obj.
+# The primary purpose of this method is to "tap into" a method chain,
+# in order to perform operations on intermediate results within
+ the chain.
+_.tap = (obj, interceptor) ->
+  interceptor obj
+  obj
+
+
+# Perform a deep comparison to check if two objects are equal.
+_.isEqual = (a, b) ->
+  # Check object identity.
+  return true if a is b
+  # Different types?
+  atype = typeof(a); btype = typeof(b)
+  return false if atype isnt btype
+  # Basic equality test (watch out for coercions).
+  return true if `a == b`
+  # One is falsy and the other truthy.
+  return false if (!a and b) or (a and !b)
+  # One of them implements an `isEqual()`?
+  return a.isEqual(b) if a.isEqual
+  # Check dates' integer values.
+  return a.getTime() is b.getTime() if _.isDate(a) and _.isDate(b)
+  # Both are NaN?
+  return false if _.isNaN(a) and _.isNaN(b)
+  # Compare regular expressions.
+  if _.isRegExp(a) and _.isRegExp(b)
+    return a.source is b.source and
+           a.global is b.global and
+           a.ignoreCase is b.ignoreCase and
+           a.multiline is b.multiline
+  # If a is not an object by this point, we can't handle it.
+  return false if atype isnt 'object'
+  # Check for different array lengths before comparing contents.
+  return false if a.length and (a.length isnt b.length)
+  # Nothing else worked, deep compare the contents.
+  aKeys = _.keys(a); bKeys = _.keys(b)
+  # Different object sizes?
+  return false if aKeys.length isnt bKeys.length
+  # Recursive comparison of contents.
+  return false for key, val of a when !(key of b) or !_.isEqual(val, b[key])
+  true
+
+
+# Is a given array or object empty?
+_.isEmpty = (obj) ->
+  return obj.length is 0 if _.isArray(obj) or _.isString(obj)
+  return false for own key of obj
+  true
+
+
+# Is a given value a DOM element?
+_.isElement = (obj) -> obj and obj.nodeType is 1
+
+
+# Is a given value an array?
+_.isArray = nativeIsArray or (obj) -> !!(obj and obj.concat and obj.unshift and not obj.callee)
+
+
+# Is a given variable an arguments object?
+_.isArguments = (obj) -> obj and obj.callee
+
+
+# Is the given value a function?
+_.isFunction = (obj) -> !!(obj and obj.constructor and obj.call and obj.apply)
+
+
+# Is the given value a string?
+_.isString = (obj) -> !!(obj is '' or (obj and obj.charCodeAt and obj.substr))
+
+
+# Is a given value a number?
+_.isNumber = (obj) -> (obj is +obj) or toString.call(obj) is '[object Number]'
+
+
+# Is a given value a boolean?
+_.isBoolean = (obj) -> obj is true or obj is false
+
+
+# Is a given value a Date?
+_.isDate = (obj) -> !!(obj and obj.getTimezoneOffset and obj.setUTCFullYear)
+
+
+# Is the given value a regular expression?
+_.isRegExp = (obj) -> !!(obj and obj.exec and (obj.ignoreCase or obj.ignoreCase is false))
+
+
+# Is the given value NaN -- this one is interesting. `NaN != NaN`, and
+# `isNaN(undefined) == true`, so we make sure it's a number first.
+_.isNaN = (obj) -> _.isNumber(obj) and window.isNaN(obj)
+
+
+# Is a given value equal to null?
+_.isNull = (obj) -> obj is null
+
+
+# Is a given variable undefined?
+_.isUndefined = (obj) -> typeof obj is 'undefined'
+
+
+# Utility Functions
+# -----------------
+
+# Run Underscore.js in noConflict mode, returning the `_` variable to its
+# previous owner. Returns a reference to the Underscore object.
+_.noConflict = ->
+  root._ = previousUnderscore
+  this
+
+
+# Keep the identity function around for default iterators.
+_.identity = (value) -> value
+
+
+# Run a function `n` times.
+_.times = (n, iterator, context) ->
+  iterator.call context, i for i in [0...n]
+
+
+# Break out of the middle of an iteration.
+_.breakLoop = -> throw breaker
+
+
+# Add your own custom functions to the Underscore object, ensuring that
+# they're correctly added to the OOP wrapper as well.
+_.mixin = (obj) ->
+  for name in _.functions(obj)
+    addToWrapper name, _[name] = obj[name]
+
+
+# Generate a unique integer id (unique within the entire client session).
+# Useful for temporary DOM ids.
+idCounter = 0
+_.uniqueId = (prefix) ->
+  (prefix or '') + idCounter++
+
+
+# By default, Underscore uses **ERB**-style template delimiters, change the
+# following template settings to use alternative delimiters.
+_.templateSettings = {
+  start: '<%'
+  end: '%>'
+  interpolate: /<%=(.+?)%>/g
+}
+
+
+# JavaScript templating a-la **ERB**, pilfered from John Resig's
+# *Secrets of the JavaScript Ninja*, page 83.
+# Single-quote fix from Rick Strahl.
+# With alterations for arbitrary delimiters, and to preserve whitespace.
+_.template = (str, data) ->
+  c = _.templateSettings
+  endMatch = new RegExp("'(?=[^"+c.end.substr(0, 1)+"]*"+escapeRegExp(c.end)+")","g")
+  fn = new Function 'obj',
+    'var p=[],print=function(){p.push.apply(p,arguments);};' +
+    'with(obj||{}){p.push(\'' +
+    str.replace(/\r/g, '\\r')
+       .replace(/\n/g, '\\n')
+       .replace(/\t/g, '\\t')
+       .replace(endMatch,"<22><><EFBFBD>")
+       .split("'").join("\\'")
+       .split("<22><><EFBFBD>").join("'")
+       .replace(c.interpolate, "',$1,'")
+       .split(c.start).join("');")
+       .split(c.end).join("p.push('") +
+       "');}return p.join('');"
+  if data then fn(data) else fn
+
+
+# Aliases
+# -------
+
+_.forEach = _.each
+_.foldl = _.inject = _.reduce
+_.foldr = _.reduceRight
+_.select = _.filter
+_.all = _.every
+_.any = _.some
+_.contains = _.include
+_.head = _.first
+_.tail = _.rest
+_.methods = _.functions
+
+
+# Setup the OOP Wrapper
+# ---------------------
+
+# If Underscore is called as a function, it returns a wrapped object that
+# can be used OO-style. This wrapper holds altered versions of all the
+# underscore functions. Wrapped objects may be chained.
+wrapper = (obj) ->
+  this._wrapped = obj
+  this
+
+
+# Helper function to continue chaining intermediate results.
+result = (obj, chain) ->
+  if chain then _(obj).chain() else obj
+
+
+# A method to easily add functions to the OOP wrapper.
+addToWrapper = (name, func) ->
+  wrapper.prototype[name] = ->
+    args = _.toArray arguments
+    unshift.call args, this._wrapped
+    result func.apply(_, args), this._chain
+
+
+# Add all ofthe Underscore functions to the wrapper object.
+_.mixin _
+
+
+# Add all mutator Array functions to the wrapper.
+_.each ['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], (name) ->
+  method = Array.prototype[name]
+  wrapper.prototype[name] = ->
+    method.apply(this._wrapped, arguments)
+    result(this._wrapped, this._chain)
+
+
+# Add all accessor Array functions to the wrapper.
+_.each ['concat', 'join', 'slice'], (name) ->
+  method = Array.prototype[name]
+  wrapper.prototype[name] = ->
+    result(method.apply(this._wrapped, arguments), this._chain)
+
+
+# Start chaining a wrapped Underscore object.
+wrapper::chain = ->
+  this._chain = true
+  this
+
+
+# Extracts the result from a wrapped and chained object.
+wrapper::value = -> this._wrapped
+</textarea></form>
+    <script>
+      var editor = CodeMirror.fromTextArea(document.getElementById("code"), {});
+    </script>
+
+    <p><strong>MIME types defined:</strong> <code>text/x-coffeescript</code>.</p>
+
+    <p>The CoffeeScript mode was written by Jeff Pickhardt (<a href="LICENSE">license</a>).</p>
+
+  </body>
+</html>

public/bower_components/messenger/docs/welcome/lib/executr/lib/CodeMirror/mode/javascript/index.html

@@ -0,0 +1,88 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>CodeMirror: JavaScript mode</title>
+    <link rel="stylesheet" href="../../lib/codemirror.css">
+    <script src="../../lib/codemirror.js"></script>
+    <script src="../../addon/edit/matchbrackets.js"></script>
+    <script src="../../addon/edit/continuecomment.js"></script>
+    <script src="javascript.js"></script>
+    <link rel="stylesheet" href="../../doc/docs.css">
+    <style type="text/css">.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style>
+  </head>
+  <body>
+    <h1>CodeMirror: JavaScript mode</h1>
+
+<div><textarea id="code" name="code">
+// Demo code (the actual new parser character stream implementation)
+
+function StringStream(string) {
+  this.pos = 0;
+  this.string = string;
+}
+
+StringStream.prototype = {
+  done: function() {return this.pos >= this.string.length;},
+  peek: function() {return this.string.charAt(this.pos);},
+  next: function() {
+    if (this.pos &lt; this.string.length)
+      return this.string.charAt(this.pos++);
+  },
+  eat: function(match) {
+    var ch = this.string.charAt(this.pos);
+    if (typeof match == "string") var ok = ch == match;
+    else var ok = ch &amp;&amp; match.test ? match.test(ch) : match(ch);
+    if (ok) {this.pos++; return ch;}
+  },
+  eatWhile: function(match) {
+    var start = this.pos;
+    while (this.eat(match));
+    if (this.pos > start) return this.string.slice(start, this.pos);
+  },
+  backUp: function(n) {this.pos -= n;},
+  column: function() {return this.pos;},
+  eatSpace: function() {
+    var start = this.pos;
+    while (/\s/.test(this.string.charAt(this.pos))) this.pos++;
+    return this.pos - start;
+  },
+  match: function(pattern, consume, caseInsensitive) {
+    if (typeof pattern == "string") {
+      function cased(str) {return caseInsensitive ? str.toLowerCase() : str;}
+      if (cased(this.string).indexOf(cased(pattern), this.pos) == this.pos) {
+        if (consume !== false) this.pos += str.length;
+        return true;
+      }
+    }
+    else {
+      var match = this.string.slice(this.pos).match(pattern);
+      if (match &amp;&amp; consume !== false) this.pos += match[0].length;
+      return match;
+    }
+  }
+};
+</textarea></div>
+
+    <script>
+      var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
+        lineNumbers: true,
+        matchBrackets: true,
+        extraKeys: {"Enter": "newlineAndIndentContinueComment"}
+      });
+    </script>
+
+    <p>
+      JavaScript mode supports a two configuration
+      options:
+      <ul>
+        <li><code>json</code> which will set the mode to expect JSON data rather than a JavaScript program.</li>
+        <li>
+          <code>typescript</code> which will activate additional syntax highlighting and some other things for TypeScript code (<a href="typescript.html">demo</a>).
+        </li>
+      </ul>
+    </p>
+
+    <p><strong>MIME types defined:</strong> <code>text/javascript</code>, <code>application/json</code>, <code>text/typescript</code>, <code>application/typescript</code>.</p>
+  </body>
+</html>

public/bower_components/messenger/docs/welcome/lib/executr/lib/CodeMirror/mode/javascript/javascript.js

@@ -0,0 +1,422 @@
+// TODO actually recognize syntax of TypeScript constructs
+
+CodeMirror.defineMode("javascript", function(config, parserConfig) {
+  var indentUnit = config.indentUnit;
+  var jsonMode = parserConfig.json;
+  var isTS = parserConfig.typescript;
+
+  // Tokenizer
+
+  var keywords = function(){
+    function kw(type) {return {type: type, style: "keyword"};}
+    var A = kw("keyword a"), B = kw("keyword b"), C = kw("keyword c");
+    var operator = kw("operator"), atom = {type: "atom", style: "atom"};
+    
+    var jsKeywords = {
+      "if": A, "while": A, "with": A, "else": B, "do": B, "try": B, "finally": B,
+      "return": C, "break": C, "continue": C, "new": C, "delete": C, "throw": C,
+      "var": kw("var"), "const": kw("var"), "let": kw("var"),
+      "function": kw("function"), "catch": kw("catch"),
+      "for": kw("for"), "switch": kw("switch"), "case": kw("case"), "default": kw("default"),
+      "in": operator, "typeof": operator, "instanceof": operator,
+      "true": atom, "false": atom, "null": atom, "undefined": atom, "NaN": atom, "Infinity": atom
+    };
+
+    // Extend the 'normal' keywords with the TypeScript language extensions
+    if (isTS) {
+      var type = {type: "variable", style: "variable-3"};
+      var tsKeywords = {
+        // object-like things
+        "interface": kw("interface"),
+        "class": kw("class"),
+        "extends": kw("extends"),
+        "constructor": kw("constructor"),
+
+        // scope modifiers
+        "public": kw("public"),
+        "private": kw("private"),
+        "protected": kw("protected"),
+        "static": kw("static"),
+
+        "super": kw("super"),
+
+        // types
+        "string": type, "number": type, "bool": type, "any": type
+      };
+
+      for (var attr in tsKeywords) {
+        jsKeywords[attr] = tsKeywords[attr];
+      }
+    }
+
+    return jsKeywords;
+  }();
+
+  var isOperatorChar = /[+\-*&%=<>!?|]/;
+
+  function chain(stream, state, f) {
+    state.tokenize = f;
+    return f(stream, state);
+  }
+
+  function nextUntilUnescaped(stream, end) {
+    var escaped = false, next;
+    while ((next = stream.next()) != null) {
+      if (next == end && !escaped)
+        return false;
+      escaped = !escaped && next == "\\";
+    }
+    return escaped;
+  }
+
+  // Used as scratch variables to communicate multiple values without
+  // consing up tons of objects.
+  var type, content;
+  function ret(tp, style, cont) {
+    type = tp; content = cont;
+    return style;
+  }
+
+  function jsTokenBase(stream, state) {
+    var ch = stream.next();
+    if (ch == '"' || ch == "'")
+      return chain(stream, state, jsTokenString(ch));
+    else if (/[\[\]{}\(\),;\:\.]/.test(ch))
+      return ret(ch);
+    else if (ch == "0" && stream.eat(/x/i)) {
+      stream.eatWhile(/[\da-f]/i);
+      return ret("number", "number");
+    }      
+    else if (/\d/.test(ch) || ch == "-" && stream.eat(/\d/)) {
+      stream.match(/^\d*(?:\.\d*)?(?:[eE][+\-]?\d+)?/);
+      return ret("number", "number");
+    }
+    else if (ch == "/") {
+      if (stream.eat("*")) {
+        return chain(stream, state, jsTokenComment);
+      }
+      else if (stream.eat("/")) {
+        stream.skipToEnd();
+        return ret("comment", "comment");
+      }
+      else if (state.lastType == "operator" || state.lastType == "keyword c" ||
+               /^[\[{}\(,;:]$/.test(state.lastType)) {
+        nextUntilUnescaped(stream, "/");
+        stream.eatWhile(/[gimy]/); // 'y' is "sticky" option in Mozilla
+        return ret("regexp", "string-2");
+      }
+      else {
+        stream.eatWhile(isOperatorChar);
+        return ret("operator", null, stream.current());
+      }
+    }
+    else if (ch == "#") {
+        stream.skipToEnd();
+        return ret("error", "error");
+    }
+    else if (isOperatorChar.test(ch)) {
+      stream.eatWhile(isOperatorChar);
+      return ret("operator", null, stream.current());
+    }
+    else {
+      stream.eatWhile(/[\w\$_]/);
+      var word = stream.current(), known = keywords.propertyIsEnumerable(word) && keywords[word];
+      return (known && state.lastType != ".") ? ret(known.type, known.style, word) :
+                     ret("variable", "variable", word);
+    }
+  }
+
+  function jsTokenString(quote) {
+    return function(stream, state) {
+      if (!nextUntilUnescaped(stream, quote))
+        state.tokenize = jsTokenBase;
+      return ret("string", "string");
+    };
+  }
+
+  function jsTokenComment(stream, state) {
+    var maybeEnd = false, ch;
+    while (ch = stream.next()) {
+      if (ch == "/" && maybeEnd) {
+        state.tokenize = jsTokenBase;
+        break;
+      }
+      maybeEnd = (ch == "*");
+    }
+    return ret("comment", "comment");
+  }
+
+  // Parser
+
+  var atomicTypes = {"atom": true, "number": true, "variable": true, "string": true, "regexp": true};
+
+  function JSLexical(indented, column, type, align, prev, info) {
+    this.indented = indented;
+    this.column = column;
+    this.type = type;
+    this.prev = prev;
+    this.info = info;
+    if (align != null) this.align = align;
+  }
+
+  function inScope(state, varname) {
+    for (var v = state.localVars; v; v = v.next)
+      if (v.name == varname) return true;
+  }
+
+  function parseJS(state, style, type, content, stream) {
+    var cc = state.cc;
+    // Communicate our context to the combinators.
+    // (Less wasteful than consing up a hundred closures on every call.)
+    cx.state = state; cx.stream = stream; cx.marked = null, cx.cc = cc;
+  
+    if (!state.lexical.hasOwnProperty("align"))
+      state.lexical.align = true;
+
+    while(true) {
+      var combinator = cc.length ? cc.pop() : jsonMode ? expression : statement;
+      if (combinator(type, content)) {
+        while(cc.length && cc[cc.length - 1].lex)
+          cc.pop()();
+        if (cx.marked) return cx.marked;
+        if (type == "variable" && inScope(state, content)) return "variable-2";
+        return style;
+      }
+    }
+  }
+
+  // Combinator utils
+
+  var cx = {state: null, column: null, marked: null, cc: null};
+  function pass() {
+    for (var i = arguments.length - 1; i >= 0; i--) cx.cc.push(arguments[i]);
+  }
+  function cont() {
+    pass.apply(null, arguments);
+    return true;
+  }
+  function register(varname) {
+    function inList(list) {
+      for (var v = list; v; v = v.next)
+        if (v.name == varname) return true;
+      return false;
+    }
+    var state = cx.state;
+    if (state.context) {
+      cx.marked = "def";
+      if (inList(state.localVars)) return;
+      state.localVars = {name: varname, next: state.localVars};
+    } else {
+      if (inList(state.globalVars)) return;
+      state.globalVars = {name: varname, next: state.globalVars};
+    }
+  }
+
+  // Combinators
+
+  var defaultVars = {name: "this", next: {name: "arguments"}};
+  function pushcontext() {
+    cx.state.context = {prev: cx.state.context, vars: cx.state.localVars};
+    cx.state.localVars = defaultVars;
+  }
+  function popcontext() {
+    cx.state.localVars = cx.state.context.vars;
+    cx.state.context = cx.state.context.prev;
+  }
+  function pushlex(type, info) {
+    var result = function() {
+      var state = cx.state;
+      state.lexical = new JSLexical(state.indented, cx.stream.column(), type, null, state.lexical, info);
+    };
+    result.lex = true;
+    return result;
+  }
+  function poplex() {
+    var state = cx.state;
+    if (state.lexical.prev) {
+      if (state.lexical.type == ")")
+        state.indented = state.lexical.indented;
+      state.lexical = state.lexical.prev;
+    }
+  }
+  poplex.lex = true;
+
+  function expect(wanted) {
+    return function expecting(type) {
+      if (type == wanted) return cont();
+      else if (wanted == ";") return pass();
+      else return cont(arguments.callee);
+    };
+  }
+
+  function statement(type) {
+    if (type == "var") return cont(pushlex("vardef"), vardef1, expect(";"), poplex);
+    if (type == "keyword a") return cont(pushlex("form"), expression, statement, poplex);
+    if (type == "keyword b") return cont(pushlex("form"), statement, poplex);
+    if (type == "{") return cont(pushlex("}"), block, poplex);
+    if (type == ";") return cont();
+    if (type == "function") return cont(functiondef);
+    if (type == "for") return cont(pushlex("form"), expect("("), pushlex(")"), forspec1, expect(")"),
+                                      poplex, statement, poplex);
+    if (type == "variable") return cont(pushlex("stat"), maybelabel);
+    if (type == "switch") return cont(pushlex("form"), expression, pushlex("}", "switch"), expect("{"),
+                                         block, poplex, poplex);
+    if (type == "case") return cont(expression, expect(":"));
+    if (type == "default") return cont(expect(":"));
+    if (type == "catch") return cont(pushlex("form"), pushcontext, expect("("), funarg, expect(")"),
+                                        statement, poplex, popcontext);
+    return pass(pushlex("stat"), expression, expect(";"), poplex);
+  }
+  function expression(type) {
+    if (atomicTypes.hasOwnProperty(type)) return cont(maybeoperator);
+    if (type == "function") return cont(functiondef);
+    if (type == "keyword c") return cont(maybeexpression);
+    if (type == "(") return cont(pushlex(")"), maybeexpression, expect(")"), poplex, maybeoperator);
+    if (type == "operator") return cont(expression);
+    if (type == "[") return cont(pushlex("]"), commasep(expression, "]"), poplex, maybeoperator);
+    if (type == "{") return cont(pushlex("}"), commasep(objprop, "}"), poplex, maybeoperator);
+    return cont();
+  }
+  function maybeexpression(type) {
+    if (type.match(/[;\}\)\],]/)) return pass();
+    return pass(expression);
+  }
+    
+  function maybeoperator(type, value) {
+    if (type == "operator" && /\+\+|--/.test(value)) return cont(maybeoperator);
+    if (type == "operator" && value == "?") return cont(expression, expect(":"), expression);
+    if (type == ";") return;
+    if (type == "(") return cont(pushlex(")"), commasep(expression, ")"), poplex, maybeoperator);
+    if (type == ".") return cont(property, maybeoperator);
+    if (type == "[") return cont(pushlex("]"), expression, expect("]"), poplex, maybeoperator);
+  }
+  function maybelabel(type) {
+    if (type == ":") return cont(poplex, statement);
+    return pass(maybeoperator, expect(";"), poplex);
+  }
+  function property(type) {
+    if (type == "variable") {cx.marked = "property"; return cont();}
+  }
+  function objprop(type) {
+    if (type == "variable") cx.marked = "property";
+    if (atomicTypes.hasOwnProperty(type)) return cont(expect(":"), expression);
+  }
+  function commasep(what, end) {
+    function proceed(type) {
+      if (type == ",") return cont(what, proceed);
+      if (type == end) return cont();
+      return cont(expect(end));
+    }
+    return function commaSeparated(type) {
+      if (type == end) return cont();
+      else return pass(what, proceed);
+    };
+  }
+  function block(type) {
+    if (type == "}") return cont();
+    return pass(statement, block);
+  }
+  function maybetype(type) {
+    if (type == ":") return cont(typedef);
+    return pass();
+  }
+  function typedef(type) {
+    if (type == "variable"){cx.marked = "variable-3"; return cont();}
+    return pass();
+  }
+  function vardef1(type, value) {
+    if (type == "variable") {
+      register(value);
+      return isTS ? cont(maybetype, vardef2) : cont(vardef2);
+    }
+    return pass();
+  }
+  function vardef2(type, value) {
+    if (value == "=") return cont(expression, vardef2);
+    if (type == ",") return cont(vardef1);
+  }
+  function forspec1(type) {
+    if (type == "var") return cont(vardef1, expect(";"), forspec2);
+    if (type == ";") return cont(forspec2);
+    if (type == "variable") return cont(formaybein);
+    return cont(forspec2);
+  }
+  function formaybein(_type, value) {
+    if (value == "in") return cont(expression);
+    return cont(maybeoperator, forspec2);
+  }
+  function forspec2(type, value) {
+    if (type == ";") return cont(forspec3);
+    if (value == "in") return cont(expression);
+    return cont(expression, expect(";"), forspec3);
+  }
+  function forspec3(type) {
+    if (type != ")") cont(expression);
+  }
+  function functiondef(type, value) {
+    if (type == "variable") {register(value); return cont(functiondef);}
+    if (type == "(") return cont(pushlex(")"), pushcontext, commasep(funarg, ")"), poplex, statement, popcontext);
+  }
+  function funarg(type, value) {
+    if (type == "variable") {register(value); return isTS ? cont(maybetype) : cont();}
+  }
+
+  // Interface
+
+  return {
+    startState: function(basecolumn) {
+      return {
+        tokenize: jsTokenBase,
+        lastType: null,
+        cc: [],
+        lexical: new JSLexical((basecolumn || 0) - indentUnit, 0, "block", false),
+        localVars: parserConfig.localVars,
+        globalVars: parserConfig.globalVars,
+        context: parserConfig.localVars && {vars: parserConfig.localVars},
+        indented: 0
+      };
+    },
+
+    token: function(stream, state) {
+      if (stream.sol()) {
+        if (!state.lexical.hasOwnProperty("align"))
+          state.lexical.align = false;
+        state.indented = stream.indentation();
+      }
+      if (stream.eatSpace()) return null;
+      var style = state.tokenize(stream, state);
+      if (type == "comment") return style;
+      state.lastType = type;
+      return parseJS(state, style, type, content, stream);
+    },
+
+    indent: function(state, textAfter) {
+      if (state.tokenize == jsTokenComment) return CodeMirror.Pass;
+      if (state.tokenize != jsTokenBase) return 0;
+      var firstChar = textAfter && textAfter.charAt(0), lexical = state.lexical;
+      if (lexical.type == "stat" && firstChar == "}") lexical = lexical.prev;
+      var type = lexical.type, closing = firstChar == type;
+      if (type == "vardef") return lexical.indented + (state.lastType == "operator" || state.lastType == "," ? 4 : 0);
+      else if (type == "form" && firstChar == "{") return lexical.indented;
+      else if (type == "form") return lexical.indented + indentUnit;
+      else if (type == "stat")
+        return lexical.indented + (state.lastType == "operator" || state.lastType == "," ? indentUnit : 0);
+      else if (lexical.info == "switch" && !closing)
+        return lexical.indented + (/^(?:case|default)\b/.test(textAfter) ? indentUnit : 2 * indentUnit);
+      else if (lexical.align) return lexical.column + (closing ? 0 : 1);
+      else return lexical.indented + (closing ? 0 : indentUnit);
+    },
+
+    electricChars: ":{}",
+
+    jsonMode: jsonMode
+  };
+});
+
+CodeMirror.defineMIME("text/javascript", "javascript");
+CodeMirror.defineMIME("text/ecmascript", "javascript");
+CodeMirror.defineMIME("application/javascript", "javascript");
+CodeMirror.defineMIME("application/ecmascript", "javascript");
+CodeMirror.defineMIME("application/json", {name: "javascript", json: true});
+CodeMirror.defineMIME("text/typescript", { name: "javascript", typescript: true });
+CodeMirror.defineMIME("application/typescript", { name: "javascript", typescript: true });

public/bower_components/messenger/docs/welcome/lib/executr/lib/CodeMirror/mode/javascript/typescript.html

@@ -0,0 +1,48 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>CodeMirror: TypeScript mode</title>
+    <link rel="stylesheet" href="../../lib/codemirror.css">
+    <script src="../../lib/codemirror.js"></script>
+    <script src="javascript.js"></script>
+    <link rel="stylesheet" href="../../doc/docs.css">
+    <style type="text/css">.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style>
+  </head>
+  <body>
+    <h1>CodeMirror: TypeScript mode</h1>
+
+<div><textarea id="code" name="code">
+class Greeter {
+	greeting: string;
+	constructor (message: string) {
+		this.greeting = message;
+	}
+	greet() {
+		return "Hello, " + this.greeting;
+	}
+}   
+
+var greeter = new Greeter("world");
+
+var button = document.createElement('button')
+button.innerText = "Say Hello"
+button.onclick = function() {
+	alert(greeter.greet())
+}
+
+document.body.appendChild(button)
+
+</textarea></div>
+
+    <script>
+      var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
+        lineNumbers: true,
+        matchBrackets: true,
+        mode: "text/typescript"
+      });
+    </script>
+
+    <p>This is a specialization of the <a href="index.html">JavaScript mode</a>.</p>
+  </body>
+</html>

public/bower_components/messenger/docs/welcome/lib/executr/lib/underscore.min.js

@@ -0,0 +1,32 @@
+// Underscore.js 1.3.3
+// (c) 2009-2012 Jeremy Ashkenas, DocumentCloud Inc.
+// Underscore is freely distributable under the MIT license.
+// Portions of Underscore are inspired or borrowed from Prototype,
+// Oliver Steele's Functional, and John Resig's Micro-Templating.
+// For all details and documentation:
+// http://documentcloud.github.com/underscore
+(function(){function r(a,c,d){if(a===c)return 0!==a||1/a==1/c;if(null==a||null==c)return a===c;a._chain&&(a=a._wrapped);c._chain&&(c=c._wrapped);if(a.isEqual&&b.isFunction(a.isEqual))return a.isEqual(c);if(c.isEqual&&b.isFunction(c.isEqual))return c.isEqual(a);var e=l.call(a);if(e!=l.call(c))return!1;switch(e){case "[object String]":return a==""+c;case "[object Number]":return a!=+a?c!=+c:0==a?1/a==1/c:a==+c;case "[object Date]":case "[object Boolean]":return+a==+c;case "[object RegExp]":return a.source==
+c.source&&a.global==c.global&&a.multiline==c.multiline&&a.ignoreCase==c.ignoreCase}if("object"!=typeof a||"object"!=typeof c)return!1;for(var f=d.length;f--;)if(d[f]==a)return!0;d.push(a);var f=0,g=!0;if("[object Array]"==e){if(f=a.length,g=f==c.length)for(;f--&&(g=f in a==f in c&&r(a[f],c[f],d)););}else{if("constructor"in a!="constructor"in c||a.constructor!=c.constructor)return!1;for(var h in a)if(b.has(a,h)&&(f++,!(g=b.has(c,h)&&r(a[h],c[h],d))))break;if(g){for(h in c)if(b.has(c,h)&&!f--)break;
+g=!f}}d.pop();return g}var s=this,I=s._,o={},k=Array.prototype,p=Object.prototype,i=k.slice,J=k.unshift,l=p.toString,K=p.hasOwnProperty,y=k.forEach,z=k.map,A=k.reduce,B=k.reduceRight,C=k.filter,D=k.every,E=k.some,q=k.indexOf,F=k.lastIndexOf,p=Array.isArray,L=Object.keys,t=Function.prototype.bind,b=function(a){return new m(a)};"undefined"!==typeof exports?("undefined"!==typeof module&&module.exports&&(exports=module.exports=b),exports._=b):s._=b;b.VERSION="1.3.3";var j=b.each=b.forEach=function(a,
+c,d){if(a!=null)if(y&&a.forEach===y)a.forEach(c,d);else if(a.length===+a.length)for(var e=0,f=a.length;e<f;e++){if(e in a&&c.call(d,a[e],e,a)===o)break}else for(e in a)if(b.has(a,e)&&c.call(d,a[e],e,a)===o)break};b.map=b.collect=function(a,c,b){var e=[];if(a==null)return e;if(z&&a.map===z)return a.map(c,b);j(a,function(a,g,h){e[e.length]=c.call(b,a,g,h)});if(a.length===+a.length)e.length=a.length;return e};b.reduce=b.foldl=b.inject=function(a,c,d,e){var f=arguments.length>2;a==null&&(a=[]);if(A&&
+a.reduce===A){e&&(c=b.bind(c,e));return f?a.reduce(c,d):a.reduce(c)}j(a,function(a,b,i){if(f)d=c.call(e,d,a,b,i);else{d=a;f=true}});if(!f)throw new TypeError("Reduce of empty array with no initial value");return d};b.reduceRight=b.foldr=function(a,c,d,e){var f=arguments.length>2;a==null&&(a=[]);if(B&&a.reduceRight===B){e&&(c=b.bind(c,e));return f?a.reduceRight(c,d):a.reduceRight(c)}var g=b.toArray(a).reverse();e&&!f&&(c=b.bind(c,e));return f?b.reduce(g,c,d,e):b.reduce(g,c)};b.find=b.detect=function(a,
+c,b){var e;G(a,function(a,g,h){if(c.call(b,a,g,h)){e=a;return true}});return e};b.filter=b.select=function(a,c,b){var e=[];if(a==null)return e;if(C&&a.filter===C)return a.filter(c,b);j(a,function(a,g,h){c.call(b,a,g,h)&&(e[e.length]=a)});return e};b.reject=function(a,c,b){var e=[];if(a==null)return e;j(a,function(a,g,h){c.call(b,a,g,h)||(e[e.length]=a)});return e};b.every=b.all=function(a,c,b){var e=true;if(a==null)return e;if(D&&a.every===D)return a.every(c,b);j(a,function(a,g,h){if(!(e=e&&c.call(b,
+a,g,h)))return o});return!!e};var G=b.some=b.any=function(a,c,d){c||(c=b.identity);var e=false;if(a==null)return e;if(E&&a.some===E)return a.some(c,d);j(a,function(a,b,h){if(e||(e=c.call(d,a,b,h)))return o});return!!e};b.include=b.contains=function(a,c){var b=false;if(a==null)return b;if(q&&a.indexOf===q)return a.indexOf(c)!=-1;return b=G(a,function(a){return a===c})};b.invoke=function(a,c){var d=i.call(arguments,2);return b.map(a,function(a){return(b.isFunction(c)?c||a:a[c]).apply(a,d)})};b.pluck=
+function(a,c){return b.map(a,function(a){return a[c]})};b.max=function(a,c,d){if(!c&&b.isArray(a)&&a[0]===+a[0])return Math.max.apply(Math,a);if(!c&&b.isEmpty(a))return-Infinity;var e={computed:-Infinity};j(a,function(a,b,h){b=c?c.call(d,a,b,h):a;b>=e.computed&&(e={value:a,computed:b})});return e.value};b.min=function(a,c,d){if(!c&&b.isArray(a)&&a[0]===+a[0])return Math.min.apply(Math,a);if(!c&&b.isEmpty(a))return Infinity;var e={computed:Infinity};j(a,function(a,b,h){b=c?c.call(d,a,b,h):a;b<e.computed&&
+(e={value:a,computed:b})});return e.value};b.shuffle=function(a){var b=[],d;j(a,function(a,f){d=Math.floor(Math.random()*(f+1));b[f]=b[d];b[d]=a});return b};b.sortBy=function(a,c,d){var e=b.isFunction(c)?c:function(a){return a[c]};return b.pluck(b.map(a,function(a,b,c){return{value:a,criteria:e.call(d,a,b,c)}}).sort(function(a,b){var c=a.criteria,d=b.criteria;return c===void 0?1:d===void 0?-1:c<d?-1:c>d?1:0}),"value")};b.groupBy=function(a,c){var d={},e=b.isFunction(c)?c:function(a){return a[c]};
+j(a,function(a,b){var c=e(a,b);(d[c]||(d[c]=[])).push(a)});return d};b.sortedIndex=function(a,c,d){d||(d=b.identity);for(var e=0,f=a.length;e<f;){var g=e+f>>1;d(a[g])<d(c)?e=g+1:f=g}return e};b.toArray=function(a){return!a?[]:b.isArray(a)||b.isArguments(a)?i.call(a):a.toArray&&b.isFunction(a.toArray)?a.toArray():b.values(a)};b.size=function(a){return b.isArray(a)?a.length:b.keys(a).length};b.first=b.head=b.take=function(a,b,d){return b!=null&&!d?i.call(a,0,b):a[0]};b.initial=function(a,b,d){return i.call(a,
+0,a.length-(b==null||d?1:b))};b.last=function(a,b,d){return b!=null&&!d?i.call(a,Math.max(a.length-b,0)):a[a.length-1]};b.rest=b.tail=function(a,b,d){return i.call(a,b==null||d?1:b)};b.compact=function(a){return b.filter(a,function(a){return!!a})};b.flatten=function(a,c){return b.reduce(a,function(a,e){if(b.isArray(e))return a.concat(c?e:b.flatten(e));a[a.length]=e;return a},[])};b.without=function(a){return b.difference(a,i.call(arguments,1))};b.uniq=b.unique=function(a,c,d){var d=d?b.map(a,d):a,
+e=[];a.length<3&&(c=true);b.reduce(d,function(d,g,h){if(c?b.last(d)!==g||!d.length:!b.include(d,g)){d.push(g);e.push(a[h])}return d},[]);return e};b.union=function(){return b.uniq(b.flatten(arguments,true))};b.intersection=b.intersect=function(a){var c=i.call(arguments,1);return b.filter(b.uniq(a),function(a){return b.every(c,function(c){return b.indexOf(c,a)>=0})})};b.difference=function(a){var c=b.flatten(i.call(arguments,1),true);return b.filter(a,function(a){return!b.include(c,a)})};b.zip=function(){for(var a=
+i.call(arguments),c=b.max(b.pluck(a,"length")),d=Array(c),e=0;e<c;e++)d[e]=b.pluck(a,""+e);return d};b.indexOf=function(a,c,d){if(a==null)return-1;var e;if(d){d=b.sortedIndex(a,c);return a[d]===c?d:-1}if(q&&a.indexOf===q)return a.indexOf(c);d=0;for(e=a.length;d<e;d++)if(d in a&&a[d]===c)return d;return-1};b.lastIndexOf=function(a,b){if(a==null)return-1;if(F&&a.lastIndexOf===F)return a.lastIndexOf(b);for(var d=a.length;d--;)if(d in a&&a[d]===b)return d;return-1};b.range=function(a,b,d){if(arguments.length<=
+1){b=a||0;a=0}for(var d=arguments[2]||1,e=Math.max(Math.ceil((b-a)/d),0),f=0,g=Array(e);f<e;){g[f++]=a;a=a+d}return g};var H=function(){};b.bind=function(a,c){var d,e;if(a.bind===t&&t)return t.apply(a,i.call(arguments,1));if(!b.isFunction(a))throw new TypeError;e=i.call(arguments,2);return d=function(){if(!(this instanceof d))return a.apply(c,e.concat(i.call(arguments)));H.prototype=a.prototype;var b=new H,g=a.apply(b,e.concat(i.call(arguments)));return Object(g)===g?g:b}};b.bindAll=function(a){var c=
+i.call(arguments,1);c.length==0&&(c=b.functions(a));j(c,function(c){a[c]=b.bind(a[c],a)});return a};b.memoize=function(a,c){var d={};c||(c=b.identity);return function(){var e=c.apply(this,arguments);return b.has(d,e)?d[e]:d[e]=a.apply(this,arguments)}};b.delay=function(a,b){var d=i.call(arguments,2);return setTimeout(function(){return a.apply(null,d)},b)};b.defer=function(a){return b.delay.apply(b,[a,1].concat(i.call(arguments,1)))};b.throttle=function(a,c){var d,e,f,g,h,i,j=b.debounce(function(){h=
+g=false},c);return function(){d=this;e=arguments;f||(f=setTimeout(function(){f=null;h&&a.apply(d,e);j()},c));g?h=true:i=a.apply(d,e);j();g=true;return i}};b.debounce=function(a,b,d){var e;return function(){var f=this,g=arguments;d&&!e&&a.apply(f,g);clearTimeout(e);e=setTimeout(function(){e=null;d||a.apply(f,g)},b)}};b.once=function(a){var b=false,d;return function(){if(b)return d;b=true;return d=a.apply(this,arguments)}};b.wrap=function(a,b){return function(){var d=[a].concat(i.call(arguments,0));
+return b.apply(this,d)}};b.compose=function(){var a=arguments;return function(){for(var b=arguments,d=a.length-1;d>=0;d--)b=[a[d].apply(this,b)];return b[0]}};b.after=function(a,b){return a<=0?b():function(){if(--a<1)return b.apply(this,arguments)}};b.keys=L||function(a){if(a!==Object(a))throw new TypeError("Invalid object");var c=[],d;for(d in a)b.has(a,d)&&(c[c.length]=d);return c};b.values=function(a){return b.map(a,b.identity)};b.functions=b.methods=function(a){var c=[],d;for(d in a)b.isFunction(a[d])&&
+c.push(d);return c.sort()};b.extend=function(a){j(i.call(arguments,1),function(b){for(var d in b)a[d]=b[d]});return a};b.pick=function(a){var c={};j(b.flatten(i.call(arguments,1)),function(b){b in a&&(c[b]=a[b])});return c};b.defaults=function(a){j(i.call(arguments,1),function(b){for(var d in b)a[d]==null&&(a[d]=b[d])});return a};b.clone=function(a){return!b.isObject(a)?a:b.isArray(a)?a.slice():b.extend({},a)};b.tap=function(a,b){b(a);return a};b.isEqual=function(a,b){return r(a,b,[])};b.isEmpty=
+function(a){if(a==null)return true;if(b.isArray(a)||b.isString(a))return a.length===0;for(var c in a)if(b.has(a,c))return false;return true};b.isElement=function(a){return!!(a&&a.nodeType==1)};b.isArray=p||function(a){return l.call(a)=="[object Array]"};b.isObject=function(a){return a===Object(a)};b.isArguments=function(a){return l.call(a)=="[object Arguments]"};b.isArguments(arguments)||(b.isArguments=function(a){return!(!a||!b.has(a,"callee"))});b.isFunction=function(a){return l.call(a)=="[object Function]"};
+b.isString=function(a){return l.call(a)=="[object String]"};b.isNumber=function(a){return l.call(a)=="[object Number]"};b.isFinite=function(a){return b.isNumber(a)&&isFinite(a)};b.isNaN=function(a){return a!==a};b.isBoolean=function(a){return a===true||a===false||l.call(a)=="[object Boolean]"};b.isDate=function(a){return l.call(a)=="[object Date]"};b.isRegExp=function(a){return l.call(a)=="[object RegExp]"};b.isNull=function(a){return a===null};b.isUndefined=function(a){return a===void 0};b.has=function(a,
+b){return K.call(a,b)};b.noConflict=function(){s._=I;return this};b.identity=function(a){return a};b.times=function(a,b,d){for(var e=0;e<a;e++)b.call(d,e)};b.escape=function(a){return(""+a).replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;").replace(/'/g,"&#x27;").replace(/\//g,"&#x2F;")};b.result=function(a,c){if(a==null)return null;var d=a[c];return b.isFunction(d)?d.call(a):d};b.mixin=function(a){j(b.functions(a),function(c){M(c,b[c]=a[c])})};var N=0;b.uniqueId=
+function(a){var b=N++;return a?a+b:b};b.templateSettings={evaluate:/<%([\s\S]+?)%>/g,interpolate:/<%=([\s\S]+?)%>/g,escape:/<%-([\s\S]+?)%>/g};var u=/.^/,n={"\\":"\\","'":"'",r:"\r",n:"\n",t:"\t",u2028:"\u2028",u2029:"\u2029"},v;for(v in n)n[n[v]]=v;var O=/\\|'|\r|\n|\t|\u2028|\u2029/g,P=/\\(\\|'|r|n|t|u2028|u2029)/g,w=function(a){return a.replace(P,function(a,b){return n[b]})};b.template=function(a,c,d){d=b.defaults(d||{},b.templateSettings);a="__p+='"+a.replace(O,function(a){return"\\"+n[a]}).replace(d.escape||
+u,function(a,b){return"'+\n_.escape("+w(b)+")+\n'"}).replace(d.interpolate||u,function(a,b){return"'+\n("+w(b)+")+\n'"}).replace(d.evaluate||u,function(a,b){return"';\n"+w(b)+"\n;__p+='"})+"';\n";d.variable||(a="with(obj||{}){\n"+a+"}\n");var a="var __p='';var print=function(){__p+=Array.prototype.join.call(arguments, '')};\n"+a+"return __p;\n",e=new Function(d.variable||"obj","_",a);if(c)return e(c,b);c=function(a){return e.call(this,a,b)};c.source="function("+(d.variable||"obj")+"){\n"+a+"}";return c};
+b.chain=function(a){return b(a).chain()};var m=function(a){this._wrapped=a};b.prototype=m.prototype;var x=function(a,c){return c?b(a).chain():a},M=function(a,c){m.prototype[a]=function(){var a=i.call(arguments);J.call(a,this._wrapped);return x(c.apply(b,a),this._chain)}};b.mixin(b);j("pop,push,reverse,shift,sort,splice,unshift".split(","),function(a){var b=k[a];m.prototype[a]=function(){var d=this._wrapped;b.apply(d,arguments);var e=d.length;(a=="shift"||a=="splice")&&e===0&&delete d[0];return x(d,
+this._chain)}});j(["concat","join","slice"],function(a){var b=k[a];m.prototype[a]=function(){return x(b.apply(this._wrapped,arguments),this._chain)}});m.prototype.chain=function(){this._chain=true;return this};m.prototype.value=function(){return this._wrapped}}).call(this);

public/bower_components/messenger/docs/welcome/lib/executr/src/coffee/executr.coffee

@@ -0,0 +1,207 @@
+runners =
+  'javascript': (opts, code) ->
+      eval code
+
+converters =
+  'coffeescript:javascript': (opts, code) ->
+    csOptions = $.extend {}, opts.coffeeOptions,
+      bare: true
+
+    CoffeeScript.compile code, csOptions
+
+
+  'javascript:coffeescript': (opts, code) ->
+    if Js2coffee
+      out = Js2coffee.build code
+    else
+      #fallback if you dont include Js2Coffee
+      console.error "Can't convert javascript to coffeescript"
+      return code
+
+normalizeType = (codeType) ->
+  switch codeType.toLowerCase()
+    when 'js', 'javascript', 'text/javascript', 'application/javascript'
+      return 'javascript'
+    when 'cs', 'coffee', 'coffeescript', 'text/coffeescript', 'application/coffeescript'
+      return 'coffeescript'
+    else
+      console.error "Code type #{ codeType } not understood."
+
+class Editor
+  constructor: (args) ->
+    @el = args.el
+    @opts = args.opts
+    @codeCache = {}
+
+    @$el = $ @el
+
+    do @buildEditor
+    do @addRunButton
+    do @addListeners
+
+  getValue: ->
+    @editor.getValue()
+
+  addListeners: ->
+    @$el.on 'executrSwitchType', (e, type) =>
+      @switchType type
+
+  addRunButton: ->
+    @$runButton = $('<button>')
+    @$runButton.addClass 'executr-run-button'
+    @$runButton.text @opts.buttonText
+
+    @$editorCont.append @$runButton
+
+    @$runButton.css
+      top: "#{ @$editorCont.height() / 2 - @$runButton.height() / 2 }px"
+
+    if @$editorCont.height() < parseInt(@$runButton.css('font-size'), 10) + 4
+      @$runButton.css 'font-size', "#{ @$editorCont.height() - 4 }px"
+
+    @$runButton.click => do @execute
+
+  buildEditor: ->
+    @$editorCont = $('<div>')
+    @$editorCont.addClass 'executr-code-editor'
+    @$editorCont.css
+      height: "#{ @$el.height() + 10 }px"
+      width: "#{ @$el.width() }px"
+
+    @$editorCont.insertBefore @$el
+    @$el.detach()
+
+    if typeof @opts.type is 'function'
+      type = @opts.type(@$el, @)
+    else
+      type = @opts.type ? @$el.attr('data-type') ? @opts.defaultType
+
+    type = normalizeType type
+
+    code = @$el.text()
+
+    mirrorOpts =
+      value: code
+      mode: type
+
+    @codeCache[type] = code
+
+    @editor = CodeMirror @$editorCont[0], $.extend(mirrorOpts, @opts.codeMirrorOptions)
+
+    @editor.on('change', (doc, changeObj) =>
+      if changeObj?.origin and not (changeObj.origin instanceof Object)
+        @codeCache = {}
+    )
+
+  getType: ->
+    @editor.getMode().name
+
+  switchType: (type) ->
+    type = normalizeType type
+    currentType = @getType()
+
+    if type is currentType
+      return
+
+    if @codeCache[type]
+      code = @codeCache[type]
+    else
+      converter = converters["#{ currentType }:#{ type }"]
+
+      unless converter?
+        console.error "Can't convert #{ currentType } to #{ type }"
+        return
+
+      code = converter @opts, @editor.getValue()
+      @codeCache[type] = code
+
+    @editor.setOption 'mode', type
+    @editor.setValue code
+    @editor.refresh()
+
+    scrollInfo = @editor.getScrollInfo()
+
+    @$editorCont.css
+      height: "#{ scrollInfo.height }px"
+
+  # Do the actual runny bit.
+  #
+  # Also handles converting the source into a language we know how to run.
+  run: (type, opts, code) ->
+    runner = runners[type]
+
+    # Non-recursivly (max depth == 1) try to convert the source
+    # into a language we can run.
+    unless runner?
+      for key, func of converters
+        [from, to] = key.split ':'
+
+        if type is from and runners[to]
+          runner = runners[to]
+          code = func(opts, code)
+
+    if not runner?
+      console.error "Couldn't find a way to run #{ type } block"
+      return
+
+    runner opts, code
+
+  execute: ->
+    code = @getValue()
+    codeType = @getType()
+
+    @$el.trigger 'executrBeforeExecute', [code, codeType, @opts]
+    if @opts.setUp?
+      @opts.setUp(codeType, @opts)
+
+    output = @run codeType, @opts, code
+
+    if @opts.tearDown?
+      @opts.tearDown(output, codeType, @opts)
+    @$el.trigger 'executrAfterExecute', [output, code, codeType, @opts]
+
+    insertOutput @opts, output
+
+
+getCodeElement = (e, opts) ->
+  $target = $ e.target
+  $code = $target.parents(opts.codeSelector)
+
+  if not $code.length and $target.is(opts.codeSelector)
+    $code = $target
+
+  $code
+
+insertOutput = (opts, output) ->
+  if opts.outputTo
+    if opts.appendOutput
+      $(opts.outputTo).append $('<div>').text(output)
+    else
+      $(opts.outputTo).text output
+
+$.fn.executr = (opts) ->
+  defaults =
+    codeSelector: 'code[executable]'
+    outputTo: false
+    appendOutput: true
+    defaultType: 'coffee'
+    buttonText: "RUN"
+
+  opts = $.extend {}, defaults, opts
+
+  if this.is(opts.codeSelector)
+    # Allow single code blocks to be passed in
+    opts.codeSelector = null
+
+
+  codeSelectors = this.find(opts.codeSelector)
+
+  codeSelectors.each (i, el) ->
+    new Editor({el: el, opts: opts})
+
+  $('.executr-switch').click ->
+    $this = $(@)
+    $this.addClass('selected').siblings().removeClass('selected')
+    codeType = $this.attr('data-code-type')
+    codeSelectors.trigger 'executrSwitchType', codeType
+

public/bower_components/messenger/docs/welcome/lib/executr/src/css/executr.css

@@ -0,0 +1,38 @@
+code[executable] {
+  display: block;
+}
+
+.executr-code-editor {
+  overflow: hidden;
+  position: relative;
+  box-sizing: border-box;
+}
+.executr-code-editor .CodeMirror pre {
+  box-shadow: none;
+  border-width: 0;
+  line-height: 1.3;
+  font-family: Monaco, Menlo, Consolas, 'Courier New', monospace;
+  font-size: 13px;
+}
+.executr-code-editor .executr-run-button {
+  width: 84px;
+  padding: 0 10px;
+  font-size: 24px;
+  z-index: 5;
+  border-width: 0;
+  background-color: #DDD;
+
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  right: 0;
+
+  opacity: 0.5;
+}
+.executr-code-editor .executr-run-button:hover {
+  opacity: 0.8;
+}
+
+.CodeMirror {
+  height: auto;
+}

public/bower_components/messenger/docs/welcome/lib/jasmine-1.3.1/MIT.LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008-2011 Pivotal Labs
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

public/bower_components/messenger/docs/welcome/lib/jasmine-1.3.1/jasmine-html.js

@@ -0,0 +1,681 @@
+jasmine.HtmlReporterHelpers = {};
+
+jasmine.HtmlReporterHelpers.createDom = function(type, attrs, childrenVarArgs) {
+  var el = document.createElement(type);
+
+  for (var i = 2; i < arguments.length; i++) {
+    var child = arguments[i];
+
+    if (typeof child === 'string') {
+      el.appendChild(document.createTextNode(child));
+    } else {
+      if (child) {
+        el.appendChild(child);
+      }
+    }
+  }
+
+  for (var attr in attrs) {
+    if (attr == "className") {
+      el[attr] = attrs[attr];
+    } else {
+      el.setAttribute(attr, attrs[attr]);
+    }
+  }
+
+  return el;
+};
+
+jasmine.HtmlReporterHelpers.getSpecStatus = function(child) {
+  var results = child.results();
+  var status = results.passed() ? 'passed' : 'failed';
+  if (results.skipped) {
+    status = 'skipped';
+  }
+
+  return status;
+};
+
+jasmine.HtmlReporterHelpers.appendToSummary = function(child, childElement) {
+  var parentDiv = this.dom.summary;
+  var parentSuite = (typeof child.parentSuite == 'undefined') ? 'suite' : 'parentSuite';
+  var parent = child[parentSuite];
+
+  if (parent) {
+    if (typeof this.views.suites[parent.id] == 'undefined') {
+      this.views.suites[parent.id] = new jasmine.HtmlReporter.SuiteView(parent, this.dom, this.views);
+    }
+    parentDiv = this.views.suites[parent.id].element;
+  }
+
+  parentDiv.appendChild(childElement);
+};
+
+
+jasmine.HtmlReporterHelpers.addHelpers = function(ctor) {
+  for(var fn in jasmine.HtmlReporterHelpers) {
+    ctor.prototype[fn] = jasmine.HtmlReporterHelpers[fn];
+  }
+};
+
+jasmine.HtmlReporter = function(_doc) {
+  var self = this;
+  var doc = _doc || window.document;
+
+  var reporterView;
+
+  var dom = {};
+
+  // Jasmine Reporter Public Interface
+  self.logRunningSpecs = false;
+
+  self.reportRunnerStarting = function(runner) {
+    var specs = runner.specs() || [];
+
+    if (specs.length == 0) {
+      return;
+    }
+
+    createReporterDom(runner.env.versionString());
+    doc.body.appendChild(dom.reporter);
+    setExceptionHandling();
+
+    reporterView = new jasmine.HtmlReporter.ReporterView(dom);
+    reporterView.addSpecs(specs, self.specFilter);
+  };
+
+  self.reportRunnerResults = function(runner) {
+    reporterView && reporterView.complete();
+  };
+
+  self.reportSuiteResults = function(suite) {
+    reporterView.suiteComplete(suite);
+  };
+
+  self.reportSpecStarting = function(spec) {
+    if (self.logRunningSpecs) {
+      self.log('>> Jasmine Running ' + spec.suite.description + ' ' + spec.description + '...');
+    }
+  };
+
+  self.reportSpecResults = function(spec) {
+    reporterView.specComplete(spec);
+  };
+
+  self.log = function() {
+    var console = jasmine.getGlobal().console;
+    if (console && console.log) {
+      if (console.log.apply) {
+        console.log.apply(console, arguments);
+      } else {
+        console.log(arguments); // ie fix: console.log.apply doesn't exist on ie
+      }
+    }
+  };
+
+  self.specFilter = function(spec) {
+    if (!focusedSpecName()) {
+      return true;
+    }
+
+    return spec.getFullName().indexOf(focusedSpecName()) === 0;
+  };
+
+  return self;
+
+  function focusedSpecName() {
+    var specName;
+
+    (function memoizeFocusedSpec() {
+      if (specName) {
+        return;
+      }
+
+      var paramMap = [];
+      var params = jasmine.HtmlReporter.parameters(doc);
+
+      for (var i = 0; i < params.length; i++) {
+        var p = params[i].split('=');
+        paramMap[decodeURIComponent(p[0])] = decodeURIComponent(p[1]);
+      }
+
+      specName = paramMap.spec;
+    })();
+
+    return specName;
+  }
+
+  function createReporterDom(version) {
+    dom.reporter = self.createDom('div', { id: 'HTMLReporter', className: 'jasmine_reporter' },
+      dom.banner = self.createDom('div', { className: 'banner' },
+        self.createDom('span', { className: 'title' }, "Jasmine "),
+        self.createDom('span', { className: 'version' }, version)),
+
+      dom.symbolSummary = self.createDom('ul', {className: 'symbolSummary'}),
+      dom.alert = self.createDom('div', {className: 'alert'},
+        self.createDom('span', { className: 'exceptions' },
+          self.createDom('label', { className: 'label', 'for': 'no_try_catch' }, 'No try/catch'),
+          self.createDom('input', { id: 'no_try_catch', type: 'checkbox' }))),
+      dom.results = self.createDom('div', {className: 'results'},
+        dom.summary = self.createDom('div', { className: 'summary' }),
+        dom.details = self.createDom('div', { id: 'details' }))
+    );
+  }
+
+  function noTryCatch() {
+    return window.location.search.match(/catch=false/);
+  }
+
+  function searchWithCatch() {
+    var params = jasmine.HtmlReporter.parameters(window.document);
+    var removed = false;
+    var i = 0;
+
+    while (!removed && i < params.length) {
+      if (params[i].match(/catch=/)) {
+        params.splice(i, 1);
+        removed = true;
+      }
+      i++;
+    }
+    if (jasmine.CATCH_EXCEPTIONS) {
+      params.push("catch=false");
+    }
+
+    return params.join("&");
+  }
+
+  function setExceptionHandling() {
+    var chxCatch = document.getElementById('no_try_catch');
+
+    if (noTryCatch()) {
+      chxCatch.setAttribute('checked', true);
+      jasmine.CATCH_EXCEPTIONS = false;
+    }
+    chxCatch.onclick = function() {
+      window.location.search = searchWithCatch();
+    };
+  }
+};
+jasmine.HtmlReporter.parameters = function(doc) {
+  var paramStr = doc.location.search.substring(1);
+  var params = [];
+
+  if (paramStr.length > 0) {
+    params = paramStr.split('&');
+  }
+  return params;
+}
+jasmine.HtmlReporter.sectionLink = function(sectionName) {
+  var link = '?';
+  var params = [];
+
+  if (sectionName) {
+    params.push('spec=' + encodeURIComponent(sectionName));
+  }
+  if (!jasmine.CATCH_EXCEPTIONS) {
+    params.push("catch=false");
+  }
+  if (params.length > 0) {
+    link += params.join("&");
+  }
+
+  return link;
+};
+jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter);
+jasmine.HtmlReporter.ReporterView = function(dom) {
+  this.startedAt = new Date();
+  this.runningSpecCount = 0;
+  this.completeSpecCount = 0;
+  this.passedCount = 0;
+  this.failedCount = 0;
+  this.skippedCount = 0;
+
+  this.createResultsMenu = function() {
+    this.resultsMenu = this.createDom('span', {className: 'resultsMenu bar'},
+      this.summaryMenuItem = this.createDom('a', {className: 'summaryMenuItem', href: "#"}, '0 specs'),
+      ' | ',
+      this.detailsMenuItem = this.createDom('a', {className: 'detailsMenuItem', href: "#"}, '0 failing'));
+
+    this.summaryMenuItem.onclick = function() {
+      dom.reporter.className = dom.reporter.className.replace(/ showDetails/g, '');
+    };
+
+    this.detailsMenuItem.onclick = function() {
+      showDetails();
+    };
+  };
+
+  this.addSpecs = function(specs, specFilter) {
+    this.totalSpecCount = specs.length;
+
+    this.views = {
+      specs: {},
+      suites: {}
+    };
+
+    for (var i = 0; i < specs.length; i++) {
+      var spec = specs[i];
+      this.views.specs[spec.id] = new jasmine.HtmlReporter.SpecView(spec, dom, this.views);
+      if (specFilter(spec)) {
+        this.runningSpecCount++;
+      }
+    }
+  };
+
+  this.specComplete = function(spec) {
+    this.completeSpecCount++;
+
+    if (isUndefined(this.views.specs[spec.id])) {
+      this.views.specs[spec.id] = new jasmine.HtmlReporter.SpecView(spec, dom);
+    }
+
+    var specView = this.views.specs[spec.id];
+
+    switch (specView.status()) {
+      case 'passed':
+        this.passedCount++;
+        break;
+
+      case 'failed':
+        this.failedCount++;
+        break;
+
+      case 'skipped':
+        this.skippedCount++;
+        break;
+    }
+
+    specView.refresh();
+    this.refresh();
+  };
+
+  this.suiteComplete = function(suite) {
+    var suiteView = this.views.suites[suite.id];
+    if (isUndefined(suiteView)) {
+      return;
+    }
+    suiteView.refresh();
+  };
+
+  this.refresh = function() {
+
+    if (isUndefined(this.resultsMenu)) {
+      this.createResultsMenu();
+    }
+
+    // currently running UI
+    if (isUndefined(this.runningAlert)) {
+      this.runningAlert = this.createDom('a', { href: jasmine.HtmlReporter.sectionLink(), className: "runningAlert bar" });
+      dom.alert.appendChild(this.runningAlert);
+    }
+    this.runningAlert.innerHTML = "Running " + this.completeSpecCount + " of " + specPluralizedFor(this.totalSpecCount);
+
+    // skipped specs UI
+    if (isUndefined(this.skippedAlert)) {
+      this.skippedAlert = this.createDom('a', { href: jasmine.HtmlReporter.sectionLink(), className: "skippedAlert bar" });
+    }
+
+    this.skippedAlert.innerHTML = "Skipping " + this.skippedCount + " of " + specPluralizedFor(this.totalSpecCount) + " - run all";
+
+    if (this.skippedCount === 1 && isDefined(dom.alert)) {
+      dom.alert.appendChild(this.skippedAlert);
+    }
+
+    // passing specs UI
+    if (isUndefined(this.passedAlert)) {
+      this.passedAlert = this.createDom('span', { href: jasmine.HtmlReporter.sectionLink(), className: "passingAlert bar" });
+    }
+    this.passedAlert.innerHTML = "Passing " + specPluralizedFor(this.passedCount);
+
+    // failing specs UI
+    if (isUndefined(this.failedAlert)) {
+      this.failedAlert = this.createDom('span', {href: "?", className: "failingAlert bar"});
+    }
+    this.failedAlert.innerHTML = "Failing " + specPluralizedFor(this.failedCount);
+
+    if (this.failedCount === 1 && isDefined(dom.alert)) {
+      dom.alert.appendChild(this.failedAlert);
+      dom.alert.appendChild(this.resultsMenu);
+    }
+
+    // summary info
+    this.summaryMenuItem.innerHTML = "" + specPluralizedFor(this.runningSpecCount);
+    this.detailsMenuItem.innerHTML = "" + this.failedCount + " failing";
+  };
+
+  this.complete = function() {
+    dom.alert.removeChild(this.runningAlert);
+
+    this.skippedAlert.innerHTML = "Ran " + this.runningSpecCount + " of " + specPluralizedFor(this.totalSpecCount) + " - run all";
+
+    if (this.failedCount === 0) {
+      dom.alert.appendChild(this.createDom('span', {className: 'passingAlert bar'}, "Passing " + specPluralizedFor(this.passedCount)));
+    } else {
+      showDetails();
+    }
+
+    dom.banner.appendChild(this.createDom('span', {className: 'duration'}, "finished in " + ((new Date().getTime() - this.startedAt.getTime()) / 1000) + "s"));
+  };
+
+  return this;
+
+  function showDetails() {
+    if (dom.reporter.className.search(/showDetails/) === -1) {
+      dom.reporter.className += " showDetails";
+    }
+  }
+
+  function isUndefined(obj) {
+    return typeof obj === 'undefined';
+  }
+
+  function isDefined(obj) {
+    return !isUndefined(obj);
+  }
+
+  function specPluralizedFor(count) {
+    var str = count + " spec";
+    if (count > 1) {
+      str += "s"
+    }
+    return str;
+  }
+
+};
+
+jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter.ReporterView);
+
+
+jasmine.HtmlReporter.SpecView = function(spec, dom, views) {
+  this.spec = spec;
+  this.dom = dom;
+  this.views = views;
+
+  this.symbol = this.createDom('li', { className: 'pending' });
+  this.dom.symbolSummary.appendChild(this.symbol);
+
+  this.summary = this.createDom('div', { className: 'specSummary' },
+    this.createDom('a', {
+      className: 'description',
+      href: jasmine.HtmlReporter.sectionLink(this.spec.getFullName()),
+      title: this.spec.getFullName()
+    }, this.spec.description)
+  );
+
+  this.detail = this.createDom('div', { className: 'specDetail' },
+      this.createDom('a', {
+        className: 'description',
+        href: '?spec=' + encodeURIComponent(this.spec.getFullName()),
+        title: this.spec.getFullName()
+      }, this.spec.getFullName())
+  );
+};
+
+jasmine.HtmlReporter.SpecView.prototype.status = function() {
+  return this.getSpecStatus(this.spec);
+};
+
+jasmine.HtmlReporter.SpecView.prototype.refresh = function() {
+  this.symbol.className = this.status();
+
+  switch (this.status()) {
+    case 'skipped':
+      break;
+
+    case 'passed':
+      this.appendSummaryToSuiteDiv();
+      break;
+
+    case 'failed':
+      this.appendSummaryToSuiteDiv();
+      this.appendFailureDetail();
+      break;
+  }
+};
+
+jasmine.HtmlReporter.SpecView.prototype.appendSummaryToSuiteDiv = function() {
+  this.summary.className += ' ' + this.status();
+  this.appendToSummary(this.spec, this.summary);
+};
+
+jasmine.HtmlReporter.SpecView.prototype.appendFailureDetail = function() {
+  this.detail.className += ' ' + this.status();
+
+  var resultItems = this.spec.results().getItems();
+  var messagesDiv = this.createDom('div', { className: 'messages' });
+
+  for (var i = 0; i < resultItems.length; i++) {
+    var result = resultItems[i];
+
+    if (result.type == 'log') {
+      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage log'}, result.toString()));
+    } else if (result.type == 'expect' && result.passed && !result.passed()) {
+      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage fail'}, result.message));
+
+      if (result.trace.stack) {
+        messagesDiv.appendChild(this.createDom('div', {className: 'stackTrace'}, result.trace.stack));
+      }
+    }
+  }
+
+  if (messagesDiv.childNodes.length > 0) {
+    this.detail.appendChild(messagesDiv);
+    this.dom.details.appendChild(this.detail);
+  }
+};
+
+jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter.SpecView);jasmine.HtmlReporter.SuiteView = function(suite, dom, views) {
+  this.suite = suite;
+  this.dom = dom;
+  this.views = views;
+
+  this.element = this.createDom('div', { className: 'suite' },
+    this.createDom('a', { className: 'description', href: jasmine.HtmlReporter.sectionLink(this.suite.getFullName()) }, this.suite.description)
+  );
+
+  this.appendToSummary(this.suite, this.element);
+};
+
+jasmine.HtmlReporter.SuiteView.prototype.status = function() {
+  return this.getSpecStatus(this.suite);
+};
+
+jasmine.HtmlReporter.SuiteView.prototype.refresh = function() {
+  this.element.className += " " + this.status();
+};
+
+jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter.SuiteView);
+
+/* @deprecated Use jasmine.HtmlReporter instead
+ */
+jasmine.TrivialReporter = function(doc) {
+  this.document = doc || document;
+  this.suiteDivs = {};
+  this.logRunningSpecs = false;
+};
+
+jasmine.TrivialReporter.prototype.createDom = function(type, attrs, childrenVarArgs) {
+  var el = document.createElement(type);
+
+  for (var i = 2; i < arguments.length; i++) {
+    var child = arguments[i];
+
+    if (typeof child === 'string') {
+      el.appendChild(document.createTextNode(child));
+    } else {
+      if (child) { el.appendChild(child); }
+    }
+  }
+
+  for (var attr in attrs) {
+    if (attr == "className") {
+      el[attr] = attrs[attr];
+    } else {
+      el.setAttribute(attr, attrs[attr]);
+    }
+  }
+
+  return el;
+};
+
+jasmine.TrivialReporter.prototype.reportRunnerStarting = function(runner) {
+  var showPassed, showSkipped;
+
+  this.outerDiv = this.createDom('div', { id: 'TrivialReporter', className: 'jasmine_reporter' },
+      this.createDom('div', { className: 'banner' },
+        this.createDom('div', { className: 'logo' },
+            this.createDom('span', { className: 'title' }, "Jasmine"),
+            this.createDom('span', { className: 'version' }, runner.env.versionString())),
+        this.createDom('div', { className: 'options' },
+            "Show ",
+            showPassed = this.createDom('input', { id: "__jasmine_TrivialReporter_showPassed__", type: 'checkbox' }),
+            this.createDom('label', { "for": "__jasmine_TrivialReporter_showPassed__" }, " passed "),
+            showSkipped = this.createDom('input', { id: "__jasmine_TrivialReporter_showSkipped__", type: 'checkbox' }),
+            this.createDom('label', { "for": "__jasmine_TrivialReporter_showSkipped__" }, " skipped")
+            )
+          ),
+
+      this.runnerDiv = this.createDom('div', { className: 'runner running' },
+          this.createDom('a', { className: 'run_spec', href: '?' }, "run all"),
+          this.runnerMessageSpan = this.createDom('span', {}, "Running..."),
+          this.finishedAtSpan = this.createDom('span', { className: 'finished-at' }, ""))
+      );
+
+  this.document.body.appendChild(this.outerDiv);
+
+  var suites = runner.suites();
+  for (var i = 0; i < suites.length; i++) {
+    var suite = suites[i];
+    var suiteDiv = this.createDom('div', { className: 'suite' },
+        this.createDom('a', { className: 'run_spec', href: '?spec=' + encodeURIComponent(suite.getFullName()) }, "run"),
+        this.createDom('a', { className: 'description', href: '?spec=' + encodeURIComponent(suite.getFullName()) }, suite.description));
+    this.suiteDivs[suite.id] = suiteDiv;
+    var parentDiv = this.outerDiv;
+    if (suite.parentSuite) {
+      parentDiv = this.suiteDivs[suite.parentSuite.id];
+    }
+    parentDiv.appendChild(suiteDiv);
+  }
+
+  this.startedAt = new Date();
+
+  var self = this;
+  showPassed.onclick = function(evt) {
+    if (showPassed.checked) {
+      self.outerDiv.className += ' show-passed';
+    } else {
+      self.outerDiv.className = self.outerDiv.className.replace(/ show-passed/, '');
+    }
+  };
+
+  showSkipped.onclick = function(evt) {
+    if (showSkipped.checked) {
+      self.outerDiv.className += ' show-skipped';
+    } else {
+      self.outerDiv.className = self.outerDiv.className.replace(/ show-skipped/, '');
+    }
+  };
+};
+
+jasmine.TrivialReporter.prototype.reportRunnerResults = function(runner) {
+  var results = runner.results();
+  var className = (results.failedCount > 0) ? "runner failed" : "runner passed";
+  this.runnerDiv.setAttribute("class", className);
+  //do it twice for IE
+  this.runnerDiv.setAttribute("className", className);
+  var specs = runner.specs();
+  var specCount = 0;
+  for (var i = 0; i < specs.length; i++) {
+    if (this.specFilter(specs[i])) {
+      specCount++;
+    }
+  }
+  var message = "" + specCount + " spec" + (specCount == 1 ? "" : "s" ) + ", " + results.failedCount + " failure" + ((results.failedCount == 1) ? "" : "s");
+  message += " in " + ((new Date().getTime() - this.startedAt.getTime()) / 1000) + "s";
+  this.runnerMessageSpan.replaceChild(this.createDom('a', { className: 'description', href: '?'}, message), this.runnerMessageSpan.firstChild);
+
+  this.finishedAtSpan.appendChild(document.createTextNode("Finished at " + new Date().toString()));
+};
+
+jasmine.TrivialReporter.prototype.reportSuiteResults = function(suite) {
+  var results = suite.results();
+  var status = results.passed() ? 'passed' : 'failed';
+  if (results.totalCount === 0) { // todo: change this to check results.skipped
+    status = 'skipped';
+  }
+  this.suiteDivs[suite.id].className += " " + status;
+};
+
+jasmine.TrivialReporter.prototype.reportSpecStarting = function(spec) {
+  if (this.logRunningSpecs) {
+    this.log('>> Jasmine Running ' + spec.suite.description + ' ' + spec.description + '...');
+  }
+};
+
+jasmine.TrivialReporter.prototype.reportSpecResults = function(spec) {
+  var results = spec.results();
+  var status = results.passed() ? 'passed' : 'failed';
+  if (results.skipped) {
+    status = 'skipped';
+  }
+  var specDiv = this.createDom('div', { className: 'spec '  + status },
+      this.createDom('a', { className: 'run_spec', href: '?spec=' + encodeURIComponent(spec.getFullName()) }, "run"),
+      this.createDom('a', {
+        className: 'description',
+        href: '?spec=' + encodeURIComponent(spec.getFullName()),
+        title: spec.getFullName()
+      }, spec.description));
+
+
+  var resultItems = results.getItems();
+  var messagesDiv = this.createDom('div', { className: 'messages' });
+  for (var i = 0; i < resultItems.length; i++) {
+    var result = resultItems[i];
+
+    if (result.type == 'log') {
+      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage log'}, result.toString()));
+    } else if (result.type == 'expect' && result.passed && !result.passed()) {
+      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage fail'}, result.message));
+
+      if (result.trace.stack) {
+        messagesDiv.appendChild(this.createDom('div', {className: 'stackTrace'}, result.trace.stack));
+      }
+    }
+  }
+
+  if (messagesDiv.childNodes.length > 0) {
+    specDiv.appendChild(messagesDiv);
+  }
+
+  this.suiteDivs[spec.suite.id].appendChild(specDiv);
+};
+
+jasmine.TrivialReporter.prototype.log = function() {
+  var console = jasmine.getGlobal().console;
+  if (console && console.log) {
+    if (console.log.apply) {
+      console.log.apply(console, arguments);
+    } else {
+      console.log(arguments); // ie fix: console.log.apply doesn't exist on ie
+    }
+  }
+};
+
+jasmine.TrivialReporter.prototype.getLocation = function() {
+  return this.document.location;
+};
+
+jasmine.TrivialReporter.prototype.specFilter = function(spec) {
+  var paramMap = {};
+  var params = this.getLocation().search.substring(1).split('&');
+  for (var i = 0; i < params.length; i++) {
+    var p = params[i].split('=');
+    paramMap[decodeURIComponent(p[0])] = decodeURIComponent(p[1]);
+  }
+
+  if (!paramMap.spec) {
+    return true;
+  }
+  return spec.getFullName().indexOf(paramMap.spec) === 0;
+};

public/bower_components/messenger/docs/welcome/lib/jasmine-1.3.1/jasmine.css

@@ -0,0 +1,82 @@
+body { background-color: #eeeeee; padding: 0; margin: 5px; overflow-y: scroll; }
+
+#HTMLReporter { font-size: 11px; font-family: Monaco, "Lucida Console", monospace; line-height: 14px; color: #333333; }
+#HTMLReporter a { text-decoration: none; }
+#HTMLReporter a:hover { text-decoration: underline; }
+#HTMLReporter p, #HTMLReporter h1, #HTMLReporter h2, #HTMLReporter h3, #HTMLReporter h4, #HTMLReporter h5, #HTMLReporter h6 { margin: 0; line-height: 14px; }
+#HTMLReporter .banner, #HTMLReporter .symbolSummary, #HTMLReporter .summary, #HTMLReporter .resultMessage, #HTMLReporter .specDetail .description, #HTMLReporter .alert .bar, #HTMLReporter .stackTrace { padding-left: 9px; padding-right: 9px; }
+#HTMLReporter #jasmine_content { position: fixed; right: 100%; }
+#HTMLReporter .version { color: #aaaaaa; }
+#HTMLReporter .banner { margin-top: 14px; }
+#HTMLReporter .duration { color: #aaaaaa; float: right; }
+#HTMLReporter .symbolSummary { overflow: hidden; *zoom: 1; margin: 14px 0; }
+#HTMLReporter .symbolSummary li { display: block; float: left; height: 7px; width: 14px; margin-bottom: 7px; font-size: 16px; }
+#HTMLReporter .symbolSummary li.passed { font-size: 14px; }
+#HTMLReporter .symbolSummary li.passed:before { color: #5e7d00; content: "\02022"; }
+#HTMLReporter .symbolSummary li.failed { line-height: 9px; }
+#HTMLReporter .symbolSummary li.failed:before { color: #b03911; content: "x"; font-weight: bold; margin-left: -1px; }
+#HTMLReporter .symbolSummary li.skipped { font-size: 14px; }
+#HTMLReporter .symbolSummary li.skipped:before { color: #bababa; content: "\02022"; }
+#HTMLReporter .symbolSummary li.pending { line-height: 11px; }
+#HTMLReporter .symbolSummary li.pending:before { color: #aaaaaa; content: "-"; }
+#HTMLReporter .exceptions { color: #fff; float: right; margin-top: 5px; margin-right: 5px; }
+#HTMLReporter .bar { line-height: 28px; font-size: 14px; display: block; color: #eee; }
+#HTMLReporter .runningAlert { background-color: #666666; }
+#HTMLReporter .skippedAlert { background-color: #aaaaaa; }
+#HTMLReporter .skippedAlert:first-child { background-color: #333333; }
+#HTMLReporter .skippedAlert:hover { text-decoration: none; color: white; text-decoration: underline; }
+#HTMLReporter .passingAlert { background-color: #a6b779; }
+#HTMLReporter .passingAlert:first-child { background-color: #5e7d00; }
+#HTMLReporter .failingAlert { background-color: #cf867e; }
+#HTMLReporter .failingAlert:first-child { background-color: #b03911; }
+#HTMLReporter .results { margin-top: 14px; }
+#HTMLReporter #details { display: none; }
+#HTMLReporter .resultsMenu, #HTMLReporter .resultsMenu a { background-color: #fff; color: #333333; }
+#HTMLReporter.showDetails .summaryMenuItem { font-weight: normal; text-decoration: inherit; }
+#HTMLReporter.showDetails .summaryMenuItem:hover { text-decoration: underline; }
+#HTMLReporter.showDetails .detailsMenuItem { font-weight: bold; text-decoration: underline; }
+#HTMLReporter.showDetails .summary { display: none; }
+#HTMLReporter.showDetails #details { display: block; }
+#HTMLReporter .summaryMenuItem { font-weight: bold; text-decoration: underline; }
+#HTMLReporter .summary { margin-top: 14px; }
+#HTMLReporter .summary .suite .suite, #HTMLReporter .summary .specSummary { margin-left: 14px; }
+#HTMLReporter .summary .specSummary.passed a { color: #5e7d00; }
+#HTMLReporter .summary .specSummary.failed a { color: #b03911; }
+#HTMLReporter .description + .suite { margin-top: 0; }
+#HTMLReporter .suite { margin-top: 14px; }
+#HTMLReporter .suite a { color: #333333; }
+#HTMLReporter #details .specDetail { margin-bottom: 28px; }
+#HTMLReporter #details .specDetail .description { display: block; color: white; background-color: #b03911; }
+#HTMLReporter .resultMessage { padding-top: 14px; color: #333333; }
+#HTMLReporter .resultMessage span.result { display: block; }
+#HTMLReporter .stackTrace { margin: 5px 0 0 0; max-height: 224px; overflow: auto; line-height: 18px; color: #666666; border: 1px solid #ddd; background: white; white-space: pre; }
+
+#TrivialReporter { padding: 8px 13px; position: absolute; top: 0; bottom: 0; left: 0; right: 0; overflow-y: scroll; background-color: white; font-family: "Helvetica Neue Light", "Lucida Grande", "Calibri", "Arial", sans-serif; /*.resultMessage {*/ /*white-space: pre;*/ /*}*/ }
+#TrivialReporter a:visited, #TrivialReporter a { color: #303; }
+#TrivialReporter a:hover, #TrivialReporter a:active { color: blue; }
+#TrivialReporter .run_spec { float: right; padding-right: 5px; font-size: .8em; text-decoration: none; }
+#TrivialReporter .banner { color: #303; background-color: #fef; padding: 5px; }
+#TrivialReporter .logo { float: left; font-size: 1.1em; padding-left: 5px; }
+#TrivialReporter .logo .version { font-size: .6em; padding-left: 1em; }
+#TrivialReporter .runner.running { background-color: yellow; }
+#TrivialReporter .options { text-align: right; font-size: .8em; }
+#TrivialReporter .suite { border: 1px outset gray; margin: 5px 0; padding-left: 1em; }
+#TrivialReporter .suite .suite { margin: 5px; }
+#TrivialReporter .suite.passed { background-color: #dfd; }
+#TrivialReporter .suite.failed { background-color: #fdd; }
+#TrivialReporter .spec { margin: 5px; padding-left: 1em; clear: both; }
+#TrivialReporter .spec.failed, #TrivialReporter .spec.passed, #TrivialReporter .spec.skipped { padding-bottom: 5px; border: 1px solid gray; }
+#TrivialReporter .spec.failed { background-color: #fbb; border-color: red; }
+#TrivialReporter .spec.passed { background-color: #bfb; border-color: green; }
+#TrivialReporter .spec.skipped { background-color: #bbb; }
+#TrivialReporter .messages { border-left: 1px dashed gray; padding-left: 1em; padding-right: 1em; }
+#TrivialReporter .passed { background-color: #cfc; display: none; }
+#TrivialReporter .failed { background-color: #fbb; }
+#TrivialReporter .skipped { color: #777; background-color: #eee; display: none; }
+#TrivialReporter .resultMessage span.result { display: block; line-height: 2em; color: black; }
+#TrivialReporter .resultMessage .mismatch { color: black; }
+#TrivialReporter .stackTrace { white-space: pre; font-size: .8em; margin-left: 10px; max-height: 5em; overflow: auto; border: 1px inset red; padding: 1em; background: #eef; }
+#TrivialReporter .finished-at { padding-left: 1em; font-size: .6em; }
+#TrivialReporter.show-passed .passed, #TrivialReporter.show-skipped .skipped { display: block; }
+#TrivialReporter #jasmine_content { position: fixed; right: 100%; }
+#TrivialReporter .runner { border: 1px solid gray; display: block; margin: 5px 0; padding: 2px 0 2px 10px; }

public/bower_components/messenger/docs/welcome/lib/licenses/backbone

@@ -0,0 +1,22 @@
+Copyright (c) 2010-2013 Jeremy Ashkenas, DocumentCloud
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

public/bower_components/messenger/docs/welcome/lib/licenses/jasmine

@@ -0,0 +1,20 @@
+Copyright (c) 2008-2011 Pivotal Labs
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

public/bower_components/messenger/docs/welcome/lib/licenses/sinon

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

public/bower_components/messenger/docs/welcome/lib/licenses/underscore

@@ -0,0 +1,22 @@
+Copyright (c) 2009-2013 Jeremy Ashkenas, DocumentCloud
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

public/bower_components/messenger/docs/welcome/lib/shims.js

@@ -0,0 +1,276 @@
+/*
+ * This file contains shims for when Underscore and Backbone
+ * are not included.
+ *
+ * Portions taken from Underscore.js and Backbone.js
+ * Both of which are Copyright (c) 2009-2013 Jeremy Ashkenas, DocumentCloud
+ */
+window.Messenger._ = (function() {
+    if (window._)
+        return window._
+
+    var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;
+
+    // Create quick reference variables for speed access to core prototypes.
+    var push             = ArrayProto.push,
+            slice            = ArrayProto.slice,
+            concat           = ArrayProto.concat,
+            toString         = ObjProto.toString,
+            hasOwnProperty   = ObjProto.hasOwnProperty;
+
+    // All **ECMAScript 5** native function implementations that we hope to use
+    // are declared here.
+    var
+        nativeForEach      = ArrayProto.forEach,
+        nativeMap          = ArrayProto.map,
+        nativeReduce       = ArrayProto.reduce,
+        nativeReduceRight  = ArrayProto.reduceRight,
+        nativeFilter       = ArrayProto.filter,
+        nativeEvery        = ArrayProto.every,
+        nativeSome         = ArrayProto.some,
+        nativeIndexOf      = ArrayProto.indexOf,
+        nativeLastIndexOf  = ArrayProto.lastIndexOf,
+        nativeIsArray      = Array.isArray,
+        nativeKeys         = Object.keys,
+        nativeBind         = FuncProto.bind;
+
+    // Create a safe reference to the Underscore object for use below.
+    var _ = {};
+
+    // Establish the object that gets returned to break out of a loop iteration.
+    var breaker = {};
+  
+    var each = _.each = _.forEach = function(obj, iterator, context) {
+        if (obj == null) return;
+        if (nativeForEach && obj.forEach === nativeForEach) {
+            obj.forEach(iterator, context);
+        } else if (obj.length === +obj.length) {
+            for (var i = 0, l = obj.length; i < l; i++) {
+                if (iterator.call(context, obj[i], i, obj) === breaker) return;
+            }
+        } else {
+            for (var key in obj) {
+                if (_.has(obj, key)) {
+                    if (iterator.call(context, obj[key], key, obj) === breaker) return;
+                }
+            }
+        }
+    };
+
+    _.result = function(object, property) {
+        if (object == null) return null;
+        var value = object[property];
+        return _.isFunction(value) ? value.call(object) : value;
+    };
+
+    _.once = function(func) {
+        var ran = false, memo;
+        return function() {
+            if (ran) return memo;
+            ran = true;
+            memo = func.apply(this, arguments);
+            func = null;
+            return memo;
+        };
+    };
+
+    var idCounter = 0;
+    _.uniqueId = function(prefix) {
+        var id = ++idCounter + '';
+        return prefix ? prefix + id : id;
+    };
+
+    _.filter = _.select = function(obj, iterator, context) {
+        var results = [];
+        if (obj == null) return results;
+        if (nativeFilter && obj.filter === nativeFilter) return obj.filter(iterator, context);
+        each(obj, function(value, index, list) {
+            if (iterator.call(context, value, index, list)) results[results.length] = value;
+        });
+        return results;
+    };
+
+    // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp.
+    each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], function(name) {
+        _['is' + name] = function(obj) {
+            return toString.call(obj) == '[object ' + name + ']';
+        };
+    });
+
+    _.defaults = function(obj) {
+        each(slice.call(arguments, 1), function(source) {
+            if (source) {
+                for (var prop in source) {
+                    if (obj[prop] == null) obj[prop] = source[prop];
+                }
+            }
+        });
+        return obj;
+    };
+
+    _.extend = function(obj) {
+        each(slice.call(arguments, 1), function(source) {
+            if (source) {
+                for (var prop in source) {
+                    obj[prop] = source[prop];
+                }
+            }
+        });
+        return obj;
+    };
+
+    _.keys = nativeKeys || function(obj) {
+        if (obj !== Object(obj)) throw new TypeError('Invalid object');
+        var keys = [];
+        for (var key in obj) if (_.has(obj, key)) keys[keys.length] = key;
+        return keys;
+    };
+
+    _.bind = function(func, context) {
+        if (func.bind === nativeBind && nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
+        var args = slice.call(arguments, 2);
+        return function() {
+            return func.apply(context, args.concat(slice.call(arguments)));
+        };
+    };
+
+    _.isObject = function(obj) {
+        return obj === Object(obj);
+    };
+
+    return _;
+})();
+
+window.Messenger.Events = (function() {
+    if (window.Backbone && Backbone.Events) {
+        return Backbone.Events;
+    }
+
+    var eventsShim = function() {
+        var eventSplitter = /\s+/;
+
+        var eventsApi = function(obj, action, name, rest) {
+            if (!name) return true;
+            if (typeof name === 'object') {
+                for (var key in name) {
+                    obj[action].apply(obj, [key, name[key]].concat(rest));
+                }
+            } else if (eventSplitter.test(name)) {
+                var names = name.split(eventSplitter);
+                for (var i = 0, l = names.length; i < l; i++) {
+                    obj[action].apply(obj, [names[i]].concat(rest));
+                }
+            } else {
+                return true;
+            }
+        };
+
+        var triggerEvents = function(events, args) {
+            var ev, i = -1, l = events.length;
+            switch (args.length) {
+            case 0: while (++i < l) (ev = events[i]).callback.call(ev.ctx);
+            return;
+            case 1: while (++i < l) (ev = events[i]).callback.call(ev.ctx, args[0]);
+            return;
+            case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, args[0], args[1]);
+            return;
+            case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, args[0], args[1], args[2]);
+            return;
+            default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args);
+            }
+        };
+
+        var Events = {
+
+            on: function(name, callback, context) {
+                if (!(eventsApi(this, 'on', name, [callback, context]) && callback)) return this;
+                this._events || (this._events = {});
+                var list = this._events[name] || (this._events[name] = []);
+                list.push({callback: callback, context: context, ctx: context || this});
+                return this;
+            },
+
+            once: function(name, callback, context) {
+                if (!(eventsApi(this, 'once', name, [callback, context]) && callback)) return this;
+                var self = this;
+                var once = _.once(function() {
+                    self.off(name, once);
+                    callback.apply(this, arguments);
+                });
+                once._callback = callback;
+                this.on(name, once, context);
+                return this;
+            },
+
+            off: function(name, callback, context) {
+                var list, ev, events, names, i, l, j, k;
+                if (!this._events || !eventsApi(this, 'off', name, [callback, context])) return this;
+                if (!name && !callback && !context) {
+                    this._events = {};
+                    return this;
+                }
+
+                names = name ? [name] : _.keys(this._events);
+                for (i = 0, l = names.length; i < l; i++) {
+                    name = names[i];
+                    if (list = this._events[name]) {
+                        events = [];
+                        if (callback || context) {
+                            for (j = 0, k = list.length; j < k; j++) {
+                                ev = list[j];
+                                if ((callback && callback !== ev.callback &&
+                                                                 callback !== ev.callback._callback) ||
+                                        (context && context !== ev.context)) {
+                                    events.push(ev);
+                                }
+                            }
+                        }
+                        this._events[name] = events;
+                    }
+                }
+
+                return this;
+            },
+
+            trigger: function(name) {
+                if (!this._events) return this;
+                var args = Array.prototype.slice.call(arguments, 1);
+                if (!eventsApi(this, 'trigger', name, args)) return this;
+                var events = this._events[name];
+                var allEvents = this._events.all;
+                if (events) triggerEvents(events, args);
+                if (allEvents) triggerEvents(allEvents, arguments);
+                return this;
+            },
+
+            listenTo: function(obj, name, callback) {
+                var listeners = this._listeners || (this._listeners = {});
+                var id = obj._listenerId || (obj._listenerId = _.uniqueId('l'));
+                listeners[id] = obj;
+                obj.on(name, typeof name === 'object' ? this : callback, this);
+                return this;
+            },
+
+            stopListening: function(obj, name, callback) {
+                var listeners = this._listeners;
+                if (!listeners) return;
+                if (obj) {
+                    obj.off(name, typeof name === 'object' ? this : callback, this);
+                    if (!name && !callback) delete listeners[obj._listenerId];
+                } else {
+                    if (typeof name === 'object') callback = this;
+                    for (var id in listeners) {
+                        listeners[id].off(name, callback, this);
+                    }
+                    this._listeners = {};
+                }
+                return this;
+            }
+        };
+
+        Events.bind   = Events.on;
+        Events.unbind = Events.off;
+        return Events;
+    };
+    return eventsShim();
+})();

public/bower_components/messenger/docs/welcome/stylesheets/demo.css

@@ -0,0 +1,64 @@
+body {
+  font-family: "Helvetica Neue", sans-serif;
+}
+
+.social {
+  position: absolute;
+  top: 10px;
+}
+
+h2 .subtitle {
+  font-size: 14px;
+}
+
+.highlight .c1 {
+  font-size: 12px;
+}
+
+.controls {
+  margin-bottom: 20px;
+}
+
+.controls > div {
+  margin: 0 40px;
+  float: left;
+}
+
+.controls h4 {
+  text-align: center;
+}
+
+.clear {
+  clear: both;
+  height: 0;
+  margin: 0;
+  margin-bottom: 15px;
+  border-width: 0;
+}
+
+pre {
+  display: block;
+  padding: 9.5px;
+  margin: 0 0 10px;
+  font-size: 13px;
+  line-height: 20px;
+  word-break: break-all;
+  word-wrap: break-word;
+  white-space: pre;
+  white-space: pre-wrap;
+  background-color: #f5f5f5;
+  border: 1px solid #ccc;
+  border: 1px solid rgba(0,0,0,0.15);
+  -webkit-border-radius: 4px;
+  -moz-border-radius: 4px;
+  border-radius: 4px;
+}
+
+pre code {
+  padding: 0;
+  color: inherit;
+  white-space: pre;
+  white-space: pre-wrap;
+  background-color: transparent;
+  border: 0;
+}

public/bower_components/messenger/docs/welcome/stylesheets/location-sel.css

@@ -0,0 +1,28 @@
+.location-selector {
+  width: 140px;
+  height: 100px;
+  background-color: #eeeeee;
+  position: relative; }
+  .location-selector .bit {
+    background-color: #dddddd;
+    cursor: pointer;
+    position: absolute; }
+    .location-selector .bit:hover {
+      background-color: #cccccc; }
+    .location-selector .bit.top, .location-selector .bit.bottom {
+      height: 25%;
+      width: 40%;
+      margin: 0 30%; }
+    .location-selector .bit.top {
+      top: 0; }
+    .location-selector .bit.bottom {
+      bottom: 0; }
+    .location-selector .bit.right, .location-selector .bit.left {
+      height: 20%;
+      width: 20%;
+      margin-left: 0;
+      margin-right: 0; }
+    .location-selector .bit.right {
+      right: 0; }
+    .location-selector .bit.left {
+      left: 0; }

public/bower_components/messenger/docs/welcome/stylesheets/location-sel.sass

@@ -0,0 +1,56 @@
+.location-selector  
+  width: 140px
+  height: 100px
+  background-color: #EEE
+  position: relative
+
+  .bit
+    background-color: #DDD
+    opacity: 0.8
+    cursor: pointer
+
+    position: absolute 
+
+    &:hover
+      background-color: #CCC
+
+    &.top, &.bottom
+      height: 25%
+      width: 40%
+      margin: 0 30%
+
+    &.top
+      top: 0
+
+    &.bottom
+      bottom: 0
+
+    &.right, &.left
+      height: 20%
+      width: 20%
+      margin:
+        left: 0
+        right: 0
+
+    &.right
+      right: 0
+  
+    &.left
+      left: 0
+
+
+  &.top
+    .bit.top
+       opacity: 1
+
+  &.bottom
+    .bit.bottom
+      opacity: 1
+
+  &.left
+    .bit:not(.left)
+      opacity: 0.8
+
+  &.right
+    .bit:not(.right)
+      opacity: 0.8

public/bower_components/messenger/docs/welcome/stylesheets/pygment_trac.css

@@ -0,0 +1,70 @@
+.highlight .hll { background-color: #ffffcc }
+.highlight  { background: #f0f3f3; }
+.highlight .c { color: #0099FF; font-style: italic } /* Comment */
+.highlight .err { color: #AA0000; background-color: #FFAAAA } /* Error */
+.highlight .k { color: #006699; font-weight: bold } /* Keyword */
+.highlight .o { color: #555555 } /* Operator */
+.highlight .cm { color: #0099FF; font-style: italic } /* Comment.Multiline */
+.highlight .cp { color: #009999 } /* Comment.Preproc */
+.highlight .c1 { color: #0099FF; font-style: italic } /* Comment.Single */
+.highlight .cs { color: #0099FF; font-weight: bold; font-style: italic } /* Comment.Special */
+.highlight .gd { background-color: #FFCCCC; border: 1px solid #CC0000 } /* Generic.Deleted */
+.highlight .ge { font-style: italic } /* Generic.Emph */
+.highlight .gr { color: #FF0000 } /* Generic.Error */
+.highlight .gh { color: #003300; font-weight: bold } /* Generic.Heading */
+.highlight .gi { background-color: #CCFFCC; border: 1px solid #00CC00 } /* Generic.Inserted */
+.highlight .go { color: #AAAAAA } /* Generic.Output */
+.highlight .gp { color: #000099; font-weight: bold } /* Generic.Prompt */
+.highlight .gs { font-weight: bold } /* Generic.Strong */
+.highlight .gu { color: #003300; font-weight: bold } /* Generic.Subheading */
+.highlight .gt { color: #99CC66 } /* Generic.Traceback */
+.highlight .kc { color: #006699; font-weight: bold } /* Keyword.Constant */
+.highlight .kd { color: #006699; font-weight: bold } /* Keyword.Declaration */
+.highlight .kn { color: #006699; font-weight: bold } /* Keyword.Namespace */
+.highlight .kp { color: #006699 } /* Keyword.Pseudo */
+.highlight .kr { color: #006699; font-weight: bold } /* Keyword.Reserved */
+.highlight .kt { color: #007788; font-weight: bold } /* Keyword.Type */
+.highlight .m { color: #FF6600 } /* Literal.Number */
+.highlight .s { color: #CC3300 } /* Literal.String */
+.highlight .na { color: #330099 } /* Name.Attribute */
+.highlight .nb { color: #336666 } /* Name.Builtin */
+.highlight .nc { color: #00AA88; font-weight: bold } /* Name.Class */
+.highlight .no { color: #336600 } /* Name.Constant */
+.highlight .nd { color: #9999FF } /* Name.Decorator */
+.highlight .ni { color: #999999; font-weight: bold } /* Name.Entity */
+.highlight .ne { color: #CC0000; font-weight: bold } /* Name.Exception */
+.highlight .nf { color: #CC00FF } /* Name.Function */
+.highlight .nl { color: #9999FF } /* Name.Label */
+.highlight .nn { color: #00CCFF; font-weight: bold } /* Name.Namespace */
+.highlight .nt { color: #330099; font-weight: bold } /* Name.Tag */
+.highlight .nv { color: #003333 } /* Name.Variable */
+.highlight .ow { color: #000000; font-weight: bold } /* Operator.Word */
+.highlight .w { color: #bbbbbb } /* Text.Whitespace */
+.highlight .mf { color: #FF6600 } /* Literal.Number.Float */
+.highlight .mh { color: #FF6600 } /* Literal.Number.Hex */
+.highlight .mi { color: #FF6600 } /* Literal.Number.Integer */
+.highlight .mo { color: #FF6600 } /* Literal.Number.Oct */
+.highlight .sb { color: #CC3300 } /* Literal.String.Backtick */
+.highlight .sc { color: #CC3300 } /* Literal.String.Char */
+.highlight .sd { color: #CC3300; font-style: italic } /* Literal.String.Doc */
+.highlight .s2 { color: #CC3300 } /* Literal.String.Double */
+.highlight .se { color: #CC3300; font-weight: bold } /* Literal.String.Escape */
+.highlight .sh { color: #CC3300 } /* Literal.String.Heredoc */
+.highlight .si { color: #AA0000 } /* Literal.String.Interpol */
+.highlight .sx { color: #CC3300 } /* Literal.String.Other */
+.highlight .sr { color: #33AAAA } /* Literal.String.Regex */
+.highlight .s1 { color: #CC3300 } /* Literal.String.Single */
+.highlight .ss { color: #FFCC33 } /* Literal.String.Symbol */
+.highlight .bp { color: #336666 } /* Name.Builtin.Pseudo */
+.highlight .vc { color: #003333 } /* Name.Variable.Class */
+.highlight .vg { color: #003333 } /* Name.Variable.Global */
+.highlight .vi { color: #003333 } /* Name.Variable.Instance */
+.highlight .il { color: #FF6600 } /* Literal.Number.Integer.Long */
+
+.type-csharp .highlight .k { color: #0000FF }
+.type-csharp .highlight .kt { color: #0000FF }
+.type-csharp .highlight .nf { color: #000000; font-weight: normal }
+.type-csharp .highlight .nc { color: #2B91AF }
+.type-csharp .highlight .nn { color: #000000 }
+.type-csharp .highlight .s { color: #A31515 }
+.type-csharp .highlight .sc { color: #A31515 }

public/bower_components/messenger/docs/welcome/stylesheets/stylesheet.css

@@ -0,0 +1,429 @@
+/*******************************************************************************
+Slate Theme for GitHub Pages
+by Jason Costello, @jsncostello
+*******************************************************************************/
+
+@import url(pygment_trac.css);
+
+/*******************************************************************************
+MeyerWeb Reset
+*******************************************************************************/
+
+html, body, div, span, applet, object, iframe,
+h1, h2, h3, h4, h5, h6, p, blockquote, pre,
+a, abbr, acronym, address, big, cite, code,
+del, dfn, em, img, ins, kbd, q, s, samp,
+small, strike, strong, sub, sup, tt, var,
+b, u, i, center,
+dl, dt, dd, ol, ul, li,
+fieldset, form, label, legend,
+table, caption, tbody, tfoot, thead, tr, th, td,
+article, aside, canvas, details, embed,
+figure, figcaption, footer, header, hgroup,
+menu, nav, output, ruby, section, summary,
+time, mark, audio, video {
+  margin: 0;
+  padding: 0;
+  border: 0;
+  font: inherit;
+  vertical-align: baseline;
+}
+
+/* HTML5 display-role reset for older browsers */
+article, aside, details, figcaption, figure,
+footer, header, hgroup, menu, nav, section {
+  display: block;
+}
+
+ol, ul {
+  list-style: none;
+}
+
+blockquote, q {
+}
+
+table {
+  border-collapse: collapse;
+  border-spacing: 0;
+}
+
+a:focus {
+  outline: none;
+}
+
+/*******************************************************************************
+Theme Styles
+*******************************************************************************/
+
+body {
+  box-sizing: border-box;
+  color:#373737;
+  background: #212121;
+  font-size: 16px;
+  line-height: 1.5;
+  -webkit-font-smoothing: antialiased;
+}
+
+h1, h2, h3, h4, h5, h6 {
+  margin: 10px 0;
+  font-weight: 700;
+  color:#222222;
+  letter-spacing: -1px;
+}
+
+h1 {
+  font-size: 36px;
+  font-weight: 700;
+}
+
+h2 {
+  padding-bottom: 10px;
+  font-size: 32px;
+  background: url('../images/bg_hr.png') repeat-x bottom;
+}
+
+h3 {
+  font-size: 24px;
+}
+
+h4 {
+  font-size: 21px;
+}
+
+h5 {
+  font-size: 18px;
+}
+
+h6 {
+  font-size: 16px;
+}
+
+p {
+  margin: 10px 0 15px 0;
+}
+
+footer p {
+  color: #f2f2f2;
+}
+
+a {
+  text-decoration: none;
+  color: #007edf;
+  text-shadow: none;
+
+  transition: color 0.5s ease;
+  transition: text-shadow 0.5s ease;
+  -webkit-transition: color 0.5s ease;
+  -webkit-transition: text-shadow 0.5s ease;
+  -moz-transition: color 0.5s ease;
+  -moz-transition: text-shadow 0.5s ease;
+  -o-transition: color 0.5s ease;
+  -o-transition: text-shadow 0.5s ease;
+  -ms-transition: color 0.5s ease;
+  -ms-transition: text-shadow 0.5s ease;
+}
+
+#main_content a:hover {
+  color: #0069ba;
+  text-shadow: #0090ff 0px 0px 2px;
+}
+
+footer a:hover {
+  color: #43adff;
+  text-shadow: #0090ff 0px 0px 2px;
+}
+
+em {
+  font-style: italic;
+}
+
+strong {
+  font-weight: bold;
+}
+
+img {
+  position: relative;
+  margin: 0 auto;
+  max-width: 739px;
+  padding: 5px;
+  margin: 10px 0 10px 0;
+  border: 1px solid #ebebeb;
+
+  box-shadow: 0 0 5px #ebebeb;
+  -webkit-box-shadow: 0 0 5px #ebebeb;
+  -moz-box-shadow: 0 0 5px #ebebeb;
+  -o-box-shadow: 0 0 5px #ebebeb;
+  -ms-box-shadow: 0 0 5px #ebebeb;
+}
+
+pre, code {
+  width: 100%;
+  color: #222;
+  background-color: #fff;
+
+  font-family: Monaco, "Bitstream Vera Sans Mono", "Lucida Console", Terminal, monospace;
+  font-size: 14px;
+
+  border-radius: 2px;
+  -moz-border-radius: 2px;
+  -webkit-border-radius: 2px;
+}
+
+pre {
+  width: 100%;
+  -webkit-box-sizing: border-box;
+  -moz-box-sizing: border-box;
+  box-sizing: border-box;
+  padding: 10px;
+  box-shadow: 0 0 10px rgba(0,0,0,.1);
+  overflow: auto;
+}
+
+code {
+  padding: 3px;
+  margin: 0 3px;
+  box-shadow: 0 0 10px rgba(0,0,0,.1);
+}
+
+pre code {
+  display: block;
+  box-shadow: none;
+}
+
+blockquote {
+  color: #666;
+  margin-bottom: 20px;
+  padding: 0 0 0 20px;
+  border-left: 3px solid #bbb;
+}
+
+ul, ol, dl {
+  margin-bottom: 15px
+}
+
+ul li {
+  list-style: inside;
+  padding-left: 20px;
+}
+
+ol li {
+  list-style: decimal inside;
+  padding-left: 20px;
+}
+
+dl dt {
+  font-weight: bold;
+}
+
+dl dd {
+  padding-left: 20px;
+  font-style: italic;
+}
+
+dl p {
+  padding-left: 20px;
+  font-style: italic;
+}
+
+hr {
+  height: 1px;
+  margin-bottom: 5px;
+  border: none;
+  background: url('../images/bg_hr.png') repeat-x center;
+}
+
+table {
+  border: 1px solid #373737;
+  margin-bottom: 20px;
+  text-align: left;
+ }
+
+th {
+  font-family: 'Lucida Grande', 'Helvetica Neue', Helvetica, Arial, sans-serif;
+  padding: 10px;
+  background: #373737;
+  color: #fff;
+ }
+
+td {
+  padding: 10px;
+  border: 1px solid #373737;
+ }
+
+form {
+  background: #f2f2f2;
+  padding: 20px;
+}
+
+img {
+  width: 100%;
+  max-width: 100%;
+}
+
+/*******************************************************************************
+Full-Width Styles
+*******************************************************************************/
+
+.outer {
+  width: 100%;
+}
+
+.inner {
+  position: relative;
+  max-width: 640px;
+  padding: 20px 10px;
+  margin: 0 auto;
+}
+
+#forkme_banner {
+  display: block;
+  position: absolute;
+  top:0;
+  right: 10px;
+  z-index: 10;
+  padding: 10px 50px 10px 10px;
+  color: #fff;
+  background: url('../images/blacktocat.png') #0090ff no-repeat 95% 50%;
+  font-weight: 700;
+  box-shadow: 0 0 10px rgba(0,0,0,.5);
+  border-bottom-left-radius: 2px;
+  border-bottom-right-radius: 2px;
+}
+
+#header_wrap {
+  background: #212121;
+  background: -moz-linear-gradient(top, #373737, #212121);
+  background: -webkit-linear-gradient(top, #373737, #212121);
+  background: -ms-linear-gradient(top, #373737, #212121);
+  background: -o-linear-gradient(top, #373737, #212121);
+  background: linear-gradient(top, #373737, #212121);
+}
+
+#header_wrap .inner {
+  padding: 50px 10px 30px 10px;
+}
+
+#project_title {
+  margin: 0;
+  color: #fff;
+  font-size: 42px;
+  font-weight: 700;
+  text-shadow: #111 0px 0px 10px;
+}
+
+#project_tagline {
+  color: #fff;
+  font-size: 24px;
+  font-weight: 300;
+  background: none;
+  text-shadow: #111 0px 0px 10px;
+}
+
+#downloads {
+  position: absolute;
+  width: 210px;
+  z-index: 10;
+  bottom: -40px;
+  right: 0;
+  height: 70px;
+  background: url('../images/icon_download.png') no-repeat 0% 90%;
+}
+
+.zip_download_link {
+  display: block;
+  float: right;
+  width: 90px;
+  height:70px;
+  text-indent: -5000px;
+  overflow: hidden;
+  background: url(../images/sprite_download.png) no-repeat bottom left;
+}
+
+.tar_download_link {
+  display: block;
+  float: right;
+  width: 90px;
+  height:70px;
+  text-indent: -5000px;
+  overflow: hidden;
+  background: url(../images/sprite_download.png) no-repeat bottom right;
+  margin-left: 10px;
+}
+
+.zip_download_link:hover {
+  background: url(../images/sprite_download.png) no-repeat top left;
+}
+
+.tar_download_link:hover {
+  background: url(../images/sprite_download.png) no-repeat top right;
+}
+
+#main_content_wrap {
+  background: #fff;
+  border-top: 1px solid #111;
+  border-bottom: 1px solid #111;
+}
+
+#main_content {
+  padding-top: 40px;
+}
+
+#footer_wrap {
+  background: #212121;
+}
+
+
+
+/*******************************************************************************
+Small Device Styles
+*******************************************************************************/
+
+@media screen and (max-width: 480px) {
+  body {
+    font-size:14px;
+  }
+
+  #downloads {
+    display: none;
+  }
+
+  .inner {
+    min-width: 320px;
+    max-width: 480px;
+  }
+
+  #project_title {
+  font-size: 32px;
+  }
+
+  h1 {
+    font-size: 28px;
+  }
+
+  h2 {
+    font-size: 24px;
+  }
+
+  h3 {
+    font-size: 21px;
+  }
+
+  h4 {
+    font-size: 18px;
+  }
+
+  h5 {
+    font-size: 14px;
+  }
+
+  h6 {
+    font-size: 12px;
+  }
+
+  code, pre {
+    min-width: 320px;
+    max-width: 480px;
+    font-size: 11px;
+  }
+
+}

public/bower_components/messenger/docs/welcome/stylesheets/theme-sel.css

@@ -0,0 +1,8 @@
+.theme-selector, .selector {
+  margin: 0; }
+  .theme-selector li, .selector li {
+    list-style-type: none;
+    color: #43adff;
+    text-decoration: underline;
+    cursor: pointer;
+    text-transform: capitalize; }

public/bower_components/messenger/docs/welcome/stylesheets/theme-sel.sass

@@ -0,0 +1,10 @@
+.theme-selector,
+.selector
+  margin: 0
+
+  li
+    list-style-type: none
+    color: #43ADFF
+    text-decoration: underline
+    cursor: pointer
+    text-transform: capitalize