feat: Add Be and tbd skill, also added Roadmap file

Skills/@be/node_modules/es3ify/.npmignore

@@ -0,0 +1 @@
+node_modules

Skills/@be/node_modules/es3ify/.travis.yml

@@ -0,0 +1,3 @@
+language: node_js
+node_js:
+- "0.10"

Skills/@be/node_modules/es3ify/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Ben Alpert
+
+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.

Skills/@be/node_modules/es3ify/README.md

@@ -0,0 +1,20 @@
+# es3ify
+
+Browserify transform to convert quote reserved words in property keys for compatibility with ES3 JavaScript engines like IE8. In addition, trailing commas in array and object literals are removed.
+
+```javascript
+// In
+var x = {class: 2,};
+x.class = [3, 4,];
+
+// Out:
+var x = {"class": 2};
+x["class"] = [3, 4];
+```
+
+Run tests with:
+
+```sh
+npm install -g jasmine-node
+jasmine-node spec
+```

Skills/@be/node_modules/es3ify/index.js

@@ -0,0 +1,139 @@
+var Syntax = require('esprima-fb').Syntax;
+var jstransform = require('jstransform');
+var through = require('through');
+var utils = require('jstransform/src/utils');
+
+var reserved = [
+    "break", "case", "catch", "continue", "default", "delete", "do", "else",
+    "finally", "for", "function", "if", "in", "instanceof", "new", "return",
+    "switch", "this", "throw", "try", "typeof", "var", "void", "while", "with",
+    "abstract", "boolean", "byte", "char", "class", "const", "debugger",
+    "double", "enum", "export", "extends", "final", "float", "goto",
+    "implements", "import", "int", "interface", "long", "native", "package",
+    "private", "protected", "public", "short", "static", "super",
+    "synchronized", "throws", "transient", "volatile",
+];
+var reservedDict = {};
+reserved.forEach(function(k) {
+    reservedDict[k] = true;
+});
+
+// In: x.class = 3;
+// Out: x["class"] = 3;
+function visitMemberExpression(traverse, node, path, state) {
+    traverse(node.object, path, state);
+    utils.catchup(node.object.range[1], state);
+    utils.append('[', state);
+    utils.catchupWhiteSpace(node.property.range[0], state);
+    utils.append('"', state);
+    utils.catchup(node.property.range[1], state);
+    utils.append('"]', state);
+    return false;
+}
+visitMemberExpression.test = function(node, path, state) {
+    return node.type === Syntax.MemberExpression &&
+        node.property.type === Syntax.Identifier &&
+        reservedDict[node.property.name] === true;
+};
+
+// In: x = {class: 2};
+// Out: x = {"class": 2};
+function visitProperty(traverse, node, path, state) {
+    utils.catchup(node.key.range[0], state);
+    utils.append('"', state);
+    utils.catchup(node.key.range[1], state);
+    utils.append('"', state);
+    utils.catchup(node.value.range[0], state);
+    traverse(node.value, path, state);
+    return false;
+}
+visitProperty.test = function(node, path, state) {
+    return node.type === Syntax.Property &&
+        node.key.type === Syntax.Identifier &&
+        reservedDict[node.key.name] === true;
+};
+
+var reCommaOrComment = /,|\/\*.+?\*\/|\/\/[^\n]+/g;
+function stripComma(value) {
+  return value.replace(reCommaOrComment, function(text) {
+    if (text === ',') {
+        return '';
+    } else {
+        // Preserve comments
+        return text;
+    }
+  });
+}
+
+// In: [1, 2, 3,]
+// Out: [1, 2, 3]
+function visitArrayOrObjectExpression(traverse, node, path, state) {
+    // Copy the opening '[' or '{'
+    utils.catchup(node.range[0] + 1, state);
+
+    var elements = node.type === Syntax.ArrayExpression ?
+        node.elements :
+        node.properties;
+    elements.forEach(function(element, i) {
+        if (element == null && i === elements.length - 1) {
+            throw new Error(
+                "Elisions ending an array are interpreted inconsistently " +
+                "in IE8; remove the extra comma or use 'undefined' explicitly");
+        }
+        if (element != null) {
+            // Copy commas from after previous element, if any
+            utils.catchup(element.range[0], state);
+            traverse(element, path, state);
+        }
+    });
+
+    // Skip over a trailing comma, if any
+    utils.catchup(node.range[1] - 1, state, stripComma);
+    utils.catchup(node.range[1], state);
+    return false;
+}
+visitArrayOrObjectExpression.test = function(node, path, state) {
+    return node.type === Syntax.ArrayExpression ||
+        node.type === Syntax.ObjectExpression;
+};
+
+var visitorList = [
+    visitMemberExpression,
+    visitProperty,
+    visitArrayOrObjectExpression
+];
+
+function transform(code) {
+    return jstransform.transform(visitorList, code).code;
+}
+
+function process(file) {
+    if (/\.json$/.test(file)) return through();
+    var data = '';
+    function write(chunk) {
+        data += chunk;
+    }
+
+    function compile() {
+
+        var source;
+
+        try {
+          source = transform(data);
+        } catch (e) {
+          return this.emit('error', e);
+        }
+
+        this.queue(source);
+        this.queue(null);
+    }
+
+    return through(write, compile);
+}
+
+module.exports = process;
+module.exports.isReserved = function(word) {
+    return reservedDict.hasOwnProperty(word) ? !!reservedDict[word] : false;
+};
+module.exports.transform = transform;
+module.exports.visitorList = visitorList;

