RubyGems - sprockets-browserify - Versions diffs - 0.1.0 - Mend

sprockets-browserify 0.1.0

Files changed (790) hide show

data/node_modules/module-deps/node_modules/detective/node_modules/esprima/test/index.html ADDED Viewed

@@ -0,0 +1,37 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>Esprima: Unit Tests</title>
+<link rel="stylesheet" type="text/css" href="../assets/style.css"/>
+<script src="../esprima.js"></script>
+<script src="../assets/json2.js"></script>
+<script src="test.js"></script>
+<script src="runner.js"></script>
+</head>
+<body>
+<div class="container">
+<div class="topbar">
+<ul class="nav">
+<li><a href="../index.html">&larr; Home</a></li>
+<li><a href="http://github.com/ariya/esprima">Code</a></li>
+<li><a href="../doc/index.html">Documentation</a></li>
+<li><a href="http://issues.esprima.org">Issues</a></li>
+</ul>
+</div>
+<h1>Unit Tests <small>ensures the correct implementation</small></h1>
+<p>Esprima version <span id="version"></span>.</p>
+<p id="status">Please wait...</p>
+<div id="report"></div>
+<div class="footer"><strong>Esprima</strong> is created by
+<a href="http://ariya.ofilabs.com/about" target="_blank">Ariya Hidayat</a>. Follow <a href="http://twitter.com/ariyahidayat">@ariyahidayat</a> on Twitter.
+</div>
+</div>
+<script>
+/*jslint browser: true */
+window.onload = window.runTests;
+</script>
+</body>
+</html>

data/node_modules/module-deps/node_modules/detective/node_modules/esprima/test/module.html ADDED Viewed

@@ -0,0 +1,36 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>Esprima: Module Loading Test</title>
+<link rel="stylesheet" type="text/css" href="../assets/style.css"/>
+<script src="../assets/require.js"></script>
+</head>
+<body>
+<div class="container">
+<div class="topbar">
+<ul class="nav">
+<li><a href="../index.html">&larr; Home</a></li>
+<li><a href="http://github.com/ariya/esprima">Code</a></li>
+<li><a href="../doc/index.html">Documentation</a></li>
+<li><a href="http://issues.esprima.org">Issues</a></li>
+</ul>
+</div>
+<h1>Module Loading <small>works also with web browsers</small></h1>
+<p>The following tests are to ensure that Esprima can be loaded using <a href="https://github.com/amdjs/amdjs-api/wiki/AMD">AMD</a> (Asynchronous Module Definition) loader such as <a href="http://requirejs.org">RequireJS</a>.</p>
+<p id="status"></p>
+<div id="report"></div>
+<div class="footer"><strong>Esprima</strong> is created by
+<a href="http://ariya.ofilabs.com/about" target="_blank">Ariya Hidayat</a>. Follow <a href="http://twitter.com/ariyahidayat">@ariyahidayat</a> on Twitter.
+</div>
+</div>
+<script src="module.js"></script>
+<script>
+/*jslint browser:true*/
+window.onload = window.runTests;
+</script>
+</body>
+</html>

data/node_modules/module-deps/node_modules/detective/node_modules/esprima/test/module.js ADDED Viewed

