sproutit-narwhal 0.1.106

data/lib/querystring.js

@@ -0,0 +1,176 @@
+// Query String Utilities
+
+
+var QueryString = exports;
+
+QueryString.unescape = function (str, decodeSpaces) {
+    return decodeURIComponent(decodeSpaces ? str.replace(/\+/g, " ") : str);
+};
+
+QueryString.escape = function (str) {
+    return encodeURIComponent(str);
+};
+
+
+var stack = [];
+/**
+ * <p>Converts an arbitrary value to a Query String representation.</p>
+ *
+ * <p>Objects with cyclical references will trigger an exception.</p>
+ *
+ * @method stringify
+ * @param obj {Variant} any arbitrary value to convert to query string
+ * @param sep {String} (optional) Character that should join param k=v pairs together. Default: "&"
+ * @param eq  {String} (optional) Character that should join keys to their values. Default: "="
+ * @param name {String} (optional) Name of the current key, for handling children recursively.
+ * @static
+ */
+QueryString.stringify = function (obj, sep, eq, name) {
+    sep = sep || "&";
+    eq = eq || "=";
+    if (isA(obj, null) || isA(obj, undefined) || typeof(obj) === 'function') {
+        return name ? encodeURIComponent(name) + eq : '';
+    }
+    
+    if (isBool(obj)) obj = +obj;
+    if (isNumber(obj) || isString(obj)) {
+        return encodeURIComponent(name) + eq + encodeURIComponent(obj);
+    }
+    if (isA(obj, [])) {
+        var s = [];
+        name = name+'[]';
+        for (var i = 0, l = obj.length; i < l; i ++) {
+            s.push( QueryString.stringify(obj[i], sep, eq, name) );
+        }
+        return s.join(sep);
+    }
+    // now we know it's an object.
+    
+    // Check for cyclical references in nested objects
+    for (var i = stack.length - 1; i >= 0; --i) if (stack[i] === obj) {
+        throw new Error("QueryString.stringify. Cyclical reference");
+    }
+    
+    stack.push(obj);
+    
+    var s = [];
+    var begin = name ? name + '[' : '';
+    var end = name ? ']' : '';
+    for (var i in obj) if (obj.hasOwnProperty(i)) {
+        var n = begin + i + end;
+        s.push(QueryString.stringify(obj[i], sep, eq, n));
+    }
+    
+    stack.pop();
+    
+    s = s.join(sep);
+    if (!s && name) return name + "=";
+    return s;
+};
+
+QueryString.parseQuery = QueryString.parse = function(qs, sep, eq) {
+    return qs
+        .split(sep||"&")
+        .map(pieceParser(eq||"="))
+        .reduce(mergeParams);
+};
+
+// Parse a key=val string.
+// These can get pretty hairy
+// example flow:
+// parse(foo[bar][][bla]=baz)
+// return parse(foo[bar][][bla],"baz")
+// return parse(foo[bar][], {bla : "baz"})
+// return parse(foo[bar], [{bla:"baz"}])
+// return parse(foo, {bar:[{bla:"baz"}]})
+// return {foo:{bar:[{bla:"baz"}]}}
+var pieceParser = function (eq) {
+    return function parsePiece (key, val) {
+        if (arguments.length !== 2) {
+            // key=val, called from the map/reduce
+             key = key.split(eq);
+            return parsePiece(
+                QueryString.unescape(key.shift(), true),
+                QueryString.unescape(key.join(eq), true)
+            );
+        }
+        key = key.replace(/^\s+|\s+$/g, '');
+        if (isString(val)) {
+            val = val.replace(/^\s+|\s+$/g, '');
+            // convert numerals to numbers
+            if (!isNaN(val)) {
+                var numVal = +val;
+                if (val === numVal.toString(10)) val = numVal;
+            }
+        }
+        var sliced = /(.*)\[([^\]]*)\]$/.exec(key);
+        if (!sliced) {
+            var ret = {};
+            if (key) ret[key] = val;
+            return ret;
+        }
+        // ["foo[][bar][][baz]", "foo[][bar][]", "baz"]
+        var tail = sliced[2], head = sliced[1];
+    
+        // array: key[]=val
+        if (!tail) return parsePiece(head, [val]);
+    
+        // obj: key[subkey]=val
+        var ret = {};
+        ret[tail] = val;
+        return parsePiece(head, ret);
+    };
+};
+
+// the reducer function that merges each query piece together into one set of params
+function mergeParams (params, addition) {
+    return (
+        // if it's uncontested, then just return the addition.
+        (!params) ? addition
+        // if the existing value is an array, then concat it.
+        : (isA(params, [])) ? params.concat(addition)
+        // if the existing value is not an array, and either are not objects, arrayify it.
+        : (!isA(params, {}) || !isA(addition, {})) ? [params].concat(addition)
+        // else merge them as objects, which is a little more complex
+        : mergeObjects(params, addition)
+    );
+};
+
+// Merge two *objects* together. If this is called, we've already ruled
+// out the simple cases, and need to do the for-in business.
+function mergeObjects (params, addition) {
+    for (var i in addition) if (i && addition.hasOwnProperty(i)) {
+        params[i] = mergeParams(params[i], addition[i]);
+    }
+    return params;
+};
+
+// duck typing
+function isA (thing, canon) {
+    return (
+        // truthiness. you can feel it in your gut.
+        (!thing === !canon)
+        // typeof is usually "object"
+        && typeof(thing) === typeof(canon)
+        // check the constructor
+        && Object.prototype.toString.call(thing) === Object.prototype.toString.call(canon)
+    );
+};
+function isBool (thing) {
+    return (
+        typeof(thing) === "boolean"
+        || isA(thing, new Boolean(thing))
+    );
+};
+function isNumber (thing) {
+    return (
+        typeof(thing) === "number"
+        || isA(thing, new Number(thing))
+    ) && isFinite(thing);
+};
+function isString (thing) {
+    return (
+        typeof(thing) === "string"
+        || isA(thing, new String(thing))
+    );
+};

