Publish Vulpes Preview 15 sources for desktop, Android and Tundra

Share Gaia assets and adapters, keep private profiles and development documents local, and update both public READMEs.

assets/webapps/test-agent.gaiamobile.org/common/vendor/blanket/test-agent-blanket.js

@@ -0,0 +1,72 @@
+(function() {
+
+    if (!mocha) {
+        throw new Exception("mocha library does not exist in global namespace!");
+    }
+
+    /*
+     * Mocha Events:
+     *
+     *   - `start`  execution started
+     *   - `end`  execution complete
+     *   - `suite`  (suite) test suite execution started
+     *   - `suite end`  (suite) all tests (and sub-suites) have finished
+     *   - `test`  (test) test execution started
+     *   - `test end`  (test) test completed
+     *   - `hook`  (hook) hook execution started
+     *   - `hook end`  (hook) hook complete
+     *   - `pass`  (test) test passed
+     *   - `fail`  (test, err) test failed
+     *
+     */
+
+    var OriginalReporter = mocha._reporter;
+
+    var BlanketReporter = function(runner) {
+        runner.on('start', function() {
+            blanket.setupCoverage();
+        });
+
+        runner.on('end', function() {
+            blanket.onTestsDone();
+        });
+
+        runner.on('suite', function() {
+            blanket.onModuleStart();
+        });
+
+        runner.on('test', function() {
+            blanket.onTestStart();
+        });
+
+        runner.on('test end', function(test) {
+            blanket.onTestDone(test.parent.tests.length, test.state === 'passed');
+        });
+
+        // NOTE: this is an instance of BlanketReporter
+        OriginalReporter.apply(this, arguments);
+    };
+
+    mocha.reporter(BlanketReporter);
+
+    var oldRun = mocha.run,
+        oldCallback = null;
+
+    mocha.run = function(finishCallback) {
+        oldCallback = finishCallback;
+        console.log("waiting for blanket...");
+    };
+
+    blanket.beforeStartTestRunner({
+        callback: function() {
+            if (!blanket.options("existingRequireJS")) {
+                oldRun(oldCallback);
+            }
+            mocha.run = oldRun;
+        },
+        bindEvent: function(startEvent) {
+            window.addEventListener("mocha-run", startEvent, false);
+        }
+    });
+
+})();

assets/webapps/test-agent.gaiamobile.org/common/vendor/chai/chai-as-promised.js

