sprockets-browserify 0.2.0 → 0.3.0

data/node_modules/browserify/node_modules/url/node_modules/punycode/vendor/requirejs/domReady.js

@@ -0,0 +1,170 @@
+/**
+ * @license RequireJS domReady 1.0.0 Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+/*jslint strict: false, plusplus: false */
+/*global require: false, define: false, requirejs: false,
+  window: false, clearInterval: false, document: false,
+  self: false, setInterval: false */
+
+
+define(function () {
+    var isBrowser = typeof window !== "undefined" && window.document,
+        isPageLoaded = !isBrowser,
+        doc = isBrowser ? document : null,
+        readyCalls = [],
+        readyLoaderCalls = [],
+        //Bind to a specific implementation, but if not there, try a
+        //a generic one under the "require" name.
+        req = requirejs || require || {},
+        oldResourcesReady = req.resourcesReady,
+        scrollIntervalId;
+
+    function runCallbacks(callbacks) {
+        for (var i = 0, callback; (callback = callbacks[i]); i++) {
+            callback(doc);
+        }
+    }
+
+    function callReady() {
+        var callbacks = readyCalls,
+            loaderCallbacks = readyLoaderCalls;
+
+        if (isPageLoaded) {
+            //Call the DOM ready callbacks
+            if (callbacks.length) {
+                readyCalls = [];
+                runCallbacks(callbacks);
+            }
+
+            //Now handle DOM ready + loader ready callbacks.
+            if (req.resourcesDone && loaderCallbacks.length) {
+                readyLoaderCalls = [];
+                runCallbacks(loaderCallbacks);
+            }
+        }
+    }
+
+    /**
+     * Add a method to require to get callbacks if there are loader resources still
+     * being loaded. If so, then hold off calling "withResources" callbacks.
+     *
+     * @param {Boolean} isReady: pass true if all resources have been loaded.
+     */
+    if ('resourcesReady' in req) {
+        req.resourcesReady = function (isReady) {
+            //Call the old function if it is around.
+            if (oldResourcesReady) {
+                oldResourcesReady(isReady);
+            }
+
+            if (isReady) {
+                callReady();
+            }
+        };
+    }
+
+    /**
+     * Sets the page as loaded.
+     */
+    function pageLoaded() {
+        if (!isPageLoaded) {
+            isPageLoaded = true;
+            if (scrollIntervalId) {
+                clearInterval(scrollIntervalId);
+            }
+
+            callReady();
+        }
+    }
+
+    if (isBrowser) {
+        if (document.addEventListener) {
+            //Standards. Hooray! Assumption here that if standards based,
+            //it knows about DOMContentLoaded.
+            document.addEventListener("DOMContentLoaded", pageLoaded, false);
+            window.addEventListener("load", pageLoaded, false);
+        } else if (window.attachEvent) {
+            window.attachEvent("onload", pageLoaded);
+
+            //DOMContentLoaded approximation, as found by Diego Perini:
+            //http://javascript.nwbox.com/IEContentLoaded/
+            if (self === self.top) {
+                scrollIntervalId = setInterval(function () {
+                    try {
+                        //From this ticket:
+                        //http://bugs.dojotoolkit.org/ticket/11106,
+                        //In IE HTML Application (HTA), such as in a selenium test,
+                        //javascript in the iframe can't see anything outside
+                        //of it, so self===self.top is true, but the iframe is
+                        //not the top window and doScroll will be available
+                        //before document.body is set. Test document.body
+                        //before trying the doScroll trick.
+                        if (document.body) {
+                            document.documentElement.doScroll("left");
+                            pageLoaded();
+                        }
+                    } catch (e) {}
+                }, 30);
+            }
+        }
+
+        //Check if document already complete, and if so, just trigger page load
+        //listeners.
+        if (document.readyState === "complete") {
+            pageLoaded();
+        }
+    }
+
+    /** START OF PUBLIC API **/
+
+    /**
+     * Registers a callback for DOM ready. If DOM is already ready, the
+     * callback is called immediately.
+     * @param {Function} callback
+     */
+    function domReady(callback) {
+        if (isPageLoaded) {
+            callback(doc);
+        } else {
+            readyCalls.push(callback);
+        }
+        return domReady;
+    }
+
+    /**
+     * Callback that waits for DOM ready as well as any outstanding
+     * loader resources. Useful when there are implicit dependencies.
+     * This method should be avoided, and always use explicit
+     * dependency resolution, with just regular DOM ready callbacks.
+     * The callback passed to this method will be called immediately
+     * if the DOM and loader are already ready.
+     * @param {Function} callback
+     */
+    domReady.withResources = function (callback) {
+        if (isPageLoaded && req.resourcesDone) {
+            callback(doc);
+        } else {
+            readyLoaderCalls.push(callback);
+        }
+        return domReady;
+    };
+
+    domReady.version = '1.0.0';
+
+    /**
+     * Loader Plugin API method
+     */
+    domReady.load = function (name, req, onLoad, config) {
+        if (config.isBuild) {
+            onLoad(null);
+        } else {
+            domReady(onLoad);
+        }
+    };
+
+    /** END OF PUBLIC API **/
+
+    return domReady;
+});

