snowball 0.1.21 → 0.1.22

data/node_modules/browserify/node_modules/syntax-error/node_modules/esprima/test/3rdparty/jsdefs.js

@@ -0,0 +1,731 @@
+/* vim: set sw=4 ts=4 et tw=78: */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is the Narcissus JavaScript engine.
+ *
+ * The Initial Developer of the Original Code is
+ * Brendan Eich <brendan@mozilla.org>.
+ * Portions created by the Initial Developer are Copyright (C) 2004
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Tom Austin <taustin@ucsc.edu>
+ *   Brendan Eich <brendan@mozilla.org>
+ *   Shu-Yu Guo <shu@rfrn.org>
+ *   Dave Herman <dherman@mozilla.com>
+ *   Dimitris Vardoulakis <dimvar@ccs.neu.edu>
+ *   Patrick Walton <pcwalton@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+/*
+ * Narcissus - JS implemented in JS.
+ *
+ * Well-known constants and lookup tables.  Many consts are generated from the
+ * tokens table via eval to minimize redundancy, so consumers must be compiled
+ * separately to take advantage of the simple switch-case constant propagation
+ * done by SpiderMonkey.
+ */
+
+(function() {
+
+    var narcissus = {
+        options: {
+            version: 185,
+            // Global variables to hide from the interpreter
+            hiddenHostGlobals: { Narcissus: true },
+            // Desugar SpiderMonkey language extensions?
+            desugarExtensions: false,
+            // Allow HTML comments?
+            allowHTMLComments: false
+        },
+        hostSupportsEvalConst: (function() {
+            try {
+                return eval("(function(s) { eval(s); return x })('const x = true;')");
+            } catch (e) {
+                return false;
+            }
+        })(),
+        hostGlobal: this
+    };
+    Narcissus = narcissus;
+})();
+
+Narcissus.definitions = (function() {
+
+    var tokens = [
+        // End of source.
+        "END",
+
+        // Operators and punctuators.  Some pair-wise order matters, e.g. (+, -)
+        // and (UNARY_PLUS, UNARY_MINUS).
+        "\n", ";",
+        ",",
+        "=",
+        "?", ":", "CONDITIONAL",
+        "||",
+        "&&",
+        "|",
+        "^",
+        "&",
+        "==", "!=", "===", "!==",
+        "<", "<=", ">=", ">",
+        "<<", ">>", ">>>",
+        "+", "-",
+        "*", "/", "%",
+        "!", "~", "UNARY_PLUS", "UNARY_MINUS",
+        "++", "--",
+        ".",
+        "[", "]",
+        "{", "}",
+        "(", ")",
+
+        // Nonterminal tree node type codes.
+        "SCRIPT", "BLOCK", "LABEL", "FOR_IN", "CALL", "NEW_WITH_ARGS", "INDEX",
+        "ARRAY_INIT", "OBJECT_INIT", "PROPERTY_INIT", "GETTER", "SETTER",
+        "GROUP", "LIST", "LET_BLOCK", "ARRAY_COMP", "GENERATOR", "COMP_TAIL",
+
+        // Terminals.
+        "IDENTIFIER", "NUMBER", "STRING", "REGEXP",
+
+        // Keywords.
+        "break",
+        "case", "catch", "const", "continue",
+        "debugger", "default", "delete", "do",
+        "else", "export",
+        "false", "finally", "for", "function",
+        "if", "import", "in", "instanceof",
+        "let", "module",
+        "new", "null",
+        "return",
+        "switch",
+        "this", "throw", "true", "try", "typeof",
+        "var", "void",
+        "yield",
+        "while", "with",
+    ];
+
+    var statementStartTokens = [
+        "break",
+        "const", "continue",
+        "debugger", "do",
+        "for",
+        "if",
+        "return",
+        "switch",
+        "throw", "try",
+        "var",
+        "yield",
+        "while", "with",
+    ];
+
+    // Whitespace characters (see ECMA-262 7.2)
+    var whitespaceChars = [
+        // normal whitespace:
+        "\u0009", "\u000B", "\u000C", "\u0020", "\u00A0", "\uFEFF", 
+
+        // high-Unicode whitespace:
+        "\u1680", "\u180E",
+        "\u2000", "\u2001", "\u2002", "\u2003", "\u2004", "\u2005", "\u2006",
+        "\u2007", "\u2008", "\u2009", "\u200A",
+        "\u202F", "\u205F", "\u3000"
+    ];
+
+    var whitespace = {};
+    for (var i = 0; i < whitespaceChars.length; i++) {
+        whitespace[whitespaceChars[i]] = true;
+    }
+
+    // Operator and punctuator mapping from token to tree node type name.
+    // NB: because the lexer doesn't backtrack, all token prefixes must themselves
+    // be valid tokens (e.g. !== is acceptable because its prefixes are the valid
+    // tokens != and !).
+    var opTypeNames = {
+        '\n':   "NEWLINE",
+        ';':    "SEMICOLON",
+        ',':    "COMMA",
+        '?':    "HOOK",
+        ':':    "COLON",
+        '||':   "OR",
+        '&&':   "AND",
+        '|':    "BITWISE_OR",
+        '^':    "BITWISE_XOR",
+        '&':    "BITWISE_AND",
+        '===':  "STRICT_EQ",
+        '==':   "EQ",
+        '=':    "ASSIGN",
+        '!==':  "STRICT_NE",
+        '!=':   "NE",
+        '<<':   "LSH",
+        '<=':   "LE",
+        '<':    "LT",
+        '>>>':  "URSH",
+        '>>':   "RSH",
+        '>=':   "GE",
+        '>':    "GT",
+        '++':   "INCREMENT",
+        '--':   "DECREMENT",
+        '+':    "PLUS",
+        '-':    "MINUS",
+        '*':    "MUL",
+        '/':    "DIV",
+        '%':    "MOD",
+        '!':    "NOT",
+        '~':    "BITWISE_NOT",
+        '.':    "DOT",
+        '[':    "LEFT_BRACKET",
+        ']':    "RIGHT_BRACKET",
+        '{':    "LEFT_CURLY",
+        '}':    "RIGHT_CURLY",
+        '(':    "LEFT_PAREN",
+        ')':    "RIGHT_PAREN"
+    };
+
+    // Hash of keyword identifier to tokens index.  NB: we must null __proto__ to
+    // avoid toString, etc. namespace pollution.
+    var keywords = {__proto__: null};
+
+    // Define const END, etc., based on the token names.  Also map name to index.
+    var tokenIds = {};
+
+    // Building up a string to be eval'd in different contexts.
+    var consts = Narcissus.hostSupportsEvalConst ? "const " : "var ";
+    for (var i = 0, j = tokens.length; i < j; i++) {
+        if (i > 0)
+            consts += ", ";
+        var t = tokens[i];
+        var name;
+        if (/^[a-z]/.test(t)) {
+            name = t.toUpperCase();
+            keywords[t] = i;
+        } else {
+            name = (/^\W/.test(t) ? opTypeNames[t] : t);
+        }
+        consts += name + " = " + i;
+        tokenIds[name] = i;
+        tokens[t] = i;
+    }
+    consts += ";";
+
+    var isStatementStartCode = {__proto__: null};
+    for (i = 0, j = statementStartTokens.length; i < j; i++)
+        isStatementStartCode[keywords[statementStartTokens[i]]] = true;
+
+    // Map assignment operators to their indexes in the tokens array.
+    var assignOps = ['|', '^', '&', '<<', '>>', '>>>', '+', '-', '*', '/', '%'];
+
+    for (i = 0, j = assignOps.length; i < j; i++) {
+        t = assignOps[i];
+        assignOps[t] = tokens[t];
+    }
+
+    function defineGetter(obj, prop, fn, dontDelete, dontEnum) {
+        Object.defineProperty(obj, prop,
+                              { get: fn, configurable: !dontDelete, enumerable: !dontEnum });
+    }
+
+    function defineGetterSetter(obj, prop, getter, setter, dontDelete, dontEnum) {
+        Object.defineProperty(obj, prop, {
+            get: getter,
+            set: setter,
+            configurable: !dontDelete,
+            enumerable: !dontEnum
+        });
+    }
+
+    function defineMemoGetter(obj, prop, fn, dontDelete, dontEnum) {
+        Object.defineProperty(obj, prop, {
+            get: function() {
+                var val = fn();
+                defineProperty(obj, prop, val, dontDelete, true, dontEnum);
+                return val;
+            },
+            configurable: true,
+            enumerable: !dontEnum
+        });
+    }
+
+    function defineProperty(obj, prop, val, dontDelete, readOnly, dontEnum) {
+        Object.defineProperty(obj, prop,
+                              { value: val, writable: !readOnly, configurable: !dontDelete,
+                                enumerable: !dontEnum });
+    }
+
+    // Returns true if fn is a native function.  (Note: SpiderMonkey specific.)
+    function isNativeCode(fn) {
+        // Relies on the toString method to identify native code.
+        return ((typeof fn) === "function") && fn.toString().match(/\[native code\]/);
+    }
+
+    var Fpapply = Function.prototype.apply;
+
+    function apply(f, o, a) {
+        return Fpapply.call(f, [o].concat(a));
+    }
+
+    var applyNew;
+
+    // ES5's bind is a simpler way to implement applyNew
+    if (Function.prototype.bind) {
+        applyNew = function applyNew(f, a) {
+            return new (f.bind.apply(f, [,].concat(a)))();
+        };
+    } else {
+        applyNew = function applyNew(f, a) {
+            switch (a.length) {
+              case 0:
+                return new f();
+              case 1:
+                return new f(a[0]);
+              case 2:
+                return new f(a[0], a[1]);
+              case 3:
+                return new f(a[0], a[1], a[2]);
+              default:
+                var argStr = "a[0]";
+                for (var i = 1, n = a.length; i < n; i++)
+                    argStr += ",a[" + i + "]";
+                return eval("new f(" + argStr + ")");
+            }
+        };
+    }
+
+    function getPropertyDescriptor(obj, name) {
+        while (obj) {
+            if (({}).hasOwnProperty.call(obj, name))
+                return Object.getOwnPropertyDescriptor(obj, name);
+            obj = Object.getPrototypeOf(obj);
+        }
+    }
+
+    function getPropertyNames(obj) {
+        var table = Object.create(null, {});
+        while (obj) {
+            var names = Object.getOwnPropertyNames(obj);
+            for (var i = 0, n = names.length; i < n; i++)
+                table[names[i]] = true;
+            obj = Object.getPrototypeOf(obj);
+        }
+        return Object.keys(table);
+    }
+
+    function getOwnProperties(obj) {
+        var map = {};
+        for (var name in Object.getOwnPropertyNames(obj))
+            map[name] = Object.getOwnPropertyDescriptor(obj, name);
+        return map;
+    }
+
+    function blacklistHandler(target, blacklist) {
+        var mask = Object.create(null, {});
+        var redirect = StringMap.create(blacklist).mapObject(function(name) { return mask; });
+        return mixinHandler(redirect, target);
+    }
+
+    function whitelistHandler(target, whitelist) {
+        var catchall = Object.create(null, {});
+        var redirect = StringMap.create(whitelist).mapObject(function(name) { return target; });
+        return mixinHandler(redirect, catchall);
+    }
+
+    function mirrorHandler(target, writable) {
+        var handler = makePassthruHandler(target);
+
+        var defineProperty = handler.defineProperty;
+        handler.defineProperty = function(name, desc) {
+            if (!desc.enumerable)
+                throw new Error("mirror property must be enumerable");
+            if (!desc.configurable)
+                throw new Error("mirror property must be configurable");
+            if (desc.writable !== writable)
+                throw new Error("mirror property must " + (writable ? "" : "not ") + "be writable");
+            defineProperty(name, desc);
+        };
+
+        handler.fix = function() { };
+        handler.getOwnPropertyDescriptor = handler.getPropertyDescriptor;
+        handler.getOwnPropertyNames = getPropertyNames.bind(handler, target);
+        handler.keys = handler.enumerate;
+        handler["delete"] = function() { return false; };
+        handler.hasOwn = handler.has;
+        return handler;
+    }
+
+    /*
+     * Mixin proxies break the single-inheritance model of prototypes, so
+     * the handler treats all properties as own-properties:
+     *
+     *                  X
+     *                  |
+     *     +------------+------------+
+     *     |                 O       |
+     *     |                 |       |
+     *     |  O         O    O       |
+     *     |  |         |    |       |
+     *     |  O    O    O    O       |
+     *     |  |    |    |    |       |
+     *     |  O    O    O    O    O  |
+     *     |  |    |    |    |    |  |
+     *     +-(*)--(w)--(x)--(y)--(z)-+
+     */
+
+    function mixinHandler(redirect, catchall) {
+        function targetFor(name) {
+            return hasOwn(redirect, name) ? redirect[name] : catchall;
+        }
+
+        function getMuxPropertyDescriptor(name) {
+            var desc = getPropertyDescriptor(targetFor(name), name);
+            if (desc)
+                desc.configurable = true;
+            return desc;
+        }
+
+        function getMuxPropertyNames() {
+            var names1 = Object.getOwnPropertyNames(redirect).filter(function(name) {
+                return name in redirect[name];
+            });
+            var names2 = getPropertyNames(catchall).filter(function(name) {
+                return !hasOwn(redirect, name);
+            });
+            return names1.concat(names2);
+        }
+
+        function enumerateMux() {
+            var result = Object.getOwnPropertyNames(redirect).filter(function(name) {
+                return name in redirect[name];
+            });
+            for (name in catchall) {
+                if (!hasOwn(redirect, name))
+                    result.push(name);
+            };
+            return result;
+        }
+
+        function hasMux(name) {
+            return name in targetFor(name);
+        }
+
+        return {
+            getOwnPropertyDescriptor: getMuxPropertyDescriptor,
+            getPropertyDescriptor: getMuxPropertyDescriptor,
+            getOwnPropertyNames: getMuxPropertyNames,
+            defineProperty: function(name, desc) {
+                Object.defineProperty(targetFor(name), name, desc);
+            },
+            "delete": function(name) {
+                var target = targetFor(name);
+                return delete target[name];
+            },
+            // FIXME: ha ha ha
+            fix: function() { },
+            has: hasMux,
+            hasOwn: hasMux,
+            get: function(receiver, name) {
+                var target = targetFor(name);
+                return target[name];
+            },
+            set: function(receiver, name, val) {
+                var target = targetFor(name);
+                target[name] = val;
+                return true;
+            },
+            enumerate: enumerateMux,
+            keys: enumerateMux
+        };
+    }
+
+    function makePassthruHandler(obj) {
+        // Handler copied from
+        // http://wiki.ecmascript.org/doku.php?id=harmony:proxies&s=proxy%20object#examplea_no-op_forwarding_proxy
+        return {
+            getOwnPropertyDescriptor: function(name) {
+                var desc = Object.getOwnPropertyDescriptor(obj, name);
+
+                // a trapping proxy's properties must always be configurable
+                desc.configurable = true;
+                return desc;
+            },
+            getPropertyDescriptor: function(name) {
+                var desc = getPropertyDescriptor(obj, name);
+
+                // a trapping proxy's properties must always be configurable
+                desc.configurable = true;
+                return desc;
+            },
+            getOwnPropertyNames: function() {
+                return Object.getOwnPropertyNames(obj);
+            },
+            defineProperty: function(name, desc) {
+                Object.defineProperty(obj, name, desc);
+            },
+            "delete": function(name) { return delete obj[name]; },
+            fix: function() {
+                if (Object.isFrozen(obj)) {
+                    return getOwnProperties(obj);
+                }
+
+                // As long as obj is not frozen, the proxy won't allow itself to be fixed.
+                return undefined; // will cause a TypeError to be thrown
+            },
+
+            has: function(name) { return name in obj; },
+            hasOwn: function(name) { return ({}).hasOwnProperty.call(obj, name); },
+            get: function(receiver, name) { return obj[name]; },
+
+            // bad behavior when set fails in non-strict mode
+            set: function(receiver, name, val) { obj[name] = val; return true; },
+            enumerate: function() {
+                var result = [];
+                for (name in obj) { result.push(name); };
+                return result;
+            },
+            keys: function() { return Object.keys(obj); }
+        };
+    }
+
+    var hasOwnProperty = ({}).hasOwnProperty;
+
+    function hasOwn(obj, name) {
+        return hasOwnProperty.call(obj, name);
+    }
+
+    function StringMap(table, size) {
+        this.table = table || Object.create(null, {});
+        this.size = size || 0;
+    }
+
+    StringMap.create = function(table) {
+        var init = Object.create(null, {});
+        var size = 0;
+        var names = Object.getOwnPropertyNames(table);
+        for (var i = 0, n = names.length; i < n; i++) {
+            var name = names[i];
+            init[name] = table[name];
+            size++;
+        }
+        return new StringMap(init, size);
+    };
+
+    StringMap.prototype = {
+        has: function(x) { return hasOwnProperty.call(this.table, x); },
+        set: function(x, v) {
+            if (!hasOwnProperty.call(this.table, x))
+                this.size++;
+            this.table[x] = v;
+        },
+        get: function(x) { return this.table[x]; },
+        getDef: function(x, thunk) {
+            if (!hasOwnProperty.call(this.table, x)) {
+                this.size++;
+                this.table[x] = thunk();
+            }
+            return this.table[x];
+        },
+        forEach: function(f) {
+            var table = this.table;
+            for (var key in table)
+                f.call(this, key, table[key]);
+        },
+        map: function(f) {
+            var table1 = this.table;
+            var table2 = Object.create(null, {});
+            this.forEach(function(key, val) {
+                table2[key] = f.call(this, val, key);
+            });
+            return new StringMap(table2, this.size);
+        },
+        mapObject: function(f) {
+            var table1 = this.table;
+            var table2 = Object.create(null, {});
+            this.forEach(function(key, val) {
+                table2[key] = f.call(this, val, key);
+            });
+            return table2;
+        },
+        toObject: function() {
+            return this.mapObject(function(val) { return val; });
+        },
+        choose: function() {
+            return Object.getOwnPropertyNames(this.table)[0];
+        },
+        remove: function(x) {
+            if (hasOwnProperty.call(this.table, x)) {
+                this.size--;
+                delete this.table[x];
+            }
+        },
+        copy: function() {
+            var table = Object.create(null, {});
+            for (var key in this.table)
+                table[key] = this.table[key];
+            return new StringMap(table, this.size);
+        },
+        keys: function() {
+            return Object.keys(this.table);
+        },
+        toString: function() { return "[object StringMap]" }
+    };
+
+    // an object-key table with poor asymptotics (replace with WeakMap when possible)
+    function ObjectMap(array) {
+        this.array = array || [];
+    }
+
+    function searchMap(map, key, found, notFound) {
+        var a = map.array;
+        for (var i = 0, n = a.length; i < n; i++) {
+            var pair = a[i];
+            if (pair.key === key)
+                return found(pair, i);
+        }
+        return notFound();
+    }
+
+    ObjectMap.prototype = {
+        has: function(x) {
+            return searchMap(this, x, function() { return true }, function() { return false });
+        },
+        set: function(x, v) {
+            var a = this.array;
+            searchMap(this, x,
+                      function(pair) { pair.value = v },
+                      function() { a.push({ key: x, value: v }) });
+        },
+        get: function(x) {
+            return searchMap(this, x,
+                             function(pair) { return pair.value },
+                             function() { return null });
+        },
+        getDef: function(x, thunk) {
+            var a = this.array;
+            return searchMap(this, x,
+                             function(pair) { return pair.value },
+                             function() {
+                                 var v = thunk();
+                                 a.push({ key: x, value: v });
+                                 return v;
+                             });
+        },
+        forEach: function(f) {
+            var a = this.array;
+            for (var i = 0, n = a.length; i < n; i++) {
+                var pair = a[i];
+                f.call(this, pair.key, pair.value);
+            }
+        },
+        choose: function() {
+            return this.array[0].key;
+        },
+        get size() {
+            return this.array.length;
+        },
+        remove: function(x) {
+            var a = this.array;
+            searchMap(this, x,
+                      function(pair, i) { a.splice(i, 1) },
+                      function() { });
+        },
+        copy: function() {
+            return new ObjectMap(this.array.map(function(pair) {
+                return { key: pair.key, value: pair.value }
+            }));
+        },
+        clear: function() {
+            this.array = [];
+        },
+        toString: function() { return "[object ObjectMap]" }
+    };
+
+    // non-destructive stack
+    function Stack(elts) {
+        this.elts = elts || null;
+    }
+
+    Stack.prototype = {
+        push: function(x) {
+            return new Stack({ top: x, rest: this.elts });
+        },
+        top: function() {
+            if (!this.elts)
+                throw new Error("empty stack");
+            return this.elts.top;
+        },
+        isEmpty: function() {
+            return this.top === null;
+        },
+        find: function(test) {
+            for (var elts = this.elts; elts; elts = elts.rest) {
+                if (test(elts.top))
+                    return elts.top;
+            }
+            return null;
+        },
+        has: function(x) {
+            return Boolean(this.find(function(elt) { return elt === x }));
+        },
+        forEach: function(f) {
+            for (var elts = this.elts; elts; elts = elts.rest) {
+                f(elts.top);
+            }
+        }
+    };
+
+    if (!Array.prototype.copy) {
+        Array.prototype.copy = function() {
+            var result = [];
+            for (var i = 0, n = this.length; i < n; i++)
+                result[i] = this[i];
+            return result;
+        };
+    }
+
+    return {
+        tokens: tokens,
+        whitespace: whitespace,
+        opTypeNames: opTypeNames,
+        keywords: keywords,
+        isStatementStartCode: isStatementStartCode,
+        tokenIds: tokenIds,
+        consts: consts,
+        assignOps: assignOps,
+        defineGetter: defineGetter,
+        defineGetterSetter: defineGetterSetter,
+        defineMemoGetter: defineMemoGetter,
+        defineProperty: defineProperty,
+        isNativeCode: isNativeCode,
+        apply: apply,
+        applyNew: applyNew,
+        mirrorHandler: mirrorHandler,
+        mixinHandler: mixinHandler,
+        whitelistHandler: whitelistHandler,
+        blacklistHandler: blacklistHandler,
+        makePassthruHandler: makePassthruHandler,
+        StringMap: StringMap,
+        ObjectMap: ObjectMap,
+        Stack: Stack
+    };
+}());