khepri-compile - npm Package Compare versions

Comparing version 0.1.1 to 0.2.0

dist_node/fun.js

 /*
  * THIS FILE IS AUTO GENERATED from 'lib/fun.kep'
  * DO NOT EDIT
-*/
-"use strict";
-var reduce, reduceRight, foldl, foldr, concat, filter, map, flatten;
+*/"use strict";
+var constant, flip, reduce, reduceRight, foldl, foldr, concat, filter, map, flatten;
+(constant = (function(x) {
+    return (function() {
+        return x;
+    });
+}));
+(flip = (function(f) {
+    return (function(x, y) {
+        return f(y, x);
+    });
+}));
 (reduce = Function.prototype.call.bind(Array.prototype.reduce));
@@ -25,9 +34,11 @@ (reduceRight = Function.prototype.call.bind(Array.prototype.reduceRight));
 }));
-(exports.reduce = reduce);
-(exports.reduceRight = reduceRight);
-(exports.foldl = foldl);
-(exports.foldr = foldr);
-(exports.concat = concat);
-(exports.filter = filter);
-(exports.map = map);
-(exports.flatten = flatten);
+(exports["constant"] = constant);
+(exports["flip"] = flip);
+(exports["reduce"] = reduce);
+(exports["reduceRight"] = reduceRight);
+(exports["foldl"] = foldl);
+(exports["foldr"] = foldr);
+(exports["concat"] = concat);
+(exports["filter"] = filter);
+(exports["map"] = map);
+(exports["flatten"] = flatten);

dist_node/khepri_peep.js

 /*
  * THIS FILE IS AUTO GENERATED from 'lib/khepri_peep.kep'
  * DO NOT EDIT
-*/
-"use strict";
-var tree = require("neith")["tree"],
-    __o = require("neith")["walk"],
-    walk = __o["walk"],
+*/"use strict";
+var record = require("bes")["record"],
+    tree = require("neith")["tree"],
+    modifyNode = tree["modifyNode"],
     zipper = require("neith")["zipper"],
-    __o0 = require("khepri-ast-zipper"),
-    khepriZipper = __o0["khepriZipper"],
-    __o1 = require("khepri-ast")["node"],
-    modify = __o1["modify"],
-    Node = __o1["Node"],
-    setUserData = __o1["setUserData"],
-    setData = __o1["setData"],
+    __o = require("khepri-ast-zipper"),
+    khepriZipper = __o["khepriZipper"],
+    __o0 = require("khepri-ast")["node"],
+    Node = __o0["Node"],
+    setUserData = __o0["setUserData"],
+    setData = __o0["setData"],
     ast_declaration = require("khepri-ast")["declaration"],
@@ -23,3 +21,70 @@ ast_statement = require("khepri-ast")["statement"],
     fun = require("./fun"),