data/node_modules/browserify/node_modules/url/node_modules/punycode/vendor/requirejs/i18n.js

@@ -0,0 +1,161 @@
+/**
+ * @license RequireJS i18n 1.0.0 Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+/*jslint regexp: false, nomen: false, plusplus: false, strict: false */
+/*global require: false, navigator: false, define: false */
+
+/**
+ * This plugin handles i18n! prefixed modules. It does the following:
+ *
+ * 1) A regular module can have a dependency on an i18n bundle, but the regular
+ * module does not want to specify what locale to load. So it just specifies
+ * the top-level bundle, like "i18n!nls/colors".
+ *
+ * This plugin will load the i18n bundle at nls/colors, see that it is a root/master
+ * bundle since it does not have a locale in its name. It will then try to find
+ * the best match locale available in that master bundle, then request all the
+ * locale pieces for that best match locale. For instance, if the locale is "en-us",
+ * then the plugin will ask for the "en-us", "en" and "root" bundles to be loaded
+ * (but only if they are specified on the master bundle).
+ *
+ * Once all the bundles for the locale pieces load, then it mixes in all those
+ * locale pieces into each other, then finally sets the context.defined value
+ * for the nls/colors bundle to be that mixed in locale.
+ *
+ * 2) A regular module specifies a specific locale to load. For instance,
+ * i18n!nls/fr-fr/colors. In this case, the plugin needs to load the master bundle
+ * first, at nls/colors, then figure out what the best match locale is for fr-fr,
+ * since maybe only fr or just root is defined for that locale. Once that best
+ * fit is found, all of its locale pieces need to have their bundles loaded.
+ *
+ * Once all the bundles for the locale pieces load, then it mixes in all those
+ * locale pieces into each other, then finally sets the context.defined value
+ * for the nls/fr-fr/colors bundle to be that mixed in locale.
+ */
+(function () {
+    //regexp for reconstructing the master bundle name from parts of the regexp match
+    //nlsRegExp.exec("foo/bar/baz/nls/en-ca/foo") gives:
+    //["foo/bar/baz/nls/en-ca/foo", "foo/bar/baz/nls/", "/", "/", "en-ca", "foo"]
+    //nlsRegExp.exec("foo/bar/baz/nls/foo") gives:
+    //["foo/bar/baz/nls/foo", "foo/bar/baz/nls/", "/", "/", "foo", ""]
+    //so, if match[5] is blank, it means this is the top bundle definition.
+    var nlsRegExp = /(^.*(^|\/)nls(\/|$))([^\/]*)\/?([^\/]*)/,
+        empty = {};
+
+    //Helper function to avoid repeating code. Lots of arguments in the
+    //desire to stay functional and support RequireJS contexts without having
+    //to know about the RequireJS contexts.
+    function addPart(locale, master, needed, toLoad, prefix, suffix) {
+        if (master[locale]) {
+            needed.push(locale);
+            if (master[locale] === true || master[locale] === 1) {
+                toLoad.push(prefix + locale + '/' + suffix);
+            }
+        }
+    }
+
+    function addIfExists(req, locale, toLoad, prefix, suffix) {
+        var fullName = prefix + locale + '/' + suffix;
+        if (require._fileExists(req.toUrl(fullName))) {
+            toLoad.push(fullName);
+        }
+    }
+
+    /**
+     * Simple function to mix in properties from source into target,
+     * but only if target does not already have a property of the same name.
+     * This is not robust in IE for transferring methods that match
+     * Object.prototype names, but the uses of mixin here seem unlikely to
+     * trigger a problem related to that.
+     */
+    function mixin(target, source, force) {
+        for (var prop in source) {
+            if (!(prop in empty) && (!(prop in target) || force)) {
+                target[prop] = source[prop];
+            }
+        }
+    }
+
+    define({
+        version: '1.0.0',
+        /**
+         * Called when a dependency needs to be loaded.
+         */
+        load: function (name, req, onLoad, config) {
+            config = config || {};
+
+            var masterName,
+                match = nlsRegExp.exec(name),
+                prefix = match[1],
+                locale = match[4],
+                suffix = match[5],
+                parts = locale.split("-"),
+                toLoad = [],
+                value = {},
+                i, part, current = "";
+
+            //If match[5] is blank, it means this is the top bundle definition,
+            //so it does not have to be handled. Locale-specific requests
+            //will have a match[4] value but no match[5]
+            if (match[5]) {
+                //locale-specific bundle
+                prefix = match[1];
+                masterName = prefix + suffix;
+            } else {
+                //Top-level bundle.
+                masterName = name;
+                suffix = match[4];
+                locale = config.locale || (config.locale =
+                        typeof navigator === "undefined" ? "root" :
+                        (navigator.language ||
+                         navigator.userLanguage || "root").toLowerCase());
+                parts = locale.split("-");
+            }
+
+            if (config.isBuild) {
+                //Check for existence of all locale possible files and
+                //require them if exist.
+                toLoad.push(masterName);
+                addIfExists(req, "root", toLoad, prefix, suffix);
+                for (i = 0; (part = parts[i]); i++) {
+                    current += (current ? "-" : "") + part;
+                    addIfExists(req, current, toLoad, prefix, suffix);
+                }
+
+                req(toLoad, function () {
+                    onLoad();
+                });
+            } else {
+                //First, fetch the master bundle, it knows what locales are available.
+                req([masterName], function (master) {
+                    //Figure out the best fit
+                    var needed = [];
+
+                    //Always allow for root, then do the rest of the locale parts.
+                    addPart("root", master, needed, toLoad, prefix, suffix);
+                    for (i = 0; (part = parts[i]); i++) {
+                        current += (current ? "-" : "") + part;
+                        addPart(current, master, needed, toLoad, prefix, suffix);
+                    }
+
+                    //Load all the parts missing.
+                    req(toLoad, function () {
+                        var i, partBundle;
+                        for (i = needed.length - 1; i > -1 && (part = needed[i]); i--) {
+                            partBundle = master[part];
+                            if (partBundle === true || partBundle === 1) {
+                                partBundle = req(prefix + part + '/' + suffix);
+                            }
+                            mixin(value, partBundle);
+                        }
+
+                        //All done, notify the loader.
+                        onLoad(value);
+                    });
+                });
+            }
+        }
+    });
+}());

