@dacely/toildefender 0.1.4 → 0.1.6

package/processors/normalizer.js

@@ -46,9 +46,358 @@ function blockToArray (node) {
     
     if (Array.isArray(node.body)) {
         return node.body;
-    } else {
+    } else if (node.body) {
         return [ node.body ];
+    } else {
+        return [ node ];
+    }
+}
+
+function hasSpreadElement(nodes) {
+    return nodes.some(node => node && node.type == "SpreadElement");
+}
+
+function isSimpleThisReceiver(node) {
+    return node.type == "Identifier" || node.type == "ThisExpression";
+}
+
+function buildArrayConcat(parts) {
+    if (parts.length == 0) {
+        return { type: "ArrayExpression", elements: [] };
+    }
+    if (parts.length == 1) {
+        return parts[0];
+    }
+    return {
+        type: "CallExpression",
+        callee: {
+            type: "MemberExpression",
+            object: parts[0],
+            property: { type: "Identifier", name: "concat" },
+            computed: false
+        },
+        arguments: parts.slice(1)
+    };
+}
+
+function spreadArgumentsToArray(args) {
+    var parts = [];
+    var pending = [];
+
+    function flushPending() {
+        if (pending.length > 0) {
+            parts.push({ type: "ArrayExpression", elements: pending });
+            pending = [];
+        }
+    }
+
+    args.forEach(arg => {
+        if (arg.type == "SpreadElement") {
+            flushPending();
+            parts.push(arg.argument);
+        } else {
+            pending.push(arg);
+        }
+    });
+    flushPending();
+
+    return buildArrayConcat(parts);
+}
+
+function isLoopOrSwitch(node) {
+    return node.type == "WhileStatement"
+        || node.type == "DoWhileStatement"
+        || node.type == "ForStatement"
+        || node.type == "ForInStatement"
+        || node.type == "ForOfStatement"
+        || node.type == "SwitchStatement";
+}
+
+function exitsCurrentTry(node, stack) {
+    if (node.type == "ReturnStatement") {
+        return true;
+    }
+
+    if (node.type == "BreakStatement" || node.type == "ContinueStatement") {
+        return !stack.some(frame => isLoopOrSwitch(frame.node));
+    }
+
+    return false;
+}
+
+function withFinalizerBefore(node, finalizer) {
+    var body = [];
+
+    if (node.type == "ReturnStatement") {
+        body.push({
+            type: "VariableDeclaration",
+            kind: "var",
+            declarations: [
+                {
+                    type: "VariableDeclarator",
+                    id: { type: "Identifier", name: "veilmark$return" },
+                    init: node.argument
+                }
+            ]
+        });
+        body.push(utils.cloneISwearIKnowWhatImDoing(finalizer));
+        body.push({
+            type: "ReturnStatement",
+            argument: { type: "Identifier", name: "veilmark$return" }
+        });
+    } else {
+        body.push(utils.cloneISwearIKnowWhatImDoing(finalizer));
+        body.push(node);
+    }
+
+    return {
+        type: "BlockStatement",
+        body: body
+    };
+}
+
+function methodDefinitionName(method) {
+    if (!method || !method.key) {
+        return "";
+    }
+    if (method.key.type == "Identifier") {
+        return method.key.name;
+    }
+    if (method.key.type == "Literal") {
+        return String(method.key.value);
+    }
+    return "";
+}
+
+function isConstructorMethod(method) {
+    return method.type == "MethodDefinition" && method.kind == "constructor" && methodDefinitionName(method) == "constructor";
+}
+
+function privateStoreName(className, privateName) {
+    return `$$private$${className}$${privateName}`;
+}
+
+function classFieldKey(field) {
+    if (field.key.type == "Identifier") {
+        return {
+            type: "Identifier",
+            name: field.key.name
+        };
+    }
+    if (field.key.type == "PrivateIdentifier") {
+        return {
+            type: "Literal",
+            value: field.key.name
+        };
+    }
+    return field.key;
+}
+
+function assignmentStatement(left, right) {
+    return {
+        type: "ExpressionStatement",
+        expression: {
+            type: "AssignmentExpression",
+            operator: "=",
+            left: left,
+            right: right || { type: "Identifier", name: "undefined" }
+        }
+    };
+}
+
+function weakMapSetStatement(storeName, object, value) {
+    return {
+        type: "ExpressionStatement",
+        expression: {
+            type: "CallExpression",
+            callee: {
+                type: "MemberExpression",
+                object: { type: "Identifier", name: storeName },
+                property: { type: "Identifier", name: "set" },
+                computed: false
+            },
+            arguments: [
+                object,
+                value || { type: "Identifier", name: "undefined" }
+            ]
+        }
+    };
+}
+
+function weakMapGetExpression(storeName, object) {
+    return {
+        type: "CallExpression",
+        callee: {
+            type: "MemberExpression",
+            object: { type: "Identifier", name: storeName },
+            property: { type: "Identifier", name: "get" },
+            computed: false
+        },
+        arguments: [ object ]
+    };
+}
+
+function undefinedExpression() {
+    return { type: "Identifier", name: "undefined" };
+}
+
+function nullishTest(expression) {
+    return {
+        type: "BinaryExpression",
+        operator: "==",
+        left: expression,
+        right: { type: "Literal", value: null }
+    };
+}
+
+function notNullishTest(expression) {
+    return {
+        type: "BinaryExpression",
+        operator: "!=",
+        left: expression,
+        right: { type: "Literal", value: null }
+    };
+}
+
+function propertyKeyValue(property) {
+    if (property.key.type == "Identifier") {
+        return property.key.name;
+    }
+    if (property.key.type == "Literal") {
+        return property.key.value;
+    }
+    return null;
+}
+
+function propertyMemberExpression(object, property) {
+    return {
+        type: "MemberExpression",
+        object: object,
+        property: property.key.type == "Identifier"
+            ? { type: "Identifier", name: property.key.name }
+            : utils.cloneISwearIKnowWhatImDoing(property.key),
+        computed: property.computed === true || property.key.type == "Literal"
+    };
+}
+
+function hasObjectRest(pattern) {
+    return pattern.type == "ObjectPattern" && pattern.properties.some(prop => prop.type == "RestElement");
+}
+
+function canLowerObjectRest(pattern) {
+    return pattern.type == "ObjectPattern" && pattern.properties.every(prop => {
+        if (prop.type == "RestElement") {
+            return prop.argument.type == "Identifier";
+        }
+        if (prop.type != "Property" || prop.computed === true || propertyKeyValue(prop) == null) {
+            return false;
+        }
+        if (prop.value.type == "Identifier") {
+            return true;
+        }
+        return prop.value.type == "AssignmentPattern" && prop.value.left.type == "Identifier";
+    });
+}
+
+function hasObjectSpread(node) {
+    return node.properties.some(prop => prop.type == "SpreadElement");
+}
+
+function objectAssignCall(parts) {
+    return {
+        type: "CallExpression",
+        callee: {
+            type: "MemberExpression",
+            object: { type: "Identifier", name: "Object" },
+            property: { type: "Identifier", name: "assign" },
+            computed: false
+        },
+        arguments: parts
+    };
+}
+
+function objectWithoutKeysCall(source, keys) {
+    return {
+        type: "CallExpression",
+        callee: { type: "Identifier", name: "veilmark$objectWithoutKeys" },
+        arguments: [
+            source,
+            {
+                type: "ArrayExpression",
+                elements: keys.map(key => ({ type: "Literal", value: key }))
+            }
+        ]
+    };
+}
+
+function objectPatternPropertyDeclaration(kind, sourceName, prop) {
+    var member = propertyMemberExpression(
+        { type: "Identifier", name: sourceName },
+        prop
+    );
+    var id = prop.value;
+    var init = member;
+
+    if (prop.value.type == "AssignmentPattern") {
+        id = prop.value.left;
+        init = {
+            type: "ConditionalExpression",
+            test: {
+                type: "BinaryExpression",
+                operator: "===",
+                left: utils.cloneISwearIKnowWhatImDoing(member),
+                right: undefinedExpression()
+            },
+            consequent: prop.value.right,
+            alternate: member
+        };
     }
+
+    return {
+        type: "VariableDeclaration",
+        kind: kind,
+        declarations: [
+            {
+                type: "VariableDeclarator",
+                id: id,
+                init: init
+            }
+        ]
+    };
+}
+
+function containsThisExpression(node) {
+    var found = false;
+    traverser.traverseEx(node, [], function (child) {
+        if (child.type == "ThisExpression") {
+            found = true;
+            this.abort();
+        }
+        return child;
+    });
+    return found;
+}
+
+function blockNeedsLexicalScope(node) {
+    if (node.type != "BlockStatement") {
+        return false;
+    }
+
+    var needsScope = false;
+    traverser.traverseEx(node, [], function (child) {
+        if (child != node && estest.isFunction(child)) {
+            return child;
+        }
+        if (
+            (child.type == "VariableDeclaration" && child.kind != "var")
+            || child.type == "ClassDeclaration"
+        ) {
+            needsScope = true;
+            this.abort();
+        }
+        return child;
+    });
+    return needsScope;
 }
 
 module.exports = class Normalizer {
@@ -79,10 +428,26 @@ module.exports = class Normalizer {
                     return this.simplifyForStatement(node);
                 case "ForInStatement":
                     return this.simplifyForStatement(this.simplifyForInStatement(node));
+                case "ForOfStatement":
+                    return this.simplifyForOfStatement(node);
                 /*case "SwitchStatement":
                     return this.simplifySwitchStatement(node);*/
                 case "TryStatement":
                     return this.simplifyTryStatement(node);
+                case "CallExpression":
+                    return this.simplifyCallExpression(node);
+                case "ChainExpression":
+                    return this.simplifyChainExpression(node);
+                case "LogicalExpression":
+                    return this.simplifyLogicalExpression(node);
+                case "ObjectExpression":
+                    return this.simplifyObjectExpression(node);
+                case "VariableDeclaration":
+                    return this.simplifyVariableDeclaration(node, stack);
+                case "ArrowFunctionExpression":
+                    return this.simplifyArrowFunctionExpression(node);
+                case "ClassDeclaration":
+                    return this.simplifyClassDeclaration(node);
                 default:
                     return node;
             }
@@ -98,10 +463,13 @@ module.exports = class Normalizer {
     simplifyBlockStatement (node) {
         assert.ok(estest.isNode(node));
     
-        function getBlockBodys(node) {
+        function getBlockBodys(node, isRoot) {
             if (node.type == "Program" || node.type == "BlockStatement") {
+                if (!isRoot && blockNeedsLexicalScope(node)) {
+                    return [ node ];
+                }
                 var stmts = [];
-                node.body.forEach(stmt => utils.push(stmts, getBlockBodys(stmt)));
+                node.body.forEach(stmt => utils.push(stmts, getBlockBodys(stmt, false)));
                 return stmts;
             } else {
                 return [ node ];
@@ -110,7 +478,7 @@ module.exports = class Normalizer {
         
         return {
             type: node.type,
-            body: getBlockBodys(node)
+            body: getBlockBodys(node, true)
         };
     }
 
@@ -299,6 +667,93 @@ module.exports = class Normalizer {
         return forStmt;
     }
 
+    /**
+     * Simplify ForOfStatement to an index-based ForStatement.
+     * @param {ForOfStatement} node
+     * @return {Node}
+     */
+    simplifyForOfStatement (node) {
+        assert.ok(estest.isNode(node));
+
+        var valuesName = `$$forof$values$${this.rngAlpha.get()}`, iterName = `$$forof$iter$${this.rngAlpha.get()}`;
+        var valueAtIndex = {
+            type: "MemberExpression",
+            object: { type: "Identifier", name: valuesName },
+            property: { type: "Identifier", name: iterName },
+            computed: true
+        };
+        var assignValue = node.left.type == "VariableDeclaration"
+        ?
+        {
+            type: "VariableDeclaration",
+            kind: node.left.kind == "const" ? "let" : node.left.kind,
+            declarations: [
+                {
+                    type: "VariableDeclarator",
+                    id: node.left.declarations[0].id,
+                    init: valueAtIndex
+                }
+            ]
+        }
+        :
+        {
+            type: "ExpressionStatement",
+            expression: {
+                type: "AssignmentExpression",
+                operator: "=",
+                left: node.left,
+                right: valueAtIndex
+            }
+        };
+
+        return {
+            type: "BlockStatement",
+            body: [
+                {
+                    type: "VariableDeclaration",
+                    kind: "var",
+                    declarations: [
+                        {
+                            type: "VariableDeclarator",
+                            id: { type: "Identifier", name: valuesName },
+                            init: node.right
+                        },
+                        {
+                            type: "VariableDeclarator",
+                            id: { type: "Identifier", name: iterName },
+                            init: { type: "Literal", value: 0 }
+                        }
+                    ]
+                },
+                {
+                    type: "ForStatement",
+                    init: null,
+                    test: {
+                        type: "BinaryExpression",
+                        operator: "<",
+                        left: { type: "Identifier", name: iterName },
+                        right: {
+                            type: "MemberExpression",
+                            object: { type: "Identifier", name: valuesName },
+                            property: { type: "Identifier", name: "length" },
+                            computed: false
+                        }
+                    },
+                    update: {
+                        type: "UpdateExpression",
+                        operator: "++",
+                        argument: { type: "Identifier", name: iterName },
+                        prefix: false
+                    },
+                    body: {
+                        type: "BlockStatement",
+                        body: [assignValue].concat(blockToArray(node.body))
+                    }
+                }
+            ]
+        };
+    }
+
     /**
      * Simplify SwitchStatement.
      * @param {SwitchStatement} node
@@ -416,28 +871,8 @@ module.exports = class Normalizer {
                     if (stack.some(x => estest.isFunction(x.node))) {
                         this.abort();
                         return node;
-                    } else if (node.type == "ReturnStatement") {
-                        return {
-                            type: "BlockStatement",
-                            body: [
-                                {
-                                    type: "VariableDeclaration",
-                                    kind: "var",
-                                    declarations: [
-                                        {
-                                            type: "VariableDeclarator",
-                                            id: { type: "Identifier", name: "veilmark$return" },
-                                            init: node.argument
-                                        }
-                                    ]
-                                },
-                                utils.cloneISwearIKnowWhatImDoing(finalizer),
-                                {
-                                    type: "ReturnStatement",
-                                    argument: { type: "Identifier", name: "veilmark$return" }
-                                }
-                            ]
-                        };
+                    } else if (exitsCurrentTry(node, stack)) {
+                        return withFinalizerBefore(node, finalizer);
                     } else {
                         return node;
                     }
@@ -487,4 +922,520 @@ module.exports = class Normalizer {
         }
     }
 
+    /**
+     * Lower simple spread calls like target.push(...items) to
+     * target.push.apply(target, items). This keeps append-style calls stable
+     * even when Babel is disabled.
+     * @param {CallExpression} node
+     * @return {Node}
+     */
+    simplifyCallExpression (node) {
+        assert.ok(estest.isNode(node));
+
+        if (!hasSpreadElement(node.arguments)) {
+            return node;
+        }
+
+        var thisArg = { type: "Literal", value: null };
+        if (node.callee.type == "MemberExpression") {
+            if (!isSimpleThisReceiver(node.callee.object)) {
+                return node;
+            }
+            thisArg = utils.cloneISwearIKnowWhatImDoing(node.callee.object);
+        }
+
+        return {
+            type: "CallExpression",
+            callee: {
+                type: "MemberExpression",
+                object: node.callee,
+                property: { type: "Identifier", name: "apply" },
+                computed: false
+            },
+            arguments: [
+                thisArg,
+                spreadArgumentsToArray(node.arguments)
+            ]
+        };
+    }
+
+    /**
+     * Lower optional chains to conditional expressions before legacy passes.
+     * This intentionally targets deterministic AST compatibility rather than
+     * Babel-perfect single-evaluation semantics for every exotic receiver.
+     * @param {ChainExpression} node
+     * @return {Node}
+     */
+    simplifyChainExpression (node) {
+        assert.ok(estest.isNode(node));
+
+        return this.lowerOptionalChain(node.expression);
+    }
+
+    lowerOptionalChain (node) {
+        if (node.type == "MemberExpression") {
+            var object = this.lowerOptionalChain(node.object);
+            var member = {
+                type: "MemberExpression",
+                object: utils.cloneISwearIKnowWhatImDoing(object),
+                property: node.property,
+                computed: node.computed === true
+            };
+            if (node.optional === true) {
+                return {
+                    type: "ConditionalExpression",
+                    test: nullishTest(utils.cloneISwearIKnowWhatImDoing(object)),
+                    consequent: undefinedExpression(),
+                    alternate: member
+                };
+            }
+            return member;
+        }
+
+        if (node.type == "CallExpression") {
+            if (node.callee.type == "MemberExpression") {
+                return this.lowerOptionalMemberCall(node);
+            }
+
+            var callee = this.lowerOptionalChain(node.callee);
+            var call = {
+                type: "CallExpression",
+                callee: utils.cloneISwearIKnowWhatImDoing(callee),
+                arguments: node.arguments,
+                optional: false
+            };
+            if (node.optional === true) {
+                return {
+                    type: "ConditionalExpression",
+                    test: nullishTest(utils.cloneISwearIKnowWhatImDoing(callee)),
+                    consequent: undefinedExpression(),
+                    alternate: call
+                };
+            }
+            return call;
+        }
+
+        return node;
+    }
+
+    lowerOptionalMemberCall (node) {
+        var member = node.callee;
+        var object = this.lowerOptionalChain(member.object);
+        var directMember = {
+            type: "MemberExpression",
+            object: utils.cloneISwearIKnowWhatImDoing(object),
+            property: member.property,
+            computed: member.computed === true
+        };
+
+        var alternate;
+        if (node.optional === true) {
+            alternate = {
+                type: "CallExpression",
+                callee: {
+                    type: "MemberExpression",
+                    object: utils.cloneISwearIKnowWhatImDoing(directMember),
+                    property: { type: "Identifier", name: "call" },
+                    computed: false
+                },
+                arguments: [ utils.cloneISwearIKnowWhatImDoing(object) ].concat(node.arguments),
+                optional: false
+            };
+            alternate = {
+                type: "ConditionalExpression",
+                test: nullishTest(utils.cloneISwearIKnowWhatImDoing(directMember)),
+                consequent: undefinedExpression(),
+                alternate: alternate
+            };
+        } else {
+            alternate = {
+                type: "CallExpression",
+                callee: directMember,
+                arguments: node.arguments,
+                optional: false
+            };
+        }
+
+        if (member.optional === true) {
+            return {
+                type: "ConditionalExpression",
+                test: nullishTest(utils.cloneISwearIKnowWhatImDoing(object)),
+                consequent: undefinedExpression(),
+                alternate: alternate
+            };
+        }
+
+        return alternate;
+    }
+
+    /**
+     * Lower nullish coalescing to an ES5-compatible conditional expression.
+     * @param {LogicalExpression} node
+     * @return {Node}
+     */
+    simplifyLogicalExpression (node) {
+        assert.ok(estest.isNode(node));
+
+        if (node.operator != "??") {
+            return node;
+        }
+
+        return {
+            type: "ConditionalExpression",
+            test: notNullishTest(utils.cloneISwearIKnowWhatImDoing(node.left)),
+            consequent: node.left,
+            alternate: node.right
+        };
+    }
+
+    /**
+     * Lower object spread to Object.assign({}, ...parts).
+     * @param {ObjectExpression} node
+     * @return {Node}
+     */
+    simplifyObjectExpression (node) {
+        assert.ok(estest.isNode(node));
+
+        if (!hasObjectSpread(node)) {
+            return node;
+        }
+
+        var parts = [
+            {
+                type: "ObjectExpression",
+                properties: []
+            }
+        ];
+        var pending = [];
+
+        function flushPending() {
+            if (pending.length > 0) {
+                parts.push({
+                    type: "ObjectExpression",
+                    properties: pending
+                });
+                pending = [];
+            }
+        }
+
+        node.properties.forEach(prop => {
+            if (prop.type == "SpreadElement") {
+                flushPending();
+                parts.push(prop.argument);
+            } else {
+                pending.push(prop);
+            }
+        });
+        flushPending();
+
+        return objectAssignCall(parts);
+    }
+
+    /**
+     * Lower simple object rest declarations:
+     *   const { a, ...rest } = source
+     * becomes:
+     *   var tmp = source; var a = tmp.a; var rest = withoutKeys(tmp, ["a"])
+     * @param {VariableDeclaration} node
+     * @param {Node[]} stack
+     * @return {Node}
+     */
+    simplifyVariableDeclaration (node, stack) {
+        assert.ok(estest.isNode(node));
+
+        if (!node.declarations.some(decl => hasObjectRest(decl.id))) {
+            return node;
+        }
+        if (node.declarations.some(decl => hasObjectRest(decl.id) && !canLowerObjectRest(decl.id))) {
+            return node;
+        }
+
+        var parentFrame = stack[1];
+        if (parentFrame && parentFrame.node.type == "ForStatement" && parentFrame.key == "init") {
+            return node;
+        }
+
+        var statements = [];
+        var normalDeclarations = [];
+        var declarationKind = node.kind == "const" ? "var" : node.kind;
+
+        function flushNormalDeclarations() {
+            if (normalDeclarations.length > 0) {
+                statements.push({
+                    type: "VariableDeclaration",
+                    kind: declarationKind,
+                    declarations: normalDeclarations
+                });
+                normalDeclarations = [];
+            }
+        }
+
+        node.declarations.forEach(decl => {
+            if (!hasObjectRest(decl.id)) {
+                normalDeclarations.push(decl);
+                return;
+            }
+
+            flushNormalDeclarations();
+
+            var sourceName = `$$destructure$obj$${this.rngAlpha.get()}`;
+            statements.push({
+                type: "VariableDeclaration",
+                kind: "var",
+                declarations: [
+                    {
+                        type: "VariableDeclarator",
+                        id: { type: "Identifier", name: sourceName },
+                        init: decl.init || { type: "ObjectExpression", properties: [] }
+                    }
+                ]
+            });
+
+            var excluded = [];
+            decl.id.properties.forEach(prop => {
+                if (prop.type == "RestElement") {
+                    statements.push({
+                        type: "VariableDeclaration",
+                        kind: declarationKind,
+                        declarations: [
+                            {
+                                type: "VariableDeclarator",
+                                id: prop.argument,
+                                init: objectWithoutKeysCall(
+                                    { type: "Identifier", name: sourceName },
+                                    excluded
+                                )
+                            }
+                        ]
+                    });
+                    return;
+                }
+
+                var key = propertyKeyValue(prop);
+                excluded.push(String(key));
+                statements.push(objectPatternPropertyDeclaration(declarationKind, sourceName, prop));
+            });
+        });
+
+        flushNormalDeclarations();
+
+        return {
+            type: "BlockStatement",
+            body: statements
+        };
+    }
+
+    /**
+     * Lower arrows so scope/control-flow passes do not leave callback bodies
+     * inside an outer flattened frame. Bind lexical this only when needed.
+     * @param {ArrowFunctionExpression} node
+     * @return {Node}
+     */
+    simplifyArrowFunctionExpression (node) {
+        assert.ok(estest.isNode(node));
+
+        var fn = {
+            type: "FunctionExpression",
+            id: null,
+            params: node.params,
+            body: node.body.type == "BlockStatement" ? node.body : {
+                type: "BlockStatement",
+                body: [
+                    {
+                        type: "ReturnStatement",
+                        argument: node.body
+                    }
+                ]
+            },
+            generator: false,
+            expression: false,
+            async: node.async === true
+        };
+
+        if (!containsThisExpression(fn.body)) {
+            return fn;
+        }
+
+        return {
+            type: "CallExpression",
+            callee: {
+                type: "MemberExpression",
+                object: fn,
+                property: { type: "Identifier", name: "bind" },
+                computed: false
+            },
+            arguments: [
+                { type: "ThisExpression" }
+            ]
+        };
+    }
+
+    /**
+     * Lower class fields/private fields to older ESTree nodes that escodegen
+     * and the classic passes can handle.
+     * @param {ClassDeclaration} node
+     * @return {Node}
+     */
+    simplifyClassDeclaration (node) {
+        assert.ok(estest.isNode(node));
+
+        var className = node.id && node.id.name || `$$class$${this.rngAlpha.get()}`;
+        var privateStores = {};
+        var instanceInitializers = [];
+        var staticAssignments = [];
+        var methods = [];
+
+        node.body.body.forEach(element => {
+            if (element.type != "PropertyDefinition" && element.type != "FieldDefinition") {
+                methods.push(element);
+                return;
+            }
+
+            if (element.key.type == "PrivateIdentifier") {
+                var storeName = privateStoreName(className, element.key.name);
+                privateStores[element.key.name] = storeName;
+                if (element.static) {
+                    staticAssignments.push(weakMapSetStatement(
+                        storeName,
+                        { type: "Identifier", name: className },
+                        element.value
+                    ));
+                } else {
+                    instanceInitializers.push(weakMapSetStatement(
+                        storeName,
+                        { type: "ThisExpression" },
+                        element.value
+                    ));
+                }
+                return;
+            }
+
+            var target = {
+                type: "MemberExpression",
+                object: element.static ? { type: "Identifier", name: className } : { type: "ThisExpression" },
+                property: classFieldKey(element),
+                computed: element.computed === true || element.key.type == "Literal"
+            };
+            if (element.static) {
+                staticAssignments.push(assignmentStatement(target, element.value));
+            } else {
+                instanceInitializers.push(assignmentStatement(target, element.value));
+            }
+        });
+
+        methods.forEach(method => {
+            this.lowerPrivateMembers(method, privateStores);
+        });
+
+        if (instanceInitializers.length > 0) {
+            var constructor = methods.find(isConstructorMethod);
+            if (!constructor) {
+                constructor = {
+                    type: "MethodDefinition",
+                    key: { type: "Identifier", name: "constructor" },
+                    computed: false,
+                    value: {
+                        type: "FunctionExpression",
+                        id: null,
+                        params: [],
+                        body: {
+                            type: "BlockStatement",
+                            body: node.superClass ? [
+                                {
+                                    type: "ExpressionStatement",
+                                    expression: {
+                                        type: "CallExpression",
+                                        callee: { type: "Super" },
+                                        arguments: []
+                                    }
+                                }
+                            ] : []
+                        },
+                        generator: false,
+                        expression: false,
+                        async: false
+                    },
+                    kind: "constructor",
+                    static: false
+                };
+                methods.unshift(constructor);
+            }
+
+            var body = constructor.value.body.body;
+            var insertAt = 0;
+            if (node.superClass) {
+                var superIndex = body.findIndex(stmt => stmt.type == "ExpressionStatement"
+                    && stmt.expression.type == "CallExpression"
+                    && stmt.expression.callee.type == "Super");
+                insertAt = superIndex == -1 ? 0 : superIndex + 1;
+            }
+            body.splice.apply(body, [insertAt, 0].concat(instanceInitializers));
+        }
+
+        node.body.body = methods;
+
+        var privateDeclarations = Object.keys(privateStores).map(name => {
+            return {
+                type: "VariableDeclaration",
+                kind: "var",
+                declarations: [
+                    {
+                        type: "VariableDeclarator",
+                        id: { type: "Identifier", name: privateStores[name] },
+                        init: {
+                            type: "NewExpression",
+                            callee: { type: "Identifier", name: "WeakMap" },
+                            arguments: []
+                        }
+                    }
+                ]
+            };
+        });
+
+        if (privateDeclarations.length == 0 && staticAssignments.length == 0) {
+            return node;
+        }
+
+        return {
+            type: "BlockStatement",
+            body: privateDeclarations.concat([node]).concat(staticAssignments)
+        };
+    }
+
+    lowerPrivateMembers (node, privateStores) {
+        traverser.traverse(node, [], (child, stack) => {
+            var parentFrame = stack[1];
+            if (child.type == "MemberExpression"
+                && parentFrame
+                && parentFrame.node.type == "AssignmentExpression"
+                && parentFrame.key == "left") {
+                return child;
+            }
+            if (child.type == "AssignmentExpression"
+                && child.left.type == "MemberExpression"
+                && child.left.property.type == "PrivateIdentifier"
+                && privateStores[child.left.property.name]) {
+                return {
+                    type: "CallExpression",
+                    callee: {
+                        type: "MemberExpression",
+                        object: { type: "Identifier", name: privateStores[child.left.property.name] },
+                        property: { type: "Identifier", name: "set" },
+                        computed: false
+                    },
+                    arguments: [
+                        child.left.object,
+                        child.right
+                    ]
+                };
+            }
+            if (child.type == "MemberExpression"
+                && child.property.type == "PrivateIdentifier"
+                && privateStores[child.property.name]) {
+                return weakMapGetExpression(privateStores[child.property.name], child.object);
+            }
+            return child;
+        });
+    }
+
 };