data/lib/ref-send.js

@@ -0,0 +1,257 @@
+/*
+ * Copyright 2007-2009 Tyler Close under the terms of the MIT X license found
+ * at http://www.opensource.org/licenses/mit-license.html
+ *
+ * ref_send.js version: 2009-05-11
+ */
+"use strict";
+
+var enqueue = require('reactor').enqueue;
+
+/**
+ * Enqueues a task to be run in a future turn.
+ * @param task  function to invoke later
+ */
+exports.run = enqueue;
+
+/**
+ * Constructs a rejected promise.
+ * @param reason    value describing the failure
+ */
+exports.reject =  reject;
+
+/**
+ * Constructs a promise for an immediate reference.
+ * @param value immediate reference
+ */
+exports.ref = ref;
+
+/**
+ * Constructs a ( promise, resolver ) pair.
+ *
+ * The resolver is a callback to invoke with a more resolved value for
+ * the promise. To fulfill the promise, simply invoke the resolver with
+ * an immediate reference. To reject the promise, invoke the resolver
+ * with the return from a call to reject(). To put the promise in the
+ * same state as another promise, invoke the resolver with that other
+ * promise.
+ */
+exports.defer = defer;
+
+/**
+ * Gets the current value of a promise.
+ * @param value promise or immediate reference to evaluate
+ */
+exports.near = function (value) {
+    return ('function' === typeof value) ? value() : value;
+};
+
+/**
+ * Registers an observer on a promise.
+ * @param value     promise or immediate reference to observe
+ * @param fulfilled function to be called with the resolved value
+ * @param rejected  function to be called with the rejection reason
+ * @return promise for the return value from the invoked callback
+ */
+exports.when = function (value, fulfilled, rejected) {
+    var r = defer();
+    var done = false;   // ensure the untrusted promise makes at most a
+                        // single call to one of the callbacks
+    forward(promise(value), 'WHEN', function (x) {
+        if (done) { throw new Error(); }
+        done = true;
+        r.resolve(ref(x)('WHEN', fulfilled, rejected));
+    }, function (reason) {
+        if (done) { throw new Error(); }
+        done = true;
+        r.resolve(rejected ? rejected(reason) : reject(reason));
+    });
+    return r.promise;
+};
+
+/**
+ * Gets the value of a property in a future turn.
+ * @param target    promise or immediate reference for target object
+ * @param noun      name of property to get
+ * @return promise for the property value
+ */
+exports.get = function (target, noun) {
+    var r = defer();
+    forward(promise(target), 'GET', r.resolve, noun);
+    return r.promise;
+};
+
+/**
+ * Invokes a method in a future turn.
+ * @param target    promise or immediate reference for target object
+ * @param verb      name of method to invoke
+ * @param argv      array of invocation arguments
+ * @return promise for the return value
+ */
+exports.post = function (target, verb, argv) {
+    var r = defer();
+    forward(promise(target), 'POST', r.resolve, verb, argv);
+    return r.promise;
+};
+
+/**
+ * Sets the value of a property in a future turn.
+ * @param target    promise or immediate reference for target object
+ * @param noun      name of property to set
+ * @param value     new value of property
+ * @return promise for the return value
+ */
+exports.put = function (target, noun, value) {
+    var r = defer();
+    forward(promise(target), 'PUT', r.resolve, noun, value);
+    return r.promise;
+};
+
+/**
+ * Deletes a property in a future turn.
+ * @param target    promise or immediate reference for target object
+ * @param noun      name of property to delete
+ * @return promise for the return value
+ */
+exports.remove = function (target, noun) {
+    var r = defer();
+    forward(promise(target), 'DELETE', r.resolve, noun);
+    return r.promise;
+};
+
+function reject(reason) {
+    return function (op, arg1, arg2, arg3) {
+        if (undefined === op) {
+            return { '!' : reason };
+        }
+        if ('WHEN' === op) { return arg2 ? arg2(reason) : reject(reason); }
+        return arg1 ? arg1(reject(reason)) : reject(reason);
+    };
+}
+
+function ref(value) {
+    if (null === value || undefined === value) {
+        return reject({ $: [ 'NaO' ] });
+    }
+    if ('number' === typeof value && !isFinite(value)) {
+        return reject({ $: [ 'NaN' ] });
+    }
+    return function (op, arg1, arg2, arg3) {
+        if (undefined === op) { return value; }
+
+        var r;
+        switch (op) {
+        case 'WHEN':
+            r = value;
+            break;
+        case 'GET':
+            r = (undefined === arg2) ? value : value[arg2];
+            break;
+        case 'POST':
+            if (undefined === arg2) {
+                r = reject({});
+            } else {
+                r = value[arg2](arg3);
+            }
+            break;
+        case 'PUT':
+            if (undefined === arg2) {
+                r = reject({});
+            } else {
+                value[arg2] = arg3;
+                r = {};
+            }
+            break;
+        case 'DELETE':
+            if (undefined === arg2) {
+                r = reject({});
+            } else {
+                delete value[arg2];
+                r = {};
+            }
+            break;
+        default:
+            r = reject({});
+        }
+        return arg1 ? arg1(r) : r;
+    };
+}
+
+/**
+ * Enqueues a promise operation.
+ *
+ * The above functions, reject() and ref(), each construct a kind of
+ * promise. Other libraries can provide other kinds of promises by
+ * implementing the same API. A promise is a function with signature:
+ * function (op, arg1, arg2, arg3). The first argument determines the
+ * interpretation of the remaining arguments. The following cases must be
+ * handled:
+ *
+ * 'op' is undefined:
+ *  Return the most resolved current value of the promise.
+ *
+ * 'op' is "WHEN":
+ *  'arg1': callback to invoke with the fulfilled value of the promise
+ *  'arg2': callback to invoke with the rejection reason for the promise
+ *
+ * 'op' is "GET":
+ *  'arg1': callback to invoke with the value of the named property
+ *  'arg2': name of the property to read
+ *
+ * 'op' is "POST":
+ *  'arg1': callback to invoke with the return value from the invocation
+ *  'arg2': name of the method to invoke
+ *  'arg3': array of invocation arguments
+ *
+ * 'op' is "PUT":
+ *  'arg1': callback to invoke with the return value from the operation
+ *  'arg2': name of the property to set
+ *  'arg3': new value of property
+ *
+ * 'op' is "DELETE":
+ *  'arg1': callback to invoke with the return value from the operation
+ *  'arg2': name of the property to delete
+ *
+ * 'op' is unrecognized:
+ *  'arg1': callback to invoke with a rejected promise
+ */
+function forward(p, op, arg1, arg2, arg3) {
+    enqueue(function () { p(op, arg1, arg2, arg3); });
+}
+
+/**
+ * Gets the corresponding promise for a given reference.
+ */
+function promise(value) {
+    return ('function' === typeof value) ? value : ref(value);
+}
+
+function defer() {
+    var value;
+    var pending = [];
+    var tail = function (op, arg1, arg2, arg3) {
+        if (undefined === op) { return pending ? tail : value(); }
+        if (pending) {
+            pending.push({ op: op, arg1: arg1, arg2: arg2, arg3: arg3 });
+        } else {
+            forward(value, op, arg1, arg2, arg3);
+        }
+    };
+    return {
+        promise: tail,
+        resolve: function (p) {
+            if (!pending) { return; }
+
+            var todo = pending;
+            pending = null;
+            value = promise(p);
+
+            var i, len = todo.length, task;
+            for (i = 0; i < len; ++i) {
+              task = todo[i];
+              forward(value, task.op, task.arg1, task.arg2, task.arg3);
+            }
+        }
+    };
+}
+