data/node_modules/browserify/node_modules/url/node_modules/punycode/vendor/requirejs/index.html

@@ -0,0 +1,21 @@
+<div id="intro" class="mono">
+    <p>/* ---</p>
+
+    <p>RequireJS is a JavaScript file and module loader. It is optimized for
+    in-browser use, but it can be used in other JavaScript environments,
+    like Rhino and <a href="requirejs/tree/master/docs/node.md">Node</a>. Using
+    a modular script loader like RequireJS will improve the speed and
+    quality of your code.</p>
+
+    <p>
+    IE 6+ .......... compatible &#x2714;<br>
+    Firefox 2+ ..... compatible &#x2714;<br>
+    Safari 3.2+ .... compatible &#x2714;<br>
+    Chrome 3+ ...... compatible &#x2714;<br>
+    Opera 10+ ...... compatible &#x2714;
+    </p>
+
+    <p><a href="requirejs/tree/master/docs/start.md">Get started</a> then check out the <a href="requirejs/tree/master/docs/api.md">API</a>.</p>
+
+    <p>--- */</p>
+</div>

data/node_modules/browserify/node_modules/url/node_modules/punycode/vendor/requirejs/order.js

@@ -0,0 +1,189 @@
+/**
+ * @license RequireJS order 1.0.5 Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+/*jslint nomen: false, plusplus: false, strict: false */
+/*global require: false, define: false, window: false, document: false,
+  setTimeout: false */
+
+//Specify that requirejs optimizer should wrap this code in a closure that
+//maps the namespaced requirejs API to non-namespaced local variables.
+/*requirejs namespace: true */
+
+(function () {
+
+    //Sadly necessary browser inference due to differences in the way
+    //that browsers load and execute dynamically inserted javascript
+    //and whether the script/cache method works when ordered execution is
+    //desired. Currently, Gecko and Opera do not load/fire onload for scripts with
+    //type="script/cache" but they execute injected scripts in order
+    //unless the 'async' flag is present.
+    //However, this is all changing in latest browsers implementing HTML5
+    //spec. With compliant browsers .async true by default, and
+    //if false, then it will execute in order. Favor that test first for forward
+    //compatibility.
+    var testScript = typeof document !== "undefined" &&
+                 typeof window !== "undefined" &&
+                 document.createElement("script"),
+
+        supportsInOrderExecution = testScript && (testScript.async ||
+                               ((window.opera &&
+                                 Object.prototype.toString.call(window.opera) === "[object Opera]") ||
+                               //If Firefox 2 does not have to be supported, then
+                               //a better check may be:
+                               //('mozIsLocallyAvailable' in window.navigator)
+                               ("MozAppearance" in document.documentElement.style))),
+
+        //This test is true for IE browsers, which will load scripts but only
+        //execute them once the script is added to the DOM.
+        supportsLoadSeparateFromExecute = testScript &&
+                                          testScript.readyState === 'uninitialized',
+
+        readyRegExp = /^(complete|loaded)$/,
+        cacheWaiting = [],
+        cached = {},
+        scriptNodes = {},
+        scriptWaiting = [];
+
+    //Done with the test script.
+    testScript = null;
+
+    //Callback used by the type="script/cache" callback that indicates a script
+    //has finished downloading.
+    function scriptCacheCallback(evt) {
+        var node = evt.currentTarget || evt.srcElement, i,
+            moduleName, resource;
+
+        if (evt.type === "load" || readyRegExp.test(node.readyState)) {
+            //Pull out the name of the module and the context.
+            moduleName = node.getAttribute("data-requiremodule");
+
+            //Mark this cache request as loaded
+            cached[moduleName] = true;
+
+            //Find out how many ordered modules have loaded
+            for (i = 0; (resource = cacheWaiting[i]); i++) {
+                if (cached[resource.name]) {
+                    resource.req([resource.name], resource.onLoad);
+                } else {
+                    //Something in the ordered list is not loaded,
+                    //so wait.
+                    break;
+                }
+            }
+
+            //If just loaded some items, remove them from cacheWaiting.
+            if (i > 0) {
+                cacheWaiting.splice(0, i);
+            }
+
+            //Remove this script tag from the DOM
+            //Use a setTimeout for cleanup because some older IE versions vomit
+            //if removing a script node while it is being evaluated.
+            setTimeout(function () {
+                node.parentNode.removeChild(node);
+            }, 15);
+        }
+    }
+
+    /**
+     * Used for the IE case, where fetching is done by creating script element
+     * but not attaching it to the DOM. This function will be called when that
+     * happens so it can be determined when the node can be attached to the
+     * DOM to trigger its execution.
+     */
+    function onFetchOnly(node) {
+        var i, loadedNode, resourceName;
+
+        //Mark this script as loaded.
+        node.setAttribute('data-orderloaded', 'loaded');
+
+        //Cycle through waiting scripts. If the matching node for them
+        //is loaded, and is in the right order, add it to the DOM
+        //to execute the script.
+        for (i = 0; (resourceName = scriptWaiting[i]); i++) {
+            loadedNode = scriptNodes[resourceName];
+            if (loadedNode &&
+                loadedNode.getAttribute('data-orderloaded') === 'loaded') {
+                delete scriptNodes[resourceName];
+                require.addScriptToDom(loadedNode);
+            } else {
+                break;
+            }
+        }
+
+        //If just loaded some items, remove them from waiting.
+        if (i > 0) {
+            scriptWaiting.splice(0, i);
+        }
+    }
+
+    define({
+        version: '1.0.5',
+
+        load: function (name, req, onLoad, config) {
+            var hasToUrl = !!req.nameToUrl,
+                url, node, context;
+
+            //If no nameToUrl, then probably a build with a loader that
+            //does not support it, and all modules are inlined.
+            if (!hasToUrl) {
+                req([name], onLoad);
+                return;
+            }
+
+            url = req.nameToUrl(name, null);
+
+            //Make sure the async attribute is not set for any pathway involving
+            //this script.
+            require.s.skipAsync[url] = true;
+            if (supportsInOrderExecution || config.isBuild) {
+                //Just a normal script tag append, but without async attribute
+                //on the script.
+                req([name], onLoad);
+            } else if (supportsLoadSeparateFromExecute) {
+                //Just fetch the URL, but do not execute it yet. The
+                //non-standards IE case. Really not so nice because it is
+                //assuming and touching requrejs internals. OK though since
+                //ordered execution should go away after a long while.
+                context = require.s.contexts._;
+
+                if (!context.urlFetched[url] && !context.loaded[name]) {
+                    //Indicate the script is being fetched.
+                    context.urlFetched[url] = true;
+
+                    //Stuff from require.load
+                    require.resourcesReady(false);
+                    context.scriptCount += 1;
+
+                    //Fetch the script now, remember it.
+                    node = require.attach(url, context, name, null, null, onFetchOnly);
+                    scriptNodes[name] = node;
+                    scriptWaiting.push(name);
+                }
+
+                //Do a normal require for it, once it loads, use it as return
+                //value.
+                req([name], onLoad);
+            } else {
+                //Credit to LABjs author Kyle Simpson for finding that scripts
+                //with type="script/cache" allow scripts to be downloaded into
+                //browser cache but not executed. Use that
+                //so that subsequent addition of a real type="text/javascript"
+                //tag will cause the scripts to be executed immediately in the
+                //correct order.
+                if (req.specified(name)) {
+                    req([name], onLoad);
+                } else {
+                    cacheWaiting.push({
+                        name: name,
+                        req: req,
+                        onLoad: onLoad
+                    });
+                    require.attach(url, null, name, scriptCacheCallback, "script/cache");
+                }
+            }
+        }
+    });
+}());