1 files changed, 412 insertions, 585 deletions

diff --git a/node_modules/montage/require/require.js b/node_modules/montage/require/require.js
index 988dd811..8273b660 100755
--- a/node_modules/montage/require/require.js
+++ b/node_modules/montage/require/require.js
@@ -3,12 +3,37 @@
  No rights, expressed or implied, whatsoever to this software are provided by Motorola Mobility, Inc. hereunder.<br/>
  (c) Copyright 2011 Motorola Mobility, Inc.  All Rights Reserved.
  </copyright> */
-bootstrap("require/require", function (require, CJS) {
 
-    var Promise = require("core/promise").Promise;
-    var URL = require("core/url");
+(function (definition) {
 
-    var global = (function () {return this})();
+    // Boostrapping Browser
+    if (typeof bootstrap !== "undefined") {
+        bootstrap("require/require", function (require, exports) {
+            var Promise = require("core/promise").Promise;
+            var URL = require("core/mini-url");
+            definition(exports, Promise, URL);
+            require("require/browser");
+        });
+
+    // Node Server
+    } else if (typeof process !== "undefined") {
+        var Promise = (require)("../core/promise").Promise;
+        var URL = (require)("../core/url");
+        definition(exports, Promise, URL);
+        require("./node");
+        if (require.main == module)
+            exports.main();
+
+    } else {
+        throw new Error("Can't support require on this platform");
+    }
+
+})(function (Require, Promise, URL) {
+
+    if (!this)
+        throw new Error("Require does not work in strict mode.");
+
+    var global = this;
     var globalEval = eval; // reassigning causes eval to not use lexical scope.
 
     // Non-CommonJS speced extensions should be marked with an "// EXTENSION" comment.
@@ -17,228 +42,192 @@ bootstrap("require/require", function (require, CJS) {
     // Returns the root "require" function. If this root "require()" function is called the loader will be in synchronous mode.
     // To get asynchronous loading you MUST call the root "require.async()". In async mode all subsequent calls to "require()" will
     // be asynchronously loaded, and synchronously executed.
-    CJS.Sandbox = function(config) {
+    Require.Sandbox = function(config) {
         // Configuration defaults:
         config = config || {};
-        config.location = URL.resolve(config.location || CJS.pwd(), ".");
+        config.location = URL.resolve(config.location || Require.getLocation(), ".");
         config.lib = URL.resolve(config.location, config.lib || ".");
         config.paths = config.paths || [config.lib];
         config.mappings = config.mappings || {}; // EXTENSION
-        config.definitions = config.definitions || {};
-        config.modules = config.modules || {};
-        config.exposedConfigs = config.exposedConfigs || [
-            "paths",
-            "mappings",
-            "loader",
-            "definitions",
-            "base",
-            "location",
-            "packageDescription",
-            "loadPackage"
-        ];
-        config.makeLoader = config.makeLoader || CJS.DefaultLoaderConstructor;
-        config.loader = config.loader || config.makeLoader(config);
-        config.makeCompiler = config.makeCompiler || CJS.DefaultCompilerConstructor;
-        config.compiler = config.compiler || config.makeCompiler(config);
+        config.exposedConfigs = config.exposedConfigs || Require.defaultExposedConfigs;
+        config.makeLoader = config.makeLoader || Require.DefaultLoaderConstructor;
+        config.load = config.load || config.makeLoader(config);
+        config.makeCompiler = config.makeCompiler || Require.DefaultCompilerConstructor;
+        config.compile = config.compile || config.makeCompiler(config);
 
         // Sandbox state:
-        // Module instances: { exports, id, path, uri }
-        var modules = config.modules;
-        // Module definition objects: { factory, dependencies, path }
-        var definitions = config.definitions;
-        // Arrays of callbacks to be executed once a module definition has been loaded
-        var definitionListeners = {};
+        // Modules: { exports, id, location, directory, factory, dependencies, dependees, text, type }
+        var modules = config.modules = config.modules || {};
         // Mapping from canonical IDs to the initial top ID used to load module
-        var urisToIds = {};
-
-        // Ensures a module definition is loaded before returning or executing the callback.
-        // Supports multiple calls for the same topId by registering callback as a listener if it has already been initiated.
-        function loadDefinition(topId, callback) {
-            if (callback) {
-                // already loaded
-                if (has(definitions, topId) && definitions[topId].factory) {
-                    callback(topId);
-                }
-                // in progress
-                else if (has(definitionListeners, topId)) {
-                    definitionListeners[topId].push(callback);
-                }
-                // pre-arranged
-                else if (has(definitions, topId) && definitions[topId].path !== undefined) {
-                    var def = definitions[topId];
-                    CJS.read(def.path).then(function (text) {
-                        def.text = text;
-                        config.compiler(def);
-                        callback(topId);
-                    }, function (reason) {
-                        console.warn("Can't read " + JSON.stringify(def.path) + ": " + reason);
-                        callback(null);
-                    });
-                }
-                // hasn't started
-                else {
-                    definitionListeners[topId] = [callback];
+        var locationsToIds = {};
 
-                    config.loader(topId, function(definition) {
-                        if (!definition) {
-                            CJS.warn("Can't find module " + JSON.stringify(topId));
-                        }
-                        definitions[topId] = definition || null;
-
-                        CJS.progress.loadedModules.push([
-                            config.location,
-                            topId
-                        ].join("#"));
+        function getModule(id) {
+            if (!has(modules, id)) {
+                modules[id] = {
+                    id: id,
+                    display: config.location + "#" + id // EXTENSION
+                };
+            }
+            return modules[id];
+        }
+        config.module = getModule;
 
-                        definitionListeners[topId].forEach(function(fn) { 
-                            fn(topId);
-                        });
+        function inject(id, exports) {
+            var module = getModule(id)
+            module.exports = exports;
+            module.location = URL.resolve(config.location, id);
+            module.directory = URL.resolve(module.location, ".");
+        }
 
+        // Ensures a module definition is loaded, compiled, analyzed
+        var load = memoize(function (topId, viaId) {
+            var module = getModule(topId);
+            return Promise.call(function () {
+                // already loaded, already instantiated, or redirection
+                if (
+                    module.factory !== void 0 ||
+                    module.exports !== void 0 ||
+                    module.redirect !== void 0
+                ) {
+                    return module;
+                // load
+                } else {
+                    Require.progress.requiredModules.push(module.display);
+                    return Promise.call(config.load, null, topId, module)
+                    .then(function () {
+                        Require.progress.loadedModules.push(module.display);
+                        return module;
                     });
                 }
-            } else {
-                // already loaded
-                if (has(definitions, topId)) {
-                    return;
-                }
-                // hasn't started
-                else {
-                    var definition = config.loader(topId);
-                    if (!definition) {
-                        CJS.warn("Can't find module " + JSON.stringify(topId));
-                    }
-                    definitions[topId] = definition || null;
+            })
+            .then(function (module) {
+                // analyze dependencies
+                config.compile(module);
+                var dependencies = module.dependencies = module.dependencies || [];
+                if (module.redirect !== void 0) {
+                    dependencies.push(module.redirect);
                 }
-            }
+                return module;
+            });
+        });
+
+        // Load a module definition, and the definitions of its transitive
+        // dependencies
+        function deepLoad(id, viaId, loading) {
+            // this is a memo of modules already being loaded so we don’t
+            // data-lock on a cycle of dependencies.
+            loading = loading || {};
+            // has this all happened before?  will it happen again?
+            if (has(loading, id))
+                return; // break the cycle of violence.
+            loading[id] = true; // this has happened before
+            return load(id, viaId)
+            .then(function (module) {
+                // load the transitive dependencies using the magic of
+                // recursion.
+                return Promise.all(module.dependencies.map(function (depId) {
+                    depId = resolve(depId, id)
+                    // create dependees set, purely for debug purposes
+                    var module = getModule(depId);
+                    var dependees = module.dependees = module.dependees || {};
+