data/lib/regexp.js

@@ -0,0 +1,12 @@
+// RegExp
+
+/*** RegExp.escape
+    accepts a string; returns the string with regex metacharacters escaped.
+    the returned string can safely be used within a regex to match a literal
+    string. escaped characters are [, ], {, }, (, ), -, *, +, ?, ., \, ^, $,
+    |, #, [comma], and whitespace.
+*/
+RegExp.escape = function (str) {
+    return str.replace(/[-[\]{}()*+?.\\^$|,#\s]/g, "\\$&");
+};
+

data/lib/sandbox.js

@@ -0,0 +1,422 @@
+
+// NOTE: this file is used is the bootstrapping process,
+// so any "requires" must be accounted for in narwhal.js
+
+var system = require("system");
+
+exports.Loader = function (options) {
+    var loader = {};
+    var factories = options.factories || {};
+    var paths = options.paths;
+    var extensions = options.extensions || ["", ".js"];
+    var timestamps = {};
+    var debug = options.debug;
+
+    loader.resolve = exports.resolve;
+
+    loader.find = function (topId) {
+        // if it's absolute only search the "root" directory.
+        // file.join() must collapse multiple "/" into a single "/"
+        var searchPaths = system.fs.isAbsolute(topId) ? [""] : paths;
+        
+        for (var j = 0; j < extensions.length; j++) {
+            var extension = extensions[j];
+            for (var i = 0; i < searchPaths.length; i++) {
+                var path = system.fs.join(searchPaths[i], topId + extension);
+                if (system.fs.isFile(path))
+                    return path;
+            }
+        }
+        throw new Error("require error: couldn't find \"" + topId + '"');
+    };
+
+    loader.fetch = function (topId, path) {
+        if (!path)
+            path = loader.find(topId);
+        if (typeof system.fs.mtime === "function")
+            timestamps[path] = system.fs.mtime(path);
+        if (debug)
+            print('loader: fetching ' + topId);
+        var text = system.fs.read(path, {
+            'charset': 'utf-8'
+        });
+        // we leave the endline so the error line numbers align
+        text = text.replace(/^#[^\n]+\n/, "\n");
+        return text;
+    };
+
+    loader.evaluate = function (text, topId) {
+        if (system.evaluate) {
+            var fileName = loader.find(topId);
+            var factory = system.evaluate(text, fileName, 1);
+            factory.path = fileName;
+            return factory;
+        } else {
+            return new Function("require", "exports", "module", "system", "print", text);
+        }
+    };
+
+    loader.load = function (topId) {
+        if (!Object.prototype.hasOwnProperty.call(factories, topId)) {
+            loader.reload(topId);
+        } else if (typeof system.fs.mtime === "function") {
+            var path = loader.find(topId);
+            if (loader.hasChanged(topId, path))
+                loader.reload(topId);
+        }
+        return factories[topId];
+    };
+
+    loader.reload = function (topId, path) {
+        factories[topId] = loader.evaluate(loader.fetch(topId, path), topId);
+    };
+
+    loader.isLoaded = function (topId) {
+        return Object.prototype.hasOwnProperty.call(factories, topId);
+    };
+
+    loader.hasChanged = function (topId, path) {
+        if (!path)
+            path = loader.resolve(topId);
+        return (
+            !Object.prototype.hasOwnProperty.call(timestamps, path) ||
+            system.fs.mtime(path) > timestamps[path]
+        );
+    };
+
+    loader.paths = paths;
+    loader.extensions = extensions;
+
+    return loader;
+};
+
+exports.MultiLoader = function (options) {
+
+    var factories = options.factories || {};
+
+    var self = {};
+    self.paths = options.paths || [];
+    self.loader = options.loader || exports.Loader(options);
+    self.loaders = options.loaders || [
+        ["", self.loader],
+        [".js", self.loader]
+    ];
+
+    self.resolve = exports.resolve;
+
+    self.find = function (topId) {
+        // if it's absolute only search the "root" directory.
+        // file.join() must collapse multiple "/" into a single "/"
+        var searchPaths = system.fs.isAbsolute(topId) ? [""] :  self.paths;
+        
+        for (var j = 0; j < self.loaders.length; j++) {
+            var extension = self.loaders[j][0];
+            var loader = self.loaders[j][1];
+            for (var i = 0; i < searchPaths.length; i++) {
+                var path = system.fs.join(searchPaths[i], topId + extension);
+                if (system.fs.isFile(path)) {
+                    // now check each extension for a match.
+                    // handles case when extension is in the id, so it's matched by "",
+                    // but we want to use the loader corresponding to the actual extension
+                    for (var k = 0; k < self.loaders.length; k++) {
+                        var ext = self.loaders[k][0];
+                        if (path.lastIndexOf(ext) === path.length - ext.length)
+                            return [self.loaders[k][1], path];
+                    }
+                    throw "ERROR: shouldn't reach this point!"
+                }
+            }
+        }
+        throw "require error: couldn't find \"" + topId + '"';
+    };
+
+    self.load = function (topId, loader, path) {
+        if (!loader || !path) {
+            var pair = self.find(topId);
+            loader = pair[0];
+            path = pair[1];
+        }
+        if (
+            !Object.prototype.hasOwnProperty.call(factories, topId) ||
+            (loader.hasChanged && loader.hasChanged(topId, path))
+        )
+            self.reload(topId, loader, path);
+        return factories[topId];
+    };
+
+    self.reload = function (topId, loader, path) {
+        if (!loader || !path) {
+            var pair = self.find(topId);
+            loader = pair[0];
+            path = pair[1];
+        }
+        loader.reload(topId, path);
+        factories[topId] = loader.load(topId, path);
+    };
+
+    self.isLoaded = function (topId) {
+        return Object.prototype.hasOwnProperty.call(factories, topId);
+    };
+
+    return self;
+};
+
+exports.AttenuatedLoader = function (loader) {
+    var self = {};
+
+    self.resolve = Object.freeze(function (id, baseId) {
+        return loader.resolve(id, baseId);
+    });
+
+    self.fetch = Object.freeze(function (topId) {
+        if (/\./.test(topId))
+            throw new Error("Invalid module identifier: " + topId);
+        return loader.fetch(topId);
+    });
+
+    self.load = Object.freeze(function (topId, path) {
+        if (/\./.test(topId))
+            throw new Error("Invalid module identifier");
+        return loader.load(topId, path);
+    });
+
+    self.reload = Object.freeze(function (topId) {
+        if (/\./.test(topId))
+            throw new Error("Invalid module identifier");
+        return loader.reload(topId, path);
+    });
+
+    return Object.freeze(self);
+};
+
+exports.Sandbox = function (options) {
+    options = options || {};
+    var loader = options.loader;
+    var subsystem = options.system || system || {};
+    var modules = options.modules || {};
+    var debug = options.debug !== undefined ? !!options.debug : !!system.debug;
+
+    // managed print free variable in the sandbox forwards
+    // to system.print in the sandbox
+    var subprint = options.print || function () {
+        return subsystem.print.apply(subsystem, arguments);
+    };
+
+    var debugDepth = 0;
+    var mainId;
+
+    var sandbox = function (id, baseId, force, reload) {
+        id = loader.resolve(id, baseId);
+
+        /* populate memo with module instance */
+        if (!Object.prototype.hasOwnProperty.call(modules, id) || force) {
+
+            if (sandbox.debug) {
+                debugDepth++;
+                var debugAcc = "";
+                for (var i = 0; i < debugDepth; i++) debugAcc += "\\";
+                print(debugAcc + " " + id, 'module');
+            }
+
+            var globals = {};
+            if (sandbox.debug) {
+                // record globals
+                for (var name in global)
+                    globals[name] = true;
+            }
+            
+            if (!Object.prototype.hasOwnProperty.call(modules, id) || reload)
+                modules[id] = {};
+            var exports = modules[id];
+            if (reload)
+                loader.reload(id);
+
+            var factory = null;
+            try {
+                factory = loader.load(id);
+            } finally {
+                // poor man's catch and rethrow (Rhino sets file/line to where the exception is thrown, not created)
+                if (!factory) {
+                    delete modules[id];
+                    if (sandbox.debug)
+                        debugDepth--;
+                }
+            }
+            var require = Require(id, factory.path);
+            var module = {
+                'id': id,
+                'path': factory.path
+            };
+            factory(require, exports, module, subsystem, subprint);
+
+            if (sandbox.debug) {
+                // check for new globals
+                for (var name in global)
+                    if (!globals[name])
+                        system.log.warn("NEW GLOBAL: " + name);
+            }
+        
+            if (sandbox.debug) {
+                var debugAcc = "";
+                for (var i = 0; i < debugDepth; i++) debugAcc += "/";
+                print(debugAcc + " " + id, 'module');
+                debugDepth--;
+            }
+
+        } else {
+            if (sandbox.debug) {
+                var debugAcc = "";
+                for (var i = 0; i < debugDepth; i++) debugAcc += "|";
+                print(debugAcc + "  " + id, 'module');
+            }
+        }
+
+        /* support curryId for modules in which it is requested */
+        var exports = modules[id];
+        var imports = {};
+        var importsUsed = false;
+        var curryUsed = false;
+        for (var name in exports) {
+            try {
+                // This try/catch block is needed to handle wrapped Java
+                // objects in Rhino.
+                curryUsed = (
+                    typeof exports[name] == "function" &&
+                    exports[name].xNarwhalCurryId
+                );
+            } catch (exception) {};
+            
+            if (curryUsed) { 
+                importsUsed = true;
+                imports[name] = (function (callback) {
+                    var curried = function () {
+                        return callback.apply(
+                            this,
+                            [baseId].concat(Array.prototype.slice.call(arguments, 0))
+                        );
+                    };
+                    curried.xNarwhalCurryId = callback;
+                    return curried;
+                })(exports[name].xNarwhalCurryId);
+            } else {
+                imports[name] = exports[name];
+            }
+        }
+
+        if (!importsUsed)
+            imports = exports;
+
+        return imports;
+
+    };
+
+    var Require = function (baseId, fileName) { // XXX deprecated fileName
+        var require = function (id) {
+            //try {
+                return sandbox(id, baseId);
+            //} catch (exception) {
+            //    if (exception.message)
+            //        exception.message += ' in ' + baseId;
+            //    throw exception;
+            //}
+        };
+        require.loader = loader;
+        require.main = mainId;
+        require.paths = loader.paths;
+        require.extensions = loader.extensions;
+        require.async = sandbox.async;
+        /* offers a facility to request the module id
+         * in which a function was imported */
+        // XXX deprecated (will need to be moved to module object)
+        require.xNarwhalCurryId = function (callback) {
+            var curried = function () {
+                return callback.apply(
+                    this,
+                    [baseId].concat(Array.prototype.slice.call(arguments))
+                );
+            };
+            curried.curryId = callback;
+            return curried;
+        };
+        return require;
+    };
+
+    sandbox.force = function (id) {
+        return sandbox(id, '', true);
+    };
+
+    sandbox.main = function (id) {
+        mainId = id;
+        return sandbox(id);
+    };
+
+    sandbox.loader = loader;
+    sandbox.system = system;
+    sandbox.paths = loader.paths;
+    sandbox.extensions = loader.extensions;
+    sandbox.debug = debug;
+
+    return sandbox;
+};
+
+exports.PrefixLoader = function (prefix, loader) {
+    var self = this || {};
+
+    self.resolve = function (id, baseId) {
+        return loader.resolve(id, baseId);
+    };
+
+    /**** evaluate
+    */
+    self.evaluate = function (text, topId) {
+        return loader.evaluate(text, prefix + topId);
+    };
+
+    /**** fetch
+    */
+    self.fetch = function (topId) {
+        return loader.fetch(prefix + topId);
+    };
+
+    /**** load
+    */
+    self.load = function (topId) {
+        return loader.load(prefix + topId);
+    };
+
+    return self;
+};
+
+exports.sandbox = function(main, system, options) {
+    options = options || {};
+    var prefix = options['prefix'];
+    var loader = options['loader'] || require.loader;
+    var modules = options['modules'] || {};
+    var print = options['print'];
+    var debug = options['debug'];
+    if (!loader) throw new Error(
+        "sandbox cannot operate without a loader, either explicitly " + 
+        "provided as an option, or implicitly provided by the current " +
+        "sandbox's 'loader' object."
+    );
+    if (prefix)
+        loader = exports.PrefixLoader(prefix, loader);
+    var sandbox = exports.Sandbox({
+        modules: modules,
+        loader: loader,
+        system: system,
+        print: print,
+        debug: debug
+    });
+    return sandbox.main(main);
+};
+
+exports.resolve = function (id, baseId) {
+    if (typeof id != "string")
+        throw new Error("module id '" + id + "' is not a String");
+    if (id.charAt(0) == ".") {
+        id = system.fs.dirname(baseId) + "/" + id;
+    }
+    return system.fs.normal(id);
+};
+