1 files changed, 698 insertions, 0 deletions

diff --git a/node_modules/montage-user/require/require.js b/node_modules/montage-user/require/require.js
new file mode 100755
index 00000000..8273b660
--- /dev/null
+++ b/node_modules/montage-user/require/require.js
@@ -0,0 +1,698 @@
+/* <copyright>
+ This file contains proprietary software owned by Motorola Mobility, Inc.<br/>
+ 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> */
+
+(function (definition) {
+
+    // 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.
+
+    // Sandbox is an instance of the loader system. Different sandboxes will have different instances of modules.
+    // 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.
+    Require.Sandbox = function(config) {
+        // Configuration defaults:
+        config = config || {};
+        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.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:
+        // 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 locationsToIds = {};
+
+        function getModule(id) {
+            if (!has(modules, id)) {
+                modules[id] = {
+                    id: id,
+                    display: config.location + "#" + id // EXTENSION
+                };
+            }
+            return modules[id];
+        }
+        config.module = getModule;
+
+        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;
+                    });
+                }
+            })
+            .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 || {};
+                    dependees[id] = true;
+                    return deepLoad(depId, id, loading);
+                }))
+                .then(function () {
+                    return module;
+                })
+            })
+        }
+
+        // Initializes a module by executing the factory function with a new module "exports" object.
+        function getExports(topId, viaId) {
+            var module = getModule(topId);
+
+            // handle redirects
+            if (module.redirect !== void 0) {
+                return getExports(module.redirect, viaId);
+            }
+
+            // handle cross-package linkage
+            if (module.mappingRedirect !== void 0) {
+                return module.mappingRequire(module.mappingRedirect, viaId);
+            }
+
+            // do not reinitialize modules
+            if (module.exports !== void 0) {
+                return module.exports;
+            }
+
+            // do not initialize modules that do not define a factory function
+            if (module.factory === void 0) {
+                throw new Error("Can't require module " + JSON.stringify(topId) + " via " + JSON.stringify(viaId));
+            }
+
+            module.directory = URL.resolve(module.location, "."); // EXTENSION
+            module.exports = {};
+
+            // Execute the factory function:
+            var returnValue = module.factory.call(
+                // in the context of the module:
+                global, // this
+                makeRequire(topId), // require
+                module.exports, // exports
+                module // module
+            );
+
+            // Modules should never have a return value.
+            if (returnValue !== void 0) {
+                console.warn('require: module "'+topId+'" returned a value.');
+            }
+
+            // Update the list of modules that are ready to use
+            Require.progress.initializedModules.push(module.display);
+
+            return module.exports;
+        }
+
+        // Finds the internal identifier for a module in a subpackage
+        // The ``internal`` boolean parameter causes the function to return
+        // null instead of throwing an exception.  I’m guessing that
+        // throwing exceptions *and* being recursive would be too much
+        // performance evil for one function.
+        function identify(id2, require2, internal) {
+            if (require2.location === config.location)
+                return id2;
+            var locations = {};
+            for (var name in config.mappings) {
+                var mapping = config.mappings[name];
+                var location = mapping.location;
+                var candidate = config.getPackage(location);
+                var id1 = candidate.identify(id2, require2, true);
+                if (id1 === null) {
+                    continue
+                } else if (id1 === "") {
+                    return name;
+                } else {
+                    return name + "/" + id1;
+                }
+            }
+            if (internal) {
+                return null;
+            } else {
+                throw new Error("Can't identify " + id2 + " from " + require2.location);
+            }
+        }
+
+        // Creates a unique require function for each module that encapsulates that module's id for resolving relative module IDs against.
+        function makeRequire(viaId) {
+
+            // Main synchronously executing "require