@@ -0,0 +1,370 @@
+(function () {
+    "use strict";
+
+    // Module systems magic dance.
+
+    /* istanbul ignore else */
+    if (typeof require === "function" && typeof exports === "object" && typeof module === "object") {
+        // NodeJS
+        module.exports = chaiAsPromised;
+    } else if (typeof define === "function" && define.amd) {
+        // AMD
+        define(function () {
+            return chaiAsPromised;
+        });
+    } else {
+        /*global self: false */
+
+        // Other environment (usually <script> tag): plug in to global chai instance directly.
+        chai.use(chaiAsPromised);
+
+        // Expose as a property of the global object so that consumers can configure the `transferPromiseness` property.
+        self.chaiAsPromised = chaiAsPromised;
+    }
+
+    chaiAsPromised.transferPromiseness = function (assertion, promise) {
+        assertion.then = promise.then.bind(promise);
+    };
+
+    function chaiAsPromised(chai, utils) {
+        var Assertion = chai.Assertion;
+        var assert = chai.assert;
+
+        function isJQueryPromise(thenable) {
+            return typeof thenable.always === "function" &&
+                   typeof thenable.done === "function" &&
+                   typeof thenable.fail === "function" &&
+                   typeof thenable.pipe === "function" &&
+                   typeof thenable.progress === "function" &&
+                   typeof thenable.state === "function";
+        }
+
+        function assertIsAboutPromise(assertion) {
+            if (typeof assertion._obj.then !== "function") {
+                throw new TypeError(utils.inspect(assertion._obj) + " is not a thenable.");
+            }
+            if (isJQueryPromise(assertion._obj)) {
+                throw new TypeError("Chai as Promised is incompatible with jQuery's thenables, sorry! Please use a " +
+                                    "Promises/A+ compatible library (see http://promisesaplus.com/).");
+            }
+        }
+
+        function method(name, asserter) {
+            utils.addMethod(Assertion.prototype, name, function () {
+                assertIsAboutPromise(this);
+                return asserter.apply(this, arguments);
+            });
+        }
+
+        function property(name, asserter) {
+            utils.addProperty(Assertion.prototype, name, function () {
+                assertIsAboutPromise(this);
+                return asserter.apply(this, arguments);
+            });
+        }
+
+        function doNotify(promise, done) {
+            promise.then(function () { done(); }, done);
+        }
+
+        // These are for clarity and to bypass Chai refusing to allow `undefined` as actual when used with `assert`.
+        function assertIfNegated(assertion, message, extra) {
+            assertion.assert(true, null, message, extra.expected, extra.actual);
+        }
+
+        function assertIfNotNegated(assertion, message, extra) {
+            assertion.assert(false, message, null, extra.expected, extra.actual);
+        }
+
+        function getBasePromise(assertion) {
+            // We need to chain subsequent asserters on top of ones in the chain already (consider
+            // `eventually.have.property("foo").that.equals("bar")`), only running them after the existing ones pass.
+            // So the first base-promise is `assertion._obj`, but after that we use the assertions themselves, i.e.
+            // previously derived promises, to chain off of.
+            return typeof assertion.then === "function" ? assertion : assertion._obj;
+        }
+
+        // Grab these first, before we modify `Assertion.prototype`.
+
+        var propertyNames = Object.getOwnPropertyNames(Assertion.prototype);
+
+        var propertyDescs = {};
+        propertyNames.forEach(function (name) {
+            propertyDescs[name] = Object.getOwnPropertyDescriptor(Assertion.prototype, name);
+        });
+
+        property("fulfilled", function () {
+            var that = this;
+            var derivedPromise = getBasePromise(that).then(
+                function (value) {
+                    that._obj = value;
+                    assertIfNegated(that,
+                                    "expected promise not to be fulfilled but it was fulfilled with #{act}",
+                                    { actual: value });
+                    return value;
+                },
+                function (reason) {
+                    assertIfNotNegated(that,
+                                       "expected promise to be fulfilled but it was rejected with #{act}",
+                                       { actual: reason });
+                }
+            );
+
+            chaiAsPromised.transferPromiseness(that, derivedPromise);
+        });
+
+        property("rejected", function () {
+            var that = this;
+            var derivedPromise = getBasePromise(that).then(
+                function (value) {
+                    that._obj = value;
+                    assertIfNotNegated(that,
+                                       "expected promise to be rejected but it was fulfilled with #{act}",
+                                       { actual: value });
+                    return value;
+                },
+                function (reason) {
+                    assertIfNegated(that,
+                                    "expected promise not to be rejected but it was rejected with #{act}",
+                                    { actual: reason });
+
+                    // Return the reason, transforming this into a fulfillment, to allow further assertions, e.g.
+                    // `promise.should.be.rejected.and.eventually.equal("reason")`.
+                    return reason;
+                }
+            );
+
+            chaiAsPromised.transferPromiseness(that, derivedPromise);
+        });
+
+        method("rejectedWith", function (Constructor, message) {
+            var desiredReason = null;
+            var constructorName = null;
+
+            if (Constructor instanceof RegExp || typeof Constructor === "string") {
+                message = Constructor;
+                Constructor = null;
+            } else if (Constructor && Constructor instanceof Error) {
+                desiredReason = Constructor;
+                Constructor = null;
+                message = null;
+            } else if (typeof Constructor === "function") {
+                constructorName = (new Constructor()).name;
+            } else {
+                Constructor = null;
+            }
+
+            var that = this;
+            var derivedPromise = getBasePromise(that).then(
+                function (value) {
+                    var assertionMessage = null;
+                    var expected = null;
+
+                    if (Constructor) {
+                        assertionMessage = "expected promise to be rejected with #{exp} but it was fulfilled with " +
+                                           "#{act}";
+                        expected = constructorName;
+                    } else if (message) {
+                        var verb = message instanceof RegExp ? "matching" : "including";
+                        assertionMessage = "expected promise to be rejected with an error " + verb + " #{exp} but it " +
+                                           "was fulfilled with #{act}";
+                        expected = message;
+                    } else if (desiredReason) {
+                        assertionMessage = "expected promise to be rejected with #{exp} but it was fulfilled with " +
+                                           "#{act}";
+                        expected = desiredReason;
+                    }
+
+                    that._obj = value;
+
+                    assertIfNotNegated(that, assertionMessage, { expected: expected, actual: value });
+                },
+                function (reason) {
+                    if (Constructor) {
+                        that.assert(reason instanceof Constructor,
+                                    "expected promise to be rejected with #{exp} but it was rejected with #{act}",
+                                    "expected promise not to be rejected with #{exp} but it was rejected with #{act}",
+                                    constructorName,
+                                    reason);
+                    }
+
+                    var reasonMessage = utils.type(reason) === "object" && "message" in reason ?
+                                            reason.message :
+                                            "" + reason;
+                    if (message && reasonMessage !== null && reasonMessage !== undefined) {
+                        if (message instanceof RegExp) {
+                            that.assert(message.test(reasonMessage),
+                                        "expected promise to be rejected with an error matching #{exp} but got #{act}",
+                                        "expected promise not to be rejected with an error matching #{exp}",
+                                        message,
+                                        reasonMessage);
+                        }
+                        if (typeof message === "string") {
+                            that.assert(reasonMessage.indexOf(message) !== -1,
+                                        "expected promise to be rejected with an error including #{exp} but got #{act}",
+                                        "expected promise not to be rejected with an error including #{exp}",
+                                        message,
+                                        reasonMessage);
+                        }
+                    }
+
+                    if (desiredReason) {
+                        that.assert(reason === desiredReason,
+                                    "expected promise to be rejected with #{exp} but it was rejected with #{act}",
+                                    "expected promise not to be rejected with #{exp}",
+                                    desiredReason,
+                                    reason);
+                    }
+                }
+            );
+
+            chaiAsPromised.transferPromiseness(that, derivedPromise);
+        });
+
+        property("eventually", function () {
+            utils.flag(this, "eventually", true);
+        });
+
+        method("notify", function (done) {
+            doNotify(getBasePromise(this), done);
+        });
+
+        method("become", function (value) {
+            return this.eventually.deep.equal(value);
+        });
+
+        ////////
+        // `eventually`
+
+        // We need to be careful not to trigger any getters, thus `Object.getOwnPropertyDescriptor` usage.
+        var methodNames = propertyNames.filter(function (name) {
+            return name !== "assert" && typeof propertyDescs[name].value === "function";
+        });
+
+        methodNames.forEach(function (methodName) {
+            Assertion.overwriteMethod(methodName, function (originalMethod) {
+                return function () {
+                    doAsserterAsyncAndAddThen(originalMethod, this, arguments);
+                };
+            });
+        });
+
+        var getterNames = propertyNames.filter(function (name) {
+            return name !== "_obj" && typeof propertyDescs[name].get === "function";
+        });
+
+        getterNames.forEach(function (getterName) {
+            var propertyDesc = propertyDescs[getterName];
+
+            // Chainable methods are things like `an`, which can work both for `.should.be.an.instanceOf` and as
+            // `should.be.an("object")`. We need to handle those specially.
+            var isChainableMethod = false;
+            try {
+                isChainableMethod = typeof propertyDesc.get.call({}) === "function";
+            } catch (e) { }
+
+            if (isChainableMethod) {
+                Assertion.addChainableMethod(
+                    getterName,
+                    function () {
+                        var assertion = this;
+                        function originalMethod() {
+                            return propertyDesc.get.call(assertion).apply(assertion, arguments);
+                        }
+                        doAsserterAsyncAndAddThen(originalMethod, this, arguments);
+                    },
+                    function () {
+                        var originalGetter = propertyDesc.get;
+                        doAsserterAsyncAndAddThen(originalGetter, this);
+                    }
+                );
+            } else {
+                Assertion.overwriteProperty(getterName, function (originalGetter) {
+                    return function () {
+                        doAsserterAsyncAndAddThen(originalGetter, this);
+                    };
+                });
+            }
+        });
+
+        function doAsserterAsyncAndAddThen(asserter, assertion, args) {
+            // Since we're intercepting all methods/properties, we need to just pass through if they don't want
+            // `eventually`, or if we've already fulfilled the promise (see below).
+            if (!utils.flag(assertion, "eventually")) {
+                return asserter.apply(assertion, args);
+            }
+
+            var derivedPromise = getBasePromise(assertion).then(function (value) {
+                // Set up the environment for the asserter to actually run: `_obj` should be the fulfillment value, and
+                // now that we have the value, we're no longer in "eventually" mode, so we won't run any of this code,
+                // just the base Chai code that we get to via the short-circuit above.
+                assertion._obj = value;
+                utils.flag(assertion, "eventually", false);
+                asserter.apply(assertion, args);
+
+                // Because asserters, for example `property`, can change the value of `_obj` (i.e. change the "object"
+                // flag), we need to communicate this value change to subsequent chained asserters. Since we build a
+                // promise chain paralleling the asserter chain, we can use it to communicate such changes.
+                return assertion._obj;
+            });
+
+            chaiAsPromised.transferPromiseness(assertion, derivedPromise);
+        }
+
+        ///////
+        // Now use the `Assertion` framework to build an `assert` interface.
+        var originalAssertMethods = Object.getOwnPropertyNames(assert).filter(function (propName) {
+            return typeof assert[propName] === "function";
+        });
+
+        assert.isFulfilled = function (promise, message) {
+            return (new Assertion(promise, message)).to.be.fulfilled;
+        };
+
+        assert.isRejected = function (promise, toTestAgainst, message) {
+            if (typeof toTestAgainst === "string") {
+                message = toTestAgainst;
+                toTestAgainst = undefined;
+            }
+
+            var assertion = (new Assertion(promise, message));
+            return toTestAgainst !== undefined ? assertion.to.be.rejectedWith(toTestAgainst) : assertion.to.be.rejected;
+        };
+
+        assert.becomes = function (promise, value, message) {
+            return assert.eventually.deepEqual(promise, value, message);
+        };
+
+        assert.doesNotBecome = function (promise, value, message) {
+            return assert.eventually.notDeepEqual(promise, value, message);
+        };
+
+        assert.eventually = {};
+        originalAssertMethods.forEach(function (assertMethodName) {
+            assert.eventually[assertMethodName] = function (promise) {
+                var otherArgs = Array.prototype.slice.call(arguments, 1);
+
+                var customRejectionHandler;
+                var message = arguments[assert[assertMethodName].length - 1];
+                if (typeof message === "string") {
+                    customRejectionHandler = function (reason) {
+                        throw new chai.AssertionError(message + "\n\nOriginal reason: " + utils.inspect(reason));
+                    };
+                }
+
+                var returnedPromise = promise.then(
+                    function (fulfillmentValue) {
+                        return assert[assertMethodName].apply(assert, [fulfillmentValue].concat(otherArgs));
+                    },
+                    customRejectionHandler
+                );
+
+                returnedPromise.notify = function (done) {
+                    doNotify(returnedPromise, done);
+                };
+
+                return returnedPromise;
+            };
+        });
+    }
+}());