-    optimize, peepholes = ({}),
+    optimize, State = record.declare(null, ["ctx", "unique"]),
+    run = (function(c, s, ok) {
+        return c(s, ok);
+    }),
+    ok = (function(x) {
+        return (function(s, ok, _) {
+            return ok(x, s);
+        });
+    }),
+    bind = (function(p, f) {
+        return (function(s, ok, err) {
+            return p(s, (function(x, s) {
+                return f(x)(s, ok);
+            }));
+        });
+    }),
+    binary = (function(a, b, f) {
+        return bind(a, (function(x) {
+            return bind(b, (function(y) {
+                return f(x, y);
+            }));
+        }));
+    }),
+    next = (function(p, c) {
+        return bind(p, fun.constant(c));
+    }),
+    seqa = (function(arr) {
+        return fun.reduce(arr, next);
+    }),
+    seq = (function() {
+        var args = arguments;
+        return seqa(args);
+    }),
+    extract = (function(s, ok) {
+        return ok(s, s);
+    }),
+    setState = (function(s) {
+        return (function(_, ok) {
+            return ok(s, s);
+        });
+    }),
+    examineState = bind.bind(null, extract),
+    modifyState = (function(f) {
+        return bind(extract, (function(s) {
+            return setState(f(s));
+        }));
+    }),
+    get = (function(op) {
+        return examineState((function(s) {
+            return ok(op(s.ctx));
+        }));
+    }),
+    node = get(tree.node),
+    move = (function(op) {
+        return modifyState((function(s) {
+            return State.setCtx(s, op(s.ctx));
+        }));
+    }),
+    modify = (function(f) {
+        return move(tree.modifyNode.bind(null, f));
+    }),
+    ctx = examineState((function(s) {
+        return ok(s.ctx);
+    })),
+    unique = (function(s, ok, err) {
+        return ok(s.unique, s.setUnique((s.unique + 1)));
+    }),
+    peepholes = ({}),
     addPeephole = (function(types, up, condition, f) {
@@ -37,87 +102,95 @@ var entry = ({
     return (node.argument && (node.argument.type === "LetExpression"));
-}), (function(node) {
+}), modify((function(node) {
     return ast_statement.WithStatement.create(null, node.argument.bindings, ast_statement.BlockStatement.create(
         null, [ast_statement.ReturnStatement.create(node.loc, node.argument.body)]));
-}));
+})));
 addPeephole(["FunctionExpression"], false, (function(node) {
     return (node.body.type === "LetExpression");
-}), (function(node) {
-    return ast_expression.FunctionExpression.create(null, node.id, node.params, ast_statement.BlockStatement.create(
-        null, [ast_statement.WithStatement.create(null, node.body.bindings, ast_statement.BlockStatement.create(
-            null, [ast_statement.ReturnStatement.create(node.loc, node.body.body)]))]));
-}));
+}), modify((function(node) {
+    return ast_expression.FunctionExpression.create(null, node.id, node.params, ast_statement.BlockStatement
+        .create(null, [ast_statement.WithStatement.create(null, node.body.bindings, ast_statement.BlockStatement
+            .create(null, [ast_statement.ReturnStatement.create(node.loc, node.body.body)]))]));
+})));
 addPeephole(["ExpressionStatement"], true, (function(node) {
     return (node.expression && (node.expression.type === "LetExpression"));
-}), (function(node) {
+}), modify((function(node) {
     return ast_statement.WithStatement.create(null, node.expression.bindings, ast_statement.BlockStatement.create(
         null, [ast_statement.ExpressionStatement.create(node.loc, node.expression.body)]));
-}));
+})));
 addPeephole(["ExpressionStatement"], true, (function(node) {
     return ((node.expression && (node.expression.type === "AssignmentExpression")) && (node.expression.right.type ===
         "LetExpression"));
-}), (function(node) {
+}), modify((function(node) {
     return ast_statement.WithStatement.create(null, node.expression.right.bindings, ast_statement.BlockStatement
-        .create(null, [ast_statement.ExpressionStatement.create(node.loc, ast_expression.AssignmentExpression.create(
-            node.expression.loc, node.expression.operator, node.expression.left, node.expression.right
-            .body))]));
-}));
+        .create(null, [ast_statement.ExpressionStatement.create(node.loc, ast_expression.AssignmentExpression
+            .create(node.expression.loc, node.expression.operator, node.expression.left, node.expression
+                .right.body))]));
+})));
 addPeephole(["LetExpression"], true, (function(node) {
     return (node.body.type === "LetExpression");
-}), (function(node) {
-    return ast_expression.LetExpression.create(null, fun.concat(node.bindings, node.body.bindings), node.body.body);
-}));
+}), modify((function(node) {
+    return ast_expression.LetExpression.create(null, fun.concat(node.bindings, node.body.bindings), node.body
+        .body);
+})));
+addPeephole(["UnaryOperatorExpression"], true, (function(_) {
+    return true;
+}), bind(unique, (function(xUid) {
+    return modify((function(node) {
+        var arg = setData(ast_value.Identifier.create(null, "x"), "uid", xUid);
+        return ast_expression.FunctionExpression.create(null, null, ast_pattern.ArgumentsPattern.create(
+                null, null, [ast_pattern.IdentifierPattern.create(null, arg)]), ast_expression.UnaryExpression
+            .create(null, node.op, arg));
+    }));
+})));
+addPeephole(["BinaryOperatorExpression"], true, (function(_) {
+    return true;
+}), binary(unique, unique, (function(xUid, yUid) {
+    return modify((function(node) {
+        var xArg = setData(ast_value.Identifier.create(null, "x"), "uid", xUid),
+            yArg = setData(ast_value.Identifier.create(null, "y"), "uid", yUid),
+            kind = (((node.op === "||") || (node.op === "&&")) ? ast_expression.LogicalExpression.create :
+                ((node.op === ".") ? (function(loc, _, x, y) {
+                    return ast_expression.MemberExpression.create(loc, x, y, true);
+                }) : ast_expression.BinaryExpression.create));
+        return ast_expression.FunctionExpression.create(null, null, ast_pattern.ArgumentsPattern.create(
+            null, null, [ast_pattern.IdentifierPattern.create(null, xArg), ast_pattern.IdentifierPattern
+                .create(null, yArg)
+            ]), kind(null, node.op, xArg, yArg));
+    }));
+})));
 addPeephole(["CurryExpression"], true, (function(node) {
-    return (node.base.type === "UnaryOperatorExpression");
-}), (function(node) {
-    var arg = setData(ast_value.Identifier.create(null, "x"), "uid", node.base.ud.x_uid);
-    return ast_expression.LetExpression.create(null, [ast_declaration.Binding.create(null, ast_pattern.IdentifierPattern
-        .create(null, arg), node.args[0])], ast_expression.FunctionExpression.create(null, null,
-        ast_pattern.ArgumentsPattern.create(null, null, []), ast_expression.UnaryExpression.create(null,
-            node.base.op, arg)));
-}));
-addPeephole(["CurryExpression"], true, (function(node) {
     return ((node.base.type === "FunctionExpression") && (!node.base.params.id));
-}), (function(node) {
+}), modify((function(node) {
     var first = node.base.params.elements[0],
         rest = node.base.params.elements.slice(1),
-        body = ast_expression.FunctionExpression.create(null, null, ast_pattern.ArgumentsPattern.create(null,
-            null, rest, node.base.params.self), node.base.body);
+        body = ast_expression.FunctionExpression.create(null, null, ast_pattern.ArgumentsPattern.create(
+            null, null, rest, node.base.params.self), node.base.body);
     return ((first && (((first.type === "IdentifierPattern") || (first.type === "AsPattern")) || (first.type ===
-        "ObjectPattern"))) ? ast_expression.LetExpression.create(null, [ast_declaration.Binding.create(null,
-        first, node.args[0])], body) : body);
-}));
+        "ObjectPattern"))) ? ast_expression.LetExpression.create(null, [ast_declaration.Binding.create(
+        null, first, node.args[0])], body) : body);
+})));
 addPeephole(["CurryExpression"], true, (function(node) {
     return (((node.base.type === "LetExpression") && (node.base.body.type === "FunctionExpression")) && (!node.base
         .body.params.id));
-}), (function(node) {
+}), modify((function(node) {
     var first = node.base.body.params.elements[0],
         rest = node.base.body.params.elements.slice(1),
-        body = ast_expression.FunctionExpression.create(null, null, ast_pattern.ArgumentsPattern.create(null,
-            null, rest, node.base.body.params.self), node.base.body.body);
+        body = ast_expression.FunctionExpression.create(null, null, ast_pattern.ArgumentsPattern.create(
+            null, null, rest, node.base.body.params.self), node.base.body.body);
     return ((first && (((first.type === "IdentifierPattern") || (first.type === "AsPattern")) || (first.type ===
-        "ObjectPattern"))) ? ast_expression.LetExpression.create(null, fun.concat(node.base.bindings,
-        ast_declaration.Binding.create(null, first, node.args[0])), body) : ast_expression.LetExpression.create(
-        null, node.base.bindings, body));
-}));
+            "ObjectPattern"))) ? ast_expression.LetExpression.create(null, fun.concat(node.base.bindings,
+            ast_declaration.Binding.create(null, first, node.args[0])), body) : ast_expression.LetExpression
+        .create(null, node.base.bindings, body));
+})));
 addPeephole(["CurryExpression"], true, (function(node) {
-    return ((node.base.type === "BinaryOperatorExpression") && (node.args.length === 1));
-}), (function(node) {
-    var bound = setData(ast_value.Identifier.create(null, "x"), "uid", node.base.ud.x_uid),
-        arg = setData(ast_value.Identifier.create(null, "y"), "uid", node.base.ud.y_uid);
-    return ast_expression.LetExpression.create(null, [ast_declaration.Binding.create(null, ast_pattern.IdentifierPattern
-        .create(null, bound), node.args[0])], ast_expression.FunctionExpression.create(null, null,
-        ast_pattern.ArgumentsPattern.create(null, null, [ast_pattern.IdentifierPattern.create(null, arg)]),
-        ast_expression.BinaryExpression.create(null, node.base.op, bound, arg)));
-}));
-addPeephole(["CurryExpression"], true, (function(node) {
     return (node.base.type === "CurryExpression");
-}), (function(node) {
+}), modify((function(node) {
     return ast_expression.CurryExpression.create(null, node.base.base, fun.concat(node.base.args, node.args));
-}));
+})));
 addPeephole(["BinaryExpression"], true, (function(node) {
     return ((node.operator === "|>") && (node.right.type === "CurryExpression"));
-}), (function(node) {
-    return ast_expression.CallExpression.create(null, ((node.right.type === "CurryExpression") ? node.right.base :
-        node.right), fun.concat((node.right.args || []), node.left));
-}));
+}), modify((function(node) {
+    return ast_expression.CallExpression.create(null, ((node.right.type === "CurryExpression") ? node.right
+        .base : node.right), fun.concat((node.right.args || []), node.left));
+})));
 addPeephole(["BinaryExpression"], true, (function(__o) {
@@ -127,6 +200,6 @@ var operator = __o["operator"],
     return ((operator === "<|") && (left.type === "CurryExpression"));
-}), (function(node) {
+}), modify((function(node) {
     return ast_expression.CallExpression.create(null, ((node.left.type === "CurryExpression") ? node.left.base :
         node.left), fun.concat((node.left.args || []), node.right));
-}));
+})));
 var upTransforms = (function(node) {
@@ -144,19 +217,36 @@ return ((node && peepholes[node.type]) || [])
     }),