@@ -0,0 +1,129 @@
+/*jslint browser:true plusplus:true */
+/*global require:true */
+function runTests() {
+    'use strict';
+    function setText(el, str) {
+        if (typeof el.innerText === 'string') {
+            el.innerText = str;
+        } else {
+            el.textContent = str;
+        }
+    }
+    function reportSuccess(code) {
+        var report, e;
+        report = document.getElementById('report');
+        e = document.createElement('pre');
+        e.setAttribute('class', 'code');
+        setText(e, code);
+        report.appendChild(e);
+    }
+    function reportFailure(code, expected, actual) {
+        var report, e;
+        report = document.getElementById('report');
+        e = document.createElement('pre');
+        e.setAttribute('class', 'code');
+        setText(e, code);
+        report.appendChild(e);
+        e = document.createElement('p');
+        setText(e, 'Expected type: ' + expected);
+        report.appendChild(e);
+        e = document.createElement('p');
+        setText(e, 'Actual type: ' + actual);
+        report.appendChild(e);
+    }
+    require(['../esprima'], function (ESParser) {
+        var tick, total, failures, obj, variable, variables, i, entry, entries;
+        // We check only the type of some members of ESParser.
+        variables = {
+            'version': 'string',
+            'parse': 'function',
+            'Syntax': 'object',
+            'Syntax.AssignmentExpression': 'string',
+            'Syntax.ArrayExpression': 'string',
+            'Syntax.BlockStatement': 'string',
+            'Syntax.BinaryExpression': 'string',
+            'Syntax.BreakStatement': 'string',
+            'Syntax.CallExpression': 'string',
+            'Syntax.CatchClause': 'string',
+            'Syntax.ConditionalExpression': 'string',
+            'Syntax.ContinueStatement': 'string',
+            'Syntax.DoWhileStatement': 'string',
+            'Syntax.DebuggerStatement': 'string',
+            'Syntax.EmptyStatement': 'string',
+            'Syntax.ExpressionStatement': 'string',
+            'Syntax.ForStatement': 'string',
+            'Syntax.ForInStatement': 'string',
+            'Syntax.FunctionDeclaration': 'string',
+            'Syntax.FunctionExpression': 'string',
+            'Syntax.Identifier': 'string',
+            'Syntax.IfStatement': 'string',
+            'Syntax.Literal': 'string',
+            'Syntax.LabeledStatement': 'string',
+            'Syntax.LogicalExpression': 'string',
+            'Syntax.MemberExpression': 'string',
+            'Syntax.NewExpression': 'string',
+            'Syntax.ObjectExpression': 'string',
+            'Syntax.Program': 'string',
+            'Syntax.Property': 'string',
+            'Syntax.ReturnStatement': 'string',
+            'Syntax.SequenceExpression': 'string',
+            'Syntax.SwitchStatement': 'string',
+            'Syntax.SwitchCase': 'string',
+            'Syntax.ThisExpression': 'string',
+            'Syntax.ThrowStatement': 'string',
+            'Syntax.TryStatement': 'string',
+            'Syntax.UnaryExpression': 'string',
+            'Syntax.UpdateExpression': 'string',
+            'Syntax.VariableDeclaration': 'string',
+            'Syntax.VariableDeclarator': 'string',
+            'Syntax.WhileStatement': 'string',
+            'Syntax.WithStatement': 'string'
+        };
+        total = failures = 0;
+        tick = new Date();
+        for (variable in variables) {
+            if (variables.hasOwnProperty(variable)) {
+                entries = variable.split('.');
+                obj = ESParser;
+                for (i = 0; i < entries.length; ++i) {
+                    entry = entries[i];
+                    if (typeof obj[entry] !== 'undefined') {
+                        obj = obj[entry];
+                    } else {
+                        obj = undefined;
+                        break;
+                    }
+                }
+                total++;
+                if (typeof obj === variables[variable]) {
+                    reportSuccess(variable);
+                } else {
+                    failures++;
+                    reportFailure(variable, variables[variable], typeof obj);
+                }
+            }
+        }
+        tick = (new Date()) - tick;
+        if (failures > 0) {
+            setText(document.getElementById('status'), total + ' tests. ' +
+                'Failures: ' + failures + '. ' + tick + ' ms');
+        } else {
+            setText(document.getElementById('status'), total + ' tests. ' +
+                'No failure. ' + tick + ' ms');
+        }
+    });
+}

data/node_modules/module-deps/node_modules/detective/node_modules/esprima/test/reflect.js ADDED Viewed