assets/webapps/test-agent.gaiamobile.org/common/vendor/mocha/mocha.css

@@ -0,0 +1,270 @@
+@charset "utf-8";
+
+body {
+  margin:0;
+}
+
+#mocha {
+  font: 20px/1.5 "Helvetica Neue", Helvetica, Arial, sans-serif;
+  margin: 60px 50px;
+}
+
+#mocha ul,
+#mocha li {
+  margin: 0;
+  padding: 0;
+}
+
+#mocha ul {
+  list-style: none;
+}
+
+#mocha h1,
+#mocha h2 {
+  margin: 0;
+}
+
+#mocha h1 {
+  margin-top: 15px;
+  font-size: 1em;
+  font-weight: 200;
+}
+
+#mocha h1 a {
+  text-decoration: none;
+  color: inherit;
+}
+
+#mocha h1 a:hover {
+  text-decoration: underline;
+}
+
+#mocha .suite .suite h1 {
+  margin-top: 0;
+  font-size: .8em;
+}
+
+#mocha .hidden {
+  display: none;
+}
+
+#mocha h2 {
+  font-size: 12px;
+  font-weight: normal;
+  cursor: pointer;
+}
+
+#mocha .suite {
+  margin-left: 15px;
+}
+
+#mocha .test {
+  margin-left: 15px;
+  overflow: hidden;
+}
+
+#mocha .test.pending:hover h2::after {
+  content: '(pending)';
+  font-family: arial, sans-serif;
+}
+
+#mocha .test.pass.medium .duration {
+  background: #c09853;
+}
+
+#mocha .test.pass.slow .duration {
+  background: #b94a48;
+}
+
+#mocha .test.pass::before {
+  content: '✓';
+  font-size: 12px;
+  display: block;
+  float: left;
+  margin-right: 5px;
+  color: #00d6b2;
+}
+
+#mocha .test.pass .duration {
+  font-size: 9px;
+  margin-left: 5px;
+  padding: 2px 5px;
+  color: #fff;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0,0,0,.2);
+  -moz-box-shadow: inset 0 1px 1px rgba(0,0,0,.2);
+  box-shadow: inset 0 1px 1px rgba(0,0,0,.2);
+  -webkit-border-radius: 5px;
+  -moz-border-radius: 5px;
+  -ms-border-radius: 5px;
+  -o-border-radius: 5px;
+  border-radius: 5px;
+}
+
+#mocha .test.pass.fast .duration {
+  display: none;
+}
+
+#mocha .test.pending {
+  color: #0b97c4;
+}
+
+#mocha .test.pending::before {
+  content: '◦';
+  color: #0b97c4;
+}
+
+#mocha .test.fail {
+  color: #c00;
+}
+
+#mocha .test.fail pre {
+  color: black;
+}
+
+#mocha .test.fail::before {
+  content: '✖';
+  font-size: 12px;
+  display: block;
+  float: left;
+  margin-right: 5px;
+  color: #c00;
+}
+
+#mocha .test pre.error {
+  color: #c00;
+  max-height: 300px;
+  overflow: auto;
+}
+
+/**
+ * (1): approximate for browsers not supporting calc
+ * (2): 42 = 2*15 + 2*10 + 2*1 (padding + margin + border)
+ *      ^^ seriously
+ */
+#mocha .test pre {
+  display: block;
+  float: left;
+  clear: left;
+  font: 12px/1.5 monaco, monospace;
+  margin: 5px;
+  padding: 15px;
+  border: 1px solid #eee;
+  max-width: 85%; /*(1)*/
+  max-width: calc(100% - 42px); /*(2)*/
+  word-wrap: break-word;
+  border-bottom-color: #ddd;
+  -webkit-border-radius: 3px;
+  -webkit-box-shadow: 0 1px 3px #eee;
+  -moz-border-radius: 3px;
+  -moz-box-shadow: 0 1px 3px #eee;
+  border-radius: 3px;
+}
+
+#mocha .test h2 {
+  position: relative;
+}
+
+#mocha .test a.replay {
+  position: absolute;
+  top: 3px;
+  right: 0;
+  text-decoration: none;
+  vertical-align: middle;
+  display: block;
+  width: 15px;
+  height: 15px;
+  line-height: 15px;
+  text-align: center;
+  background: #eee;
+  font-size: 15px;
+  -moz-border-radius: 15px;
+  border-radius: 15px;
+  -webkit-transition: opacity 200ms;
+  -moz-transition: opacity 200ms;
+  transition: opacity 200ms;
+  opacity: 0.3;
+  color: #888;
+}
+
+#mocha .test:hover a.replay {
+  opacity: 1;
+}
+
+#mocha-report.pass .test.fail {
+  display: none;
+}
+
+#mocha-report.fail .test.pass {
+  display: none;
+}
+
+#mocha-report.pending .test.pass,
+#mocha-report.pending .test.fail {
+  display: none;
+}
+#mocha-report.pending .test.pass.pending {
+  display: block;
+}
+
+#mocha-error {
+  color: #c00;
+  font-size: 1.5em;
+  font-weight: 100;
+  letter-spacing: 1px;
+}
+
+#mocha-stats {
+  position: fixed;
+  top: 15px;
+  right: 10px;
+  font-size: 12px;
+  margin: 0;
+  color: #888;
+  z-index: 1;
+}
+
+#mocha-stats .progress {
+  float: right;
+  padding-top: 0;
+}
+
+#mocha-stats em {
+  color: black;
+}
+
+#mocha-stats a {
+  text-decoration: none;
+  color: inherit;
+}
+
+#mocha-stats a:hover {
+  border-bottom: 1px solid #eee;
+}
+
+#mocha-stats li {
+  display: inline-block;
+  margin: 0 5px;
+  list-style: none;
+  padding-top: 11px;
+}
+
+#mocha-stats canvas {
+  width: 40px;
+  height: 40px;
+}
+
+#mocha code .comment { color: #ddd; }
+#mocha code .init { color: #2f6fad; }
+#mocha code .string { color: #5890ad; }
+#mocha code .keyword { color: #8a6343; }
+#mocha code .number { color: #2f6fad; }
+
+@media screen and (max-device-width: 480px) {
+  #mocha {
+    margin: 60px 0px;
+  }
+
+  #mocha #stats {
+    position: absolute;
+  }
+}