Skills/@be/node_modules/es3ify/package.json

@@ -0,0 +1,28 @@
+{
+    "name": "es3ify",
+    "version": "0.1.4",
+    "description": "Browserify transform to convert ES5 syntax to be ES3-compatible.",
+    "main": "index.js",
+    "dependencies": {
+        "esprima-fb": "~3001.0001.0000-dev-harmony-fb",
+        "jstransform": "~3.0.0",
+        "through": "~2.3.4"
+    },
+    "devDependencies": {
+        "jasmine-node": "~1.13.1"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git://github.com/spicyj/es3ify.git"
+    },
+    "scripts": {
+        "test": "jasmine-node spec"
+    },
+    "homepage": "https://github.com/spicyj/es3ify",
+    "author": {
+        "name": "Ben Alpert",
+        "email": "ben@benalpert.com",
+        "url": "http://benalpert.com"
+    },
+    "license": "MIT"
+}

Skills/@be/node_modules/es3ify/spec/es3ifyspec.js

@@ -0,0 +1,33 @@
+var transform = require('../index.js').transform;
+
+describe('es3ify', function() {
+    it('should quote property keys', function() {
+        expect(transform('x = {dynamic: 0, static: 17};'))
+                .toEqual('x = {dynamic: 0, "static": 17};');
+    });
+
+    it('should quote member properties', function() {
+        expect(transform('x.dynamic++; x.static++;'))
+                .toEqual('x.dynamic++; x["static"]++;');
+    });
+
+    it('should remove trailing commas in arrays', function() {
+        expect(transform('[2, 3, 4,]'))
+                .toEqual('[2, 3, 4]');
+    });
+
+    it('should keep comments near a trailing comma', function() {
+        expect(transform('[2, 3, 4 /* = 2^2 */,// = 6 - 2\n]'))
+                .toEqual('[2, 3, 4 /* = 2^2 */// = 6 - 2\n]');
+    });
+
+    it('should remove trailing commas in objects', function() {
+        expect(transform('({x: 3, y: 4,})'))
+                .toEqual('({x: 3, y: 4})');
+    });
+
+    it('should transform everything at once', function() {
+        expect(transform('({a:2,\tfor :[2,,3,],}\n.class)'))
+                .toEqual('({a:2,\t"for" :[2,,3]}[\n"class"])');
+    });
+});