@@ -0,0 +1,422 @@
+// This is modified from Mozilla Reflect.parse test suite (the file is located
+// at js/src/tests/js1_8_5/extensions/reflect-parse.js in the source tree).
+//
+// Some notable changes:
+//   * Removed unsupported features (destructuring, let, comprehensions...).
+//   * Removed tests for E4X (ECMAScript for XML).
+//   * Removed everything related to builder.
+//   * Enclosed every 'Pattern' construct with a scope.
+//   * Tweaked some expected tree to remove generator field.
+//   * Removed the test for bug 632030 and bug 632024.
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/licenses/publicdomain/
+ */
+(function (exports) {
+function testReflect(Reflect, Pattern) {
+function program(elts) { return Pattern({ type: "Program", body: elts }) }
+function exprStmt(expr) { return Pattern({ type: "ExpressionStatement", expression: expr }) }
+function throwStmt(expr) { return Pattern({ type: "ThrowStatement", argument: expr }) }
+function returnStmt(expr) { return Pattern({ type: "ReturnStatement", argument: expr }) }
+function yieldExpr(expr) { return Pattern({ type: "YieldExpression", argument: expr }) }
+function lit(val) { return Pattern({ type: "Literal", value: val }) }
+var thisExpr = Pattern({ type: "ThisExpression" });
+function funDecl(id, params, body) { return Pattern({ type: "FunctionDeclaration",
+                                             id: id,
+                                             params: params,
+                                             defaults: [],
+                                             body: body,
+                                             rest: null,
+                                             generator: false,
+                                             expression: false
+                                             }) }
+function genFunDecl(id, params, body) { return Pattern({ type: "FunctionDeclaration",
+                                                id: id,
+                                                params: params,
+                                                defaults: [],
+                                                body: body,
+                                                rest: null,
+                                                generator: false,
+                                                expression: false
+                                                }) }
+function declarator(id, init) { return Pattern({ type: "VariableDeclarator", id: id, init: init }) }
+function varDecl(decls) { return Pattern({ type: "VariableDeclaration", declarations: decls, kind: "var" }) }
+function letDecl(decls) { return Pattern({ type: "VariableDeclaration", declarations: decls, kind: "let" }) }
+function constDecl(decls) { return Pattern({ type: "VariableDeclaration", declarations: decls, kind: "const" }) }
+function ident(name) { return Pattern({ type: "Identifier", name: name }) }
+function dotExpr(obj, id) { return Pattern({ type: "MemberExpression", computed: false, object: obj, property: id }) }
+function memExpr(obj, id) { return Pattern({ type: "MemberExpression", computed: true, object: obj, property: id }) }
+function forStmt(init, test, update, body) { return Pattern({ type: "ForStatement", init: init, test: test, update: update, body: body }) }
+function forInStmt(lhs, rhs, body) { return Pattern({ type: "ForInStatement", left: lhs, right: rhs, body: body, each: false }) }
+function forEachInStmt(lhs, rhs, body) { return Pattern({ type: "ForInStatement", left: lhs, right: rhs, body: body, each: true }) }
+function breakStmt(lab) { return Pattern({ type: "BreakStatement", label: lab }) }
+function continueStmt(lab) { return Pattern({ type: "ContinueStatement", label: lab }) }
+function blockStmt(body) { return Pattern({ type: "BlockStatement", body: body }) }
+var emptyStmt = Pattern({ type: "EmptyStatement" });
+function ifStmt(test, cons, alt) { return Pattern({ type: "IfStatement", test: test, alternate: alt, consequent: cons }) }
+function labStmt(lab, stmt) { return Pattern({ type: "LabeledStatement", label: lab, body: stmt }) }
+function withStmt(obj, stmt) { return Pattern({ type: "WithStatement", object: obj, body: stmt }) }
+function whileStmt(test, stmt) { return Pattern({ type: "WhileStatement", test: test, body: stmt }) }
+function doStmt(stmt, test) { return Pattern({ type: "DoWhileStatement", test: test, body: stmt }) }
+function switchStmt(disc, cases) { return Pattern({ type: "SwitchStatement", discriminant: disc, cases: cases }) }
+function caseClause(test, stmts) { return Pattern({ type: "SwitchCase", test: test, consequent: stmts }) }
+function defaultClause(stmts) { return Pattern({ type: "SwitchCase", test: null, consequent: stmts }) }
+function catchClause(id, guard, body) { if (guard) { return Pattern({ type: "GuardedCatchClause", param: id, guard: guard, body: body }) } else { return Pattern({ type: "CatchClause", param: id, body: body }) } }
+function tryStmt(body, guarded, catches, fin) { return Pattern({ type: "TryStatement", block: body, guardedHandlers: guarded, handlers: catches, finalizer: fin }) }
+function letStmt(head, body) { return Pattern({ type: "LetStatement", head: head, body: body }) }
+function funExpr(id, args, body, gen) { return Pattern({ type: "FunctionExpression",
+                                                id: id,
+                                                params: args,
+                                                defaults: [],
+                                                body: body,
+                                                rest: null,
+                                                generator: false,
+                                                expression: false
+                                                }) }
+function genFunExpr(id, args, body) { return Pattern({ type: "FunctionExpression",
+                                              id: id,
+                                              params: args,
+                                              defaults: [],
+                                              body: body,
+                                              rest: null,
+                                              generator: false,
+                                              expression: false
+                                              }) }
+function unExpr(op, arg) { return Pattern({ type: "UnaryExpression", operator: op, argument: arg }) }
+function binExpr(op, left, right) { return Pattern({ type: "BinaryExpression", operator: op, left: left, right: right }) }
+function aExpr(op, left, right) { return Pattern({ type: "AssignmentExpression", operator: op, left: left, right: right }) }
+function updExpr(op, arg, prefix) { return Pattern({ type: "UpdateExpression", operator: op, argument: arg, prefix: prefix }) }
+function logExpr(op, left, right) { return Pattern({ type: "LogicalExpression", operator: op, left: left, right: right }) }
+function condExpr(test, cons, alt) { return Pattern({ type: "ConditionalExpression", test: test, consequent: cons, alternate: alt }) }
+function seqExpr(exprs) { return Pattern({ type: "SequenceExpression", expressions: exprs }) }
+function newExpr(callee, args) { return Pattern({ type: "NewExpression", callee: callee, arguments: args }) }
+function callExpr(callee, args) { return Pattern({ type: "CallExpression", callee: callee, arguments: args }) }
+function arrExpr(elts) { return Pattern({ type: "ArrayExpression", elements: elts }) }
+function objExpr(elts) { return Pattern({ type: "ObjectExpression", properties: elts }) }
+function objProp(key, value, kind) { return Pattern({ type: "Property", key: key, value: value, kind: kind }) }
+function arrPatt(elts) { return Pattern({ type: "ArrayPattern", elements: elts }) }
+function objPatt(elts) { return Pattern({ type: "ObjectPattern", properties: elts }) }
+function localSrc(src) { return "(function(){ " + src + " })" }
+function localPatt(patt) { return program([exprStmt(funExpr(null, [], blockStmt([patt])))]) }
+function blockSrc(src) { return "(function(){ { " + src + " } })" }
+function blockPatt(patt) { return program([exprStmt(funExpr(null, [], blockStmt([blockStmt([patt])])))]) }
+function assertBlockStmt(src, patt) {
+    blockPatt(patt).assert(Reflect.parse(blockSrc(src)));
+}
+function assertBlockExpr(src, patt) {
+    assertBlockStmt(src, exprStmt(patt));
+}
+function assertBlockDecl(src, patt, builder) {
+    blockPatt(patt).assert(Reflect.parse(blockSrc(src), {builder: builder}));
+}
+function assertLocalStmt(src, patt) {
+    localPatt(patt).assert(Reflect.parse(localSrc(src)));
+}
+function assertLocalExpr(src, patt) {
+    assertLocalStmt(src, exprStmt(patt));
+}
+function assertLocalDecl(src, patt) {
+    localPatt(patt).assert(Reflect.parse(localSrc(src)));
+}
+function assertGlobalStmt(src, patt, builder) {
+    program([patt]).assert(Reflect.parse(src, {builder: builder}));
+}
+function assertGlobalExpr(src, patt, builder) {
+    program([exprStmt(patt)]).assert(Reflect.parse(src, {builder: builder}));
+    //assertStmt(src, exprStmt(patt));
+}
+function assertGlobalDecl(src, patt) {
+    program([patt]).assert(Reflect.parse(src));
+}
+function assertProg(src, patt) {
+    program(patt).assert(Reflect.parse(src));
+}
+function assertStmt(src, patt) {
+    assertLocalStmt(src, patt);
+    assertGlobalStmt(src, patt);
+    assertBlockStmt(src, patt);
+}
+function assertExpr(src, patt) {
+    assertLocalExpr(src, patt);
+    assertGlobalExpr(src, patt);
+    assertBlockExpr(src, patt);
+}
+function assertDecl(src, patt) {
+    assertLocalDecl(src, patt);
+    assertGlobalDecl(src, patt);
+    assertBlockDecl(src, patt);
+}
+function assertError(src, errorType) {
+    try {
+        Reflect.parse(src);
+    } catch (e) {
+        return;
+    }
+    throw new Error("expected " + errorType.name + " for " + uneval(src));
+}
+// general tests
+// NB: These are useful but for now jit-test doesn't do I/O reliably.
+//program(_).assert(Reflect.parse(snarf('data/flapjax.txt')));
+//program(_).assert(Reflect.parse(snarf('data/jquery-1.4.2.txt')));
+//program(_).assert(Reflect.parse(snarf('data/prototype.js')));
+//program(_).assert(Reflect.parse(snarf('data/dojo.js.uncompressed.js')));
+//program(_).assert(Reflect.parse(snarf('data/mootools-1.2.4-core-nc.js')));
+// declarations
+assertDecl("var x = 1, y = 2, z = 3",
+           varDecl([declarator(ident("x"), lit(1)),
+                    declarator(ident("y"), lit(2)),
+                    declarator(ident("z"), lit(3))]));
+assertDecl("var x, y, z",
+           varDecl([declarator(ident("x"), null),
+                    declarator(ident("y"), null),
+                    declarator(ident("z"), null)]));
+assertDecl("function foo() { }",
+           funDecl(ident("foo"), [], blockStmt([])));
+assertDecl("function foo() { return 42 }",
+           funDecl(ident("foo"), [], blockStmt([returnStmt(lit(42))])));
+// Bug 591437: rebound args have their defs turned into uses
+assertDecl("function f(a) { function a() { } }",
+           funDecl(ident("f"), [ident("a")], blockStmt([funDecl(ident("a"), [], blockStmt([]))])));
+assertDecl("function f(a,b,c) { function b() { } }",
+           funDecl(ident("f"), [ident("a"),ident("b"),ident("c")], blockStmt([funDecl(ident("b"), [], blockStmt([]))])));
+// expressions
+assertExpr("true", lit(true));
+assertExpr("false", lit(false));
+assertExpr("42", lit(42));
+assertExpr("(/asdf/)", lit(/asdf/));
+assertExpr("this", thisExpr);
+assertExpr("foo", ident("foo"));
+assertExpr("foo.bar", dotExpr(ident("foo"), ident("bar")));
+assertExpr("foo[bar]", memExpr(ident("foo"), ident("bar")));
+assertExpr("(function(){})", funExpr(null, [], blockStmt([])));
+assertExpr("(function f() {})", funExpr(ident("f"), [], blockStmt([])));
+assertExpr("(function f(x,y,z) {})", funExpr(ident("f"), [ident("x"),ident("y"),ident("z")], blockStmt([])));
+assertExpr("(++x)", updExpr("++", ident("x"), true));
+assertExpr("(x++)", updExpr("++", ident("x"), false));
+assertExpr("(+x)", unExpr("+", ident("x")));
+assertExpr("(-x)", unExpr("-", ident("x")));
+assertExpr("(!x)", unExpr("!", ident("x")));
+assertExpr("(~x)", unExpr("~", ident("x")));
+assertExpr("(delete x)", unExpr("delete", ident("x")));
+assertExpr("(typeof x)", unExpr("typeof", ident("x")));
+assertExpr("(void x)", unExpr("void", ident("x")));
+assertExpr("(x == y)", binExpr("==", ident("x"), ident("y")));
+assertExpr("(x != y)", binExpr("!=", ident("x"), ident("y")));
+assertExpr("(x === y)", binExpr("===", ident("x"), ident("y")));
+assertExpr("(x !== y)", binExpr("!==", ident("x"), ident("y")));
+assertExpr("(x < y)", binExpr("<", ident("x"), ident("y")));
+assertExpr("(x <= y)", binExpr("<=", ident("x"), ident("y")));
+assertExpr("(x > y)", binExpr(">", ident("x"), ident("y")));
+assertExpr("(x >= y)", binExpr(">=", ident("x"), ident("y")));
+assertExpr("(x << y)", binExpr("<<", ident("x"), ident("y")));
+assertExpr("(x >> y)", binExpr(">>", ident("x"), ident("y")));
+assertExpr("(x >>> y)", binExpr(">>>", ident("x"), ident("y")));
+assertExpr("(x + y)", binExpr("+", ident("x"), ident("y")));
+assertExpr("(w + x + y + z)", binExpr("+", binExpr("+", binExpr("+", ident("w"), ident("x")), ident("y")), ident("z")));
+assertExpr("(x - y)", binExpr("-", ident("x"), ident("y")));
+assertExpr("(w - x - y - z)", binExpr("-", binExpr("-", binExpr("-", ident("w"), ident("x")), ident("y")), ident("z")));
+assertExpr("(x * y)", binExpr("*", ident("x"), ident("y")));
+assertExpr("(x / y)", binExpr("/", ident("x"), ident("y")));
+assertExpr("(x % y)", binExpr("%", ident("x"), ident("y")));
+assertExpr("(x | y)", binExpr("|", ident("x"), ident("y")));
+assertExpr("(x ^ y)", binExpr("^", ident("x"), ident("y")));
+assertExpr("(x & y)", binExpr("&", ident("x"), ident("y")));
+assertExpr("(x in y)", binExpr("in", ident("x"), ident("y")));
+assertExpr("(x instanceof y)", binExpr("instanceof", ident("x"), ident("y")));
+assertExpr("(x = y)", aExpr("=", ident("x"), ident("y")));
+assertExpr("(x += y)", aExpr("+=", ident("x"), ident("y")));
+assertExpr("(x -= y)", aExpr("-=", ident("x"), ident("y")));
+assertExpr("(x *= y)", aExpr("*=", ident("x"), ident("y")));
+assertExpr("(x /= y)", aExpr("/=", ident("x"), ident("y")));
+assertExpr("(x %= y)", aExpr("%=", ident("x"), ident("y")));
+assertExpr("(x <<= y)", aExpr("<<=", ident("x"), ident("y")));
+assertExpr("(x >>= y)", aExpr(">>=", ident("x"), ident("y")));
+assertExpr("(x >>>= y)", aExpr(">>>=", ident("x"), ident("y")));
+assertExpr("(x |= y)", aExpr("|=", ident("x"), ident("y")));
+assertExpr("(x ^= y)", aExpr("^=", ident("x"), ident("y")));
+assertExpr("(x &= y)", aExpr("&=", ident("x"), ident("y")));
+assertExpr("(x || y)", logExpr("||", ident("x"), ident("y")));
+assertExpr("(x && y)", logExpr("&&", ident("x"), ident("y")));
+assertExpr("(w || x || y || z)", logExpr("||", logExpr("||", logExpr("||", ident("w"), ident("x")), ident("y")), ident("z")))
+assertExpr("(x ? y : z)", condExpr(ident("x"), ident("y"), ident("z")));
+assertExpr("(x,y)", seqExpr([ident("x"),ident("y")]))
+assertExpr("(x,y,z)", seqExpr([ident("x"),ident("y"),ident("z")]))
+assertExpr("(a,b,c,d,e,f,g)", seqExpr([ident("a"),ident("b"),ident("c"),ident("d"),ident("e"),ident("f"),ident("g")]));
+assertExpr("(new Object)", newExpr(ident("Object"), []));
+assertExpr("(new Object())", newExpr(ident("Object"), []));
+assertExpr("(new Object(42))", newExpr(ident("Object"), [lit(42)]));
+assertExpr("(new Object(1,2,3))", newExpr(ident("Object"), [lit(1),lit(2),lit(3)]));
+assertExpr("(String())", callExpr(ident("String"), []));
+assertExpr("(String(42))", callExpr(ident("String"), [lit(42)]));
+assertExpr("(String(1,2,3))", callExpr(ident("String"), [lit(1),lit(2),lit(3)]));
+assertExpr("[]", arrExpr([]));
+assertExpr("[1]", arrExpr([lit(1)]));
+assertExpr("[1,2]", arrExpr([lit(1),lit(2)]));
+assertExpr("[1,2,3]", arrExpr([lit(1),lit(2),lit(3)]));
+assertExpr("[1,,2,3]", arrExpr([lit(1),,lit(2),lit(3)]));
+assertExpr("[1,,,2,3]", arrExpr([lit(1),,,lit(2),lit(3)]));
+assertExpr("[1,,,2,,3]", arrExpr([lit(1),,,lit(2),,lit(3)]));
+assertExpr("[1,,,2,,,3]", arrExpr([lit(1),,,lit(2),,,lit(3)]));
+assertExpr("[,1,2,3]", arrExpr([,lit(1),lit(2),lit(3)]));
+assertExpr("[,,1,2,3]", arrExpr([,,lit(1),lit(2),lit(3)]));
+assertExpr("[,,,1,2,3]", arrExpr([,,,lit(1),lit(2),lit(3)]));
+assertExpr("[,,,1,2,3,]", arrExpr([,,,lit(1),lit(2),lit(3)]));
+assertExpr("[,,,1,2,3,,]", arrExpr([,,,lit(1),lit(2),lit(3),undefined]));
+assertExpr("[,,,1,2,3,,,]", arrExpr([,,,lit(1),lit(2),lit(3),undefined,undefined]));
+assertExpr("[,,,,,]", arrExpr([undefined,undefined,undefined,undefined,undefined]));
+assertExpr("({})", objExpr([]));
+assertExpr("({x:1})", objExpr([objProp(ident("x"), lit(1), "init")]));
+assertExpr("({x:1, y:2})", objExpr([objProp(ident("x"), lit(1), "init"),
+                                    objProp(ident("y"), lit(2), "init")]));
+assertExpr("({x:1, y:2, z:3})", objExpr([objProp(ident("x"), lit(1), "init"),
+                                         objProp(ident("y"), lit(2), "init"),
+                                         objProp(ident("z"), lit(3), "init") ]));
+assertExpr("({x:1, 'y':2, z:3})", objExpr([objProp(ident("x"), lit(1), "init"),
+                                           objProp(lit("y"), lit(2), "init"),
+                                           objProp(ident("z"), lit(3), "init") ]));
+assertExpr("({'x':1, 'y':2, z:3})", objExpr([objProp(lit("x"), lit(1), "init"),
+                                             objProp(lit("y"), lit(2), "init"),
+                                             objProp(ident("z"), lit(3), "init") ]));
+assertExpr("({'x':1, 'y':2, 3:3})", objExpr([objProp(lit("x"), lit(1), "init"),
+                                             objProp(lit("y"), lit(2), "init"),
+                                             objProp(lit(3), lit(3), "init") ]));
+// Bug 571617: eliminate constant-folding
+assertExpr("2 + 3", binExpr("+", lit(2), lit(3)));
+// Bug 632026: constant-folding
+assertExpr("typeof(0?0:a)", unExpr("typeof", condExpr(lit(0), lit(0), ident("a"))));
+// Bug 632056: constant-folding
+program([exprStmt(ident("f")),
+         ifStmt(lit(1),
+                funDecl(ident("f"), [], blockStmt([])),
+                null)]).assert(Reflect.parse("f; if (1) function f(){}"));
+// statements
+assertStmt("throw 42", throwStmt(lit(42)));
+assertStmt("for (;;) break", forStmt(null, null, null, breakStmt(null)));
+assertStmt("for (x; y; z) break", forStmt(ident("x"), ident("y"), ident("z"), breakStmt(null)));
+assertStmt("for (var x; y; z) break", forStmt(varDecl([declarator(ident("x"), null)]), ident("y"), ident("z"), breakStmt(null)));
+assertStmt("for (var x = 42; y; z) break", forStmt(varDecl([declarator(ident("x"), lit(42))]), ident("y"), ident("z"), breakStmt(null)));
+assertStmt("for (x; ; z) break", forStmt(ident("x"), null, ident("z"), breakStmt(null)));
+assertStmt("for (var x; ; z) break", forStmt(varDecl([declarator(ident("x"), null)]), null, ident("z"), breakStmt(null)));
+assertStmt("for (var x = 42; ; z) break", forStmt(varDecl([declarator(ident("x"), lit(42))]), null, ident("z"), breakStmt(null)));
+assertStmt("for (x; y; ) break", forStmt(ident("x"), ident("y"), null, breakStmt(null)));
+assertStmt("for (var x; y; ) break", forStmt(varDecl([declarator(ident("x"), null)]), ident("y"), null, breakStmt(null)));
+assertStmt("for (var x = 42; y; ) break", forStmt(varDecl([declarator(ident("x"),lit(42))]), ident("y"), null, breakStmt(null)));
+assertStmt("for (var x in y) break", forInStmt(varDecl([declarator(ident("x"),null)]), ident("y"), breakStmt(null)));
+assertStmt("for (x in y) break", forInStmt(ident("x"), ident("y"), breakStmt(null)));
+assertStmt("{ }", blockStmt([]));
+assertStmt("{ throw 1; throw 2; throw 3; }", blockStmt([ throwStmt(lit(1)), throwStmt(lit(2)), throwStmt(lit(3))]));
+assertStmt(";", emptyStmt);
+assertStmt("if (foo) throw 42;", ifStmt(ident("foo"), throwStmt(lit(42)), null));
+assertStmt("if (foo) throw 42; else true;", ifStmt(ident("foo"), throwStmt(lit(42)), exprStmt(lit(true))));
+assertStmt("if (foo) { throw 1; throw 2; throw 3; }",
+           ifStmt(ident("foo"),
+                  blockStmt([throwStmt(lit(1)), throwStmt(lit(2)), throwStmt(lit(3))]),
+                  null));
+assertStmt("if (foo) { throw 1; throw 2; throw 3; } else true;",
+           ifStmt(ident("foo"),
+                  blockStmt([throwStmt(lit(1)), throwStmt(lit(2)), throwStmt(lit(3))]),
+                  exprStmt(lit(true))));
+assertStmt("foo: for(;;) break foo;", labStmt(ident("foo"), forStmt(null, null, null, breakStmt(ident("foo")))));
+assertStmt("foo: for(;;) continue foo;", labStmt(ident("foo"), forStmt(null, null, null, continueStmt(ident("foo")))));
+assertStmt("with (obj) { }", withStmt(ident("obj"), blockStmt([])));
+assertStmt("with (obj) { obj; }", withStmt(ident("obj"), blockStmt([exprStmt(ident("obj"))])));
+assertStmt("while (foo) { }", whileStmt(ident("foo"), blockStmt([])));
+assertStmt("while (foo) { foo; }", whileStmt(ident("foo"), blockStmt([exprStmt(ident("foo"))])));
+assertStmt("do { } while (foo);", doStmt(blockStmt([]), ident("foo")));
+assertStmt("do { foo; } while (foo)", doStmt(blockStmt([exprStmt(ident("foo"))]), ident("foo")));
+assertStmt("switch (foo) { case 1: 1; break; case 2: 2; break; default: 3; }",
+           switchStmt(ident("foo"),
+                      [ caseClause(lit(1), [ exprStmt(lit(1)), breakStmt(null) ]),
+                        caseClause(lit(2), [ exprStmt(lit(2)), breakStmt(null) ]),
+                        defaultClause([ exprStmt(lit(3)) ]) ]));
+assertStmt("switch (foo) { case 1: 1; break; case 2: 2; break; default: 3; case 42: 42; }",
+           switchStmt(ident("foo"),
+                      [ caseClause(lit(1), [ exprStmt(lit(1)), breakStmt(null) ]),
+                        caseClause(lit(2), [ exprStmt(lit(2)), breakStmt(null) ]),
+                        defaultClause([ exprStmt(lit(3)) ]),
+                        caseClause(lit(42), [ exprStmt(lit(42)) ]) ]));
+assertStmt("try { } catch (e) { }",
+           tryStmt(blockStmt([]),
+                   [],
+                   [ catchClause(ident("e"), null, blockStmt([])) ],
+                   null));
+assertStmt("try { } catch (e) { } finally { }",
+           tryStmt(blockStmt([]),
+                   [],
+                   [ catchClause(ident("e"), null, blockStmt([])) ],
+                   blockStmt([])));
+assertStmt("try { } finally { }",
+           tryStmt(blockStmt([]),
+                   [],
+                   [],
+                   blockStmt([])));
+// redeclarations (TOK_NAME nodes with lexdef)
+assertStmt("function f() { function g() { } function g() { } }",
+           funDecl(ident("f"), [], blockStmt([funDecl(ident("g"), [], blockStmt([])),
+                                              funDecl(ident("g"), [], blockStmt([]))])));
+assertStmt("function f() { function g() { } function g() { return 42 } }",
+           funDecl(ident("f"), [], blockStmt([funDecl(ident("g"), [], blockStmt([])),
+                                              funDecl(ident("g"), [], blockStmt([returnStmt(lit(42))]))])));
+assertStmt("function f() { var x = 42; var x = 43; }",
+           funDecl(ident("f"), [], blockStmt([varDecl([declarator(ident("x"),lit(42))]),
+                                              varDecl([declarator(ident("x"),lit(43))])])));
+// getters and setters
+ assertExpr("({ get x() { return 42 } })",
+            objExpr([ objProp(ident("x"),
+                              funExpr(null, [], blockStmt([returnStmt(lit(42))])),
+                              "get" ) ]));
+ assertExpr("({ set x(v) { return 42 } })",
+            objExpr([ objProp(ident("x"),
+                              funExpr(null, [ident("v")], blockStmt([returnStmt(lit(42))])),
+                              "set" ) ]));
+}
+exports.testReflect = testReflect;
+}(typeof exports === 'undefined' ? this : exports));