assets/webapps/test-agent.gaiamobile.org/common/vendor/test-agent/test-agent.css

@@ -0,0 +1,214 @@
+* { -moz-box-sizing: border-box; -webkit-box-sizing: border-box; box-sizing: border-box; }
+
+body,
+html {
+  height: 100%;
+  padding: 0;
+  margin: 0;
+}
+
+body {
+  font: 14px/1.5 "Helvetica Neue", Helvetica, Arial, sans-serif;
+}
+
+body > iframe {
+  visibility: hidden;
+}
+
+button {
+  border-radius: 0.3125rem;
+  font-size: 1rem;
+}
+
+button.active, button:active {
+  border-left: 0.15em solid #B8B8B8;
+  border-top: 0.15em solid #B8B8B8;
+  border-right: 0.15em solid white;
+  border-bottom: 0.15em solid white;
+  background-color: #E0E0E0;
+}
+
+#test-agent-ui {
+  margin: 2em 2em 2em 1em;
+}
+
+#test-agent-ui .hidden {
+  display: none;
+}
+
+#test-agent-ui > .error {
+  margin: 15px 40px;
+}
+
+#test-agent-ui > .error h1,
+#test-agent-ui > .error p {
+  padding: 0px;
+  margin: 0px;
+}
+
+#test-agent-ui ul {
+  padding: none;
+  border: none;
+  clear: both;
+  overflow: hidden;
+  margin: 4.5rem 0 0 0;
+  padding: 0 0 1rem 0;
+
+  -webkit-column-width: 350px;
+     -moz-column-width: 350px;
+          column-width: 350px;
+  -webkit-column-fill: balance;
+     -moz-column-fill: balance;
+          column-fill: balance;
+}
+
+#test-agent-ui li {
+  position: relative;
+
+  list-style: none;
+  padding: 0 0 0 1.5rem;
+  margin: 0;
+
+  cursor: pointer;
+}
+
+#test-agent-ui .active,
+#test-agent-ui li:not(.test-agent-list-head):hover {
+  color: #00d;
+  text-decoration: underline;
+}
+
+#test-agent-ui .active:before {
+  content: '*';
+  position: absolute;
+  display: block;
+  left: .7rem;
+  top: .2rem;
+  width: 1rem;
+}
+
+#test-agent-ui .working {
+  font-style: italic;
+}
+
+#test-agent-ui .working:after {
+  content: '...';
+}
+
+#test-agent-ui button {
+  clear: both;
+  font-size: 1.4rem;
+  width: 100%;
+  padding: .5rem;
+  height: 3rem;
+  border: 1px solid #E2E2E2;
+}
+
+#test-agent-ui .test-agent-list-head {
+  position: relative;
+
+  width: 100%;
+  margin: 1rem 0;
+
+  font-weight: bolder;
+  font-size: 1.2rem;
+  background: #CCC;
+}
+
+#test-agent-ui .test-agent-list-head-info {
+  position: absolute;
+  right: .5rem;
+
+  font-style: italic;
+  font-weight: normal;
+}
+
+#test-agent-ui .test-agent-list-head:hover {
+  text-decoration: none;
+}
+
+#test-agent-panel {
+  position: fixed;
+  top: 0;
+  left: 0;
+  padding: 1rem 5rem;
+  background-color: rgba(250, 250, 250, 0.35);
+  width: 100%;
+  height: 4.5rem;
+  z-index: 4;
+}
+
+#test-agent-panel .options {
+  margin-top: 0.2rem;
+  margin-left: -0.3rem;
+}
+
+#test-agent-panel .execute {
+  margin-top: -2.5rem;
+  text-align: center;
+}
+
+@media only screen and (max-width: 720px) {
+  #test-agent-ui {
+    margin-left: 0;
+    margin-right: 0;
+  }
+
+  #test-agent-ui li {
+    width: 100%;
+    padding: .5rem 1rem .5rem 2rem;
+    border-bottom: 1px solid #aaa;
+  }
+
+  #test-agent-ui .active:before {
+    top: .8rem;
+  }
+
+  #test-agent-panel {
+    height: 5.5rem;
+    border-bottom: 1px solid #aaa;
+  }
+
+  #test-agent-panel .execute button {
+    margin-top: 2.8rem;
+  }
+
+  #test-agent-panel .execute {
+    margin-top: -4rem;
+  }
+}
+
+@media only screen and (max-width: 600px) {
+  #test-agent-panel {
+    height: 7rem;
+    padding: 1rem 1.5rem;
+    border-bottom: 1px solid #aaa;
+  }
+
+  form {
+    margin-top: 1.7rem;
+  }
+
+  #test-agent-ui ul {
+    margin: 5.9rem 0 0;
+  }
+}
+
+@media only screen and (max-width: 460px) {
+  #test-agent-panel .execute {
+    position: fixed;
+    margin-left: 10.7rem;
+  }
+}
+
+#blanket-main * {
+  -moz-box-sizing: initial;
+  -webkit-box-sizing: initial;
+  box-sizing: initial;
+}
+
+code .comment { color: #ddd }
+code .init { color: #2F6FAD }
+code .string { color: #5890AD }
+code .keyword { color: #8A6343 }
+code .number { color: #2F6FAD }