-    transform = (function(ctx, transforms) {
-        return (transforms.length ? tree.modifyNode((function(node) {
-            return transforms.reduce((function(p, c) {
-                return c.map(p);
-            }), node);
-        }), ctx) : ctx);
+    transform = (function(node, transforms) {
+        return (transforms.length ? seqa(transforms.map((function(x) {
+            return x.map;
+        }))) : ok());
     }),
-    opt = walk.bind(null, (function(ctx) {
-        var node = tree.node(ctx);
-        return transform(ctx, downTransforms(node));
-    }), (function(ctx) {
-        var node = tree.node(ctx);
-        return transform(ctx, upTransforms(node));
+    walk = (function(pre, post) {
+        return next(pre, bind(ctx, (function(t) {
+            if (zipper.isLeaf(t)) {
+                var loop = next(post, bind(ctx, (function(t) {
+                    if (zipper.isLast(t)) {
+                        if (zipper.isRoot(t)) return ok();
+                        return next(move(zipper.up), loop);
+                    } else {
+                        return next(move(zipper.right), walk(pre, post));
+                    }
+                })));
+                return loop;
+            }
+            return next(move(zipper.down), walk(pre, post));
+        })));
+    }),
+    _transform = bind(node, (function(node) {
+        return transform(node, downTransforms(node));
+    })),
+    _transformPost = bind(node, (function(node) {
+        return transform(node, upTransforms(node));
+    })),
+    opt = walk.bind(null, _transform, _transformPost);
+(optimize = (function(ast, data) {
+    var s = State.create(khepriZipper(ast), data.unique);
+    return next(walk(_transform, _transformPost), node)(s, (function(x) {
+        return x;
     }));
-(optimize = (function(ast) {
-    return tree.node(zipper.root(opt(khepriZipper(ast))));
 }));
-(exports.optimize = optimize);
+(exports["optimize"] = optimize);

dist_node/lexical.js

 /*
  * THIS FILE IS AUTO GENERATED from 'lib/lexical.kep'
  * DO NOT EDIT
-*/
-"use strict";
+*/"use strict";
 var ast_node = require("khepri-ast")["node"],
@@ -23,47 +22,53 @@ setData = ast_node["setData"],
     fun = require("./fun"),
+    __o1 = require("./control/base"),
+    next = __o1["next"],
+    seq = __o1["seq"],
+    seqa = __o1["seqa"],
+    binary = __o1["binary"],
     check, _check, State = record.declare(null, ["ctx", "scope", "unique"]),
+    M = (function(run) {
+        var self = this;
+        (self.run = run);
+    }),
+    un = (function(p, s, ok, err) {
+        return new(Tail)(p.run, s, ok, err);
+    }),
+    run = (function(f, g) {
+        return (function() {
+            return f(g.apply(null, arguments));
+        });
+    })(trampoline, un),
     ok = (function(x) {
-        return (function(s, ok, _) {
+        return new(M)((function(s, ok, _) {
             return ok(x, s);
-        });
+        }));
     }),
     error = (function(x) {
-        return (function(s, _, err) {
+        return new(M)((function(s, _, err) {
             return err(x, s);
-        });
+        }));
     }),
     bind = (function(p, f) {
-        return (function(s, ok, err) {
-            return new(Tail)(p, s, (function(x, s) {
-                return f(x)(s, ok, err);
+        return new(M)((function(s, ok, err) {
+            return un(p, s, (function(x, s) {
+                return un(f(x), s, ok, err);
             }), err);
-        });
-    }),
-    next = (function(p, n) {
-        return bind(p, (function(_) {
-            return n;
         }));
-    }),
-    binary = (function(a, b, f) {
-        return bind(a, (function(x) {
-            return bind(b, (function(y) {
-                return f(x, y);
-            }));
-        }));
-    }),
-    seqa = (function(arr) {
-        return fun.reduce(arr, next);
-    }),
-    seq = (function() {
-        var args = arguments;
-        return seqa(args);
-    }),
-    extract = (function(s, ok, _) {
-        return ok(s, s);
-    }),
+    });
+(M.of = ok);
+(M.prototype.of = ok);
+(M.chain = bind);
+(M.prototype.chain = (function(f) {
+    var self = this;
+    return bind(self, f);
+}));
+var extract = new(M)((function(s, ok, _) {
+    return ok(s, s);
+})),
     setState = (function(s) {
-        return (function(_, ok, _0) {
+        return new(M)((function(_, ok, _0) {
             return ok(s, s);
-        });
+        }));
     }),
+    examineState = bind.bind(null, extract),
     modifyState = (function(f) {
@@ -74,8 +79,5 @@ return bind(extract, (function(s) {
     }),
-    examineState = (function(f) {
-        return bind(extract, f);
-    }),
-    unique = (function(s, ok, err) {
+    unique = new(M)((function(s, ok, err) {
         return ok(s.unique, s.setUnique((s.unique + 1)));
-    }),
+    })),
     examineScope = (function(f) {
@@ -93,2 +95,8 @@ return examineState((function(s) {
     pop = modifyScope(scope.pop),
+    inspect = (function(f) {
+        return examineState((function(s) {
+            return f(tree.node(s.ctx));
+        }));
+    }),
+    extractNode = inspect(ok),
     move = (function(op) {
@@ -107,16 +115,2 @@ return modifyState((function(s) {
     }),
-    checkCtx = (function(ctx) {
-        return _check((ctx && tree.node(ctx)));
-    }),
-    checkTop = (function(s, ok, err) {
-        return checkCtx(s.ctx)(s, ok, err);
-    }),
-    checkChild = (function(edge) {
-        return child(edge, checkTop);
-    }),
-    inspect = (function(f) {
-        return examineState((function(s) {
-            return f(tree.node(s.ctx));
-        }));
-    }),
     modifyNode = (function(f) {
@@ -128,2 +122,8 @@ return move(tree.modifyNode.bind(null, f));
     }),
+    checkTop = inspect((function(x) {
+        return _check(x);
+    })),
+    checkChild = (function(edge) {
+        return child(edge, checkTop);
+    }),
     pass = ok(),
@@ -242,15 +242,2 @@ block = (function() {
 addCheck("CurryExpression", seq(checkChild("base"), checkChild("args")));
-addCheck("UnaryOperatorExpression", bind(unique, (function(uid) {
-    return modifyNode((function(node) {
-        return setData(node, "x_uid", uid);
-    }));
-})));
-addCheck("BinaryOperatorExpression", binary(unique, unique, (function(xuid, yuid) {
-    return modifyNode((function(node) {
-        return setUserData(node, ({
-            "x_uid": xuid,
-            "y_uid": yuid
-        }));
-    }));
-})));
 addCheck("SinkPattern", bind(unique, (function(uid) {
@@ -298,14 +285,18 @@ return setNode(setData(ast_value.Identifier.create(null, "_"), "uid", uid));
 }));
-var checkAst = (function(ast, globals) {
-    var scope = fun.reduce((globals || []), Scope.addImmutableBinding, Scope.empty),
-        state = new(State)(khepriZipper(ast), scope, 1);
-    return trampoline(checkTop(state, (function(x, s) {
-        return tree.node(zipper.root(s.ctx));
-    }), (function(err, s) {
-        throw err;
-    })));
-});
+var initialScope = fun.foldl.bind(null, Scope.addImmutableBinding, Scope.empty),
+    suc = (function(x, s) {
+        return ({
+            "tree": x,
+            "data": ({
+                "unique": s.unique
+            })
+        });
+    }),
+    fail = (function(x) {
+        throw x;
+    });
 (check = (function(ast, globals) {
-    return checkAst(ast, globals);
+    return run(seq(checkTop, move(zipper.root), extractNode), new(State)(khepriZipper(ast), initialScope((
+        globals || [])), 1), suc, fail);
 }));
-(exports.check = check);
+(exports["check"] = check);

dist_node/stage/khepri_peep.js

 /*
  * THIS FILE IS AUTO GENERATED from 'lib/stage/khepri_peep.kep'
  * DO NOT EDIT
-*/
-"use strict";
+*/"use strict";
 var khepri_peep = require("../khepri_peep"),
+    __o = require("bes")["object"],
+    setProperty = __o["setProperty"],
     optimize;
-(optimize = (function(__o) {
-    var options = __o["options"],
-        ast = __o["ast"];
-    return ({
-        "options": options,
-        "ast": khepri_peep.optimize(ast)
-    });
+(optimize = (function(input) {
+    var ast = input["ast"],
+        data = input["data"];
+    return setProperty(input, "ast", khepri_peep.optimize(ast, data));
 }));
-(exports.optimize = optimize);
+(exports["optimize"] = optimize);

dist_node/stage/lexical.js

 /*
  * THIS FILE IS AUTO GENERATED from 'lib/stage/lexical.kep'
  * DO NOT EDIT
-*/
-"use strict";
+*/"use strict";
 var lexical = require("../lexical"),
@@ -14,8 +13,13 @@ check, builtins = ["Array", "Boolean", "Date", "decodeURI", "decodeURIComponent", "encodeURI", "encodeURIComponent",
     var options = __o["options"],
-        ast = __o["ast"];
+        ast = __o["ast"],
+        data = __o["data"],
+        __o0 = lexical.check(ast, ((options && options.globals) || builtins), data),
+        tree = __o0["tree"],
+        data0 = __o0["data"];
     return ({
-        "ast": lexical.check(ast, ((options && options.globals) || builtins)),
+        "ast": tree,
+        "data": data0,
         "options": options
     });
 }));
-(exports.check = check);
+(exports["check"] = check);

dist_node/stage/transform.js

 /*
  * THIS FILE IS AUTO GENERATED from 'lib/stage/transform.kep'
  * DO NOT EDIT
-*/
-"use strict";
+*/"use strict";
 var transformer = require("../transform"),
+    __o = require("bes")["object"],
+    setProperty = __o["setProperty"],
     transform;
-(transform = (function(__o) {
-    var options = __o["options"],
-        ast = __o["ast"],
-        packageManager = (options.package_manager || "amd");
-    return ({
-        "options": options,
-        "ast": transformer.transform(ast, packageManager)
-    });
+(transform = (function(input) {
+    var options = input["options"],
+        ast = input["ast"],
+        data = input["data"];
+    return setProperty(input, "ast", transformer.transform(ast, (options.package_manager || "amd"), data));
 }));
-(exports.transform = transform);
+(exports["transform"] = transform);

dist_node/transform.js

 /*
  * THIS FILE IS AUTO GENERATED from 'lib/transform.kep'
  * DO NOT EDIT
-*/
-"use strict";
+*/"use strict";
 var record = require("bes")["record"],
@@ -33,15 +32,11 @@ array = require("bes")["array"],
     fun = require("./fun"),
-    transform, objectElementUnpack, flip = (function(f) {
-        return (function(x, y) {
-            return f(y, x);
-        });
-    }),
-    _transform = (function() {
+    flip = fun["flip"],
+    transform, objectElementUnpack, _transform = (function() {
         var args = arguments;
         return _transform.apply(null, args);
     }),
-    State = record.declare(null, ["ctx", "scope", "packageManager", "bindings"]);
+    State = record.declare(null, ["ctx", "scope", "packageManager", "bindings", "unique"]);
 (State.empty = State.create(null, scope.Scope.empty, null, [
     [], null
-]));
+], 0));
 var ok = (function(x) {
@@ -284,14 +279,2 @@ return (function(s, ok) {
     }),
-    unaryOperatorExpression = (function(loc, op) {
-        return khepri_expression.FunctionExpression.create(loc, null, khepri_pattern.ArgumentsPattern.create(null,
-                null, [khepri_pattern.IdentifierPattern.create(null, identifier(null, "x"))]), khepri_expression.UnaryExpression
-            .create(null, op, identifier(null, "x")));
-    }),
-    binaryOperatorExpression = (function(loc, op) {
-        var kind = (((op === "||") || (op === "&&")) ? khepri_expression.LogicalExpression : khepri_expression.BinaryExpression);
-        return khepri_expression.FunctionExpression.create(loc, null, khepri_pattern.ArgumentsPattern.create(null,
-            null, [khepri_pattern.IdentifierPattern.create(null, identifier(null, "x")), khepri_pattern.IdentifierPattern
-                .create(null, identifier(null, "y"))
-            ]), kind.create(null, op, identifier(null, "x"), identifier(null, "y")));
-    }),
     ternaryOperatorExpression = (function(loc) {
@@ -483,8 +466,2 @@ return khepri_expression.FunctionExpression.create(loc, null, khepri_pattern.ArgumentsPattern.create(null,
 })));
-addTransform("UnaryOperatorExpression", next(modify((function(node) {
-    return unaryOperatorExpression(node.loc, node.op);
-})), _transform));
-addTransform("BinaryOperatorExpression", next(modify((function(node) {
-    return binaryOperatorExpression(node.loc, node.op);
-})), _transform));
 addTransform("TernaryOperatorExpression", next(modify((function(node) {
@@ -572,3 +549,3 @@ return ternaryOperatorExpression(node.loc);
                     if (zipper.isLast(t)) {
-                        if (zipper.isRoot(t)) return ok();
+                        if (zipper.isRoot(t)) return pass;
                         return next(move(zipper.up), loop);
@@ -584,3 +561,3 @@ } else {
     });
-(transform = (function(ast, manager) {
+(transform = (function(ast, manager, data) {
     var amd_manager = require("./package_manager/amd"),
@@ -592,3 +569,4 @@ node_manager = require("./package_manager/node"),
         .setScope(scope.Scope.empty)
-        .setPackageManager(packageManager);
+        .setPackageManager(packageManager)
+        .setUnique(data.unique);
     return trampoline(next(walk(_transform, _transformPost), node)(s, (function(x) {
@@ -598,2 +576,2 @@ return x;
 }));
-(exports.transform = transform);
+(exports["transform"] = transform);

package.json

 {
     "name": "khepri-compile",
-    "version": "0.1.1",
+    "version": "0.2.0",
     "description": "Compiler for the Khepri programming language",
@@ -51,3 +51,3 @@ "author": "Matt Bierner",
         
-        "khepri-parse": "0.5.x",
+        "khepri-parse": "0.7.x",
         "ecma-unparse": "3.2.x"
@@ -54,0 +54,0 @@ },

tests/lexical.js

@@ -85,48 +85,2 @@ var parser = require('khepri-parse').parse.parser;
 
-exports.packageDuplicateExports = function(test) {
-    test.throws(function() {
-        lexical.check(testParser(lexer.lex("package (x, x) {}")));
-    });
-    
-    test.throws(function() {
-        lexical.check(testParser(lexer.lex("package (x, y, z, x) {}")));
-    });
-    test.done();
-};
-
-exports.packageBindingNameConflict = function(test) {
-    test.throws(function() {
-        lexical.check(testParser(lexer.lex("package (x) with x = 3 {}")));
-    });
-    
-    test.throws(function() {
-        lexical.check(testParser(lexer.lex("package (y, z, x) with [[[x]]] = 3 {}")));
-    });
-    
-    test.throws(function() {
-        lexical.check(testParser(lexer.lex("package (y, z, x) with import 'x' x {}")));
-    });
-    test.done();
-};
-
-exports.packageBodyNameConflict = function(test) {
-    test.throws(function() {
-        lexical.check(testParser(lexer.lex("package (x) { var x; }")));
-    });
-    
-    test.ok(
-        lexical.check(testParser(lexer.lex("package (x) { {var x; } }"))));
-    test.done();
-};
-
-exports.packageBlockBodyConflict = function(test) {
-    test.throws(function() {
-        lexical.check(testParser(lexer.lex("package () with x = 3 in { var x; }")));
-    });
-    
-    test.ok(
-        lexical.check(testParser(lexer.lex("package () with x = 3 in { {var x; } }"))));
-    test.done();
-};
-
 exports.multipleParameterSameName = function(test) {
@@ -133,0 +87,0 @@ test.throws(function() {

No alert changes

Improved metrics

Total package byte prevSize

165316

increased by2.51%

Number of package files

51

increased by6.25%

Lines of code

2422

increased by5.4%

Worsened metrics

Number of medium supply chain risk alerts

12

increased by9.09%

No dependency changes