The Tor Browser: comparison toolkit/devtools/Require.jsm

--1:000000000000
+:30d73bd11208
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+/**
+* Require.jsm is a small module loader that loads JavaScript modules as
+* defined by AMD/RequireJS and CommonJS, or specifically as used by:
+* GCLI, Orion, Firebug, CCDump, NetPanel/HTTPMonitor and others.
+*
+* To date, no attempt has been made to ensure that Require.jsm closely follows
+* either the AMD or CommonJS specs. It is hoped that a more formal JavaScript
+* module standard will arrive before this is necessary. In the mean time it
+* serves the projects it loads.
+*/
+this.EXPORTED_SYMBOLS = [ "define", "require" ];
+const console = (function() {
+const tempScope = {};
+Components.utils.import("resource://gre/modules/devtools/Console.jsm", tempScope);
+return tempScope.console;
+})();
+/**
+* Define a module along with a payload.
+* @param moduleName Name for the payload
+* @param deps Ignored. For compatibility with CommonJS AMD Spec
+* @param payload Function with (require, exports, module) params
+*/
+this.define = function define(moduleName, deps, payload) {
+if (typeof moduleName != "string") {
+throw new Error("Error: Module name is not a string");
+}
+if (arguments.length == 2) {
+payload = deps;
+}
+else {
+payload.deps = deps;
+}
+if (define.debugDependencies) {
+console.log("define: " + moduleName + " -> " + payload.toString()
+.slice(0, 40).replace(/\n/, '\\n').replace(/\r/, '\\r') + "...");
+}
+if (moduleName in define.modules) {
+throw new Error("Error: Redefining module: " + moduleName);
+}
+// Mark the payload so we know we need to call it to get the real module
+payload.__uncompiled = true;
+define.modules[moduleName] = payload;
+}
+/**
+* The global store of un-instantiated modules
+*/
+define.modules = {};
+/**
+* Should we console.log on module definition/instantiation/requirement?
+*/
+define.debugDependencies = false;
+/**
+* We invoke require() in the context of a Domain so we can have multiple
+* sets of modules running separate from each other.
+* This contrasts with JSMs which are singletons, Domains allows us to
+* optionally load a CommonJS module twice with separate data each time.
+* Perhaps you want 2 command lines with a different set of commands in each,
+* for example.
+*/
+function Domain() {
+this.modules = {};
+if (define.debugDependencies) {
+this.depth = "";
+}
+}
+/**
+* Lookup module names and resolve them by calling the definition function if
+* needed.
+* There are 2 ways to call this, either with an array of dependencies and a
+* callback to call when the dependencies are found (which can happen
+* asynchronously in an in-page context) or with a single string an no
+* callback where the dependency is resolved synchronously and returned.
+* The API is designed to be compatible with the CommonJS AMD spec and
+* RequireJS.
+* @param deps A name, or array of names for the payload
+* @param callback Function to call when the dependencies are resolved
+* @return The module required or undefined for array/callback method
+*/
+Domain.prototype.require = function(config, deps, callback) {
+if (arguments.length <= 2) {
+callback = deps;
+deps = config;
+config = undefined;
+}
+if (Array.isArray(deps)) {
+var params = deps.map(function(dep) {
+return this.lookup(dep);
+}, this);
+if (callback) {
+callback.apply(null, params);
+}
+return undefined;
+}
+else {
+return this.lookup(deps);
+}
+};
+/**
+* Lookup module names and resolve them by calling the definition function if
+* needed.
+* @param moduleName A name for the payload to lookup
+* @return The module specified by aModuleName or null if not found
+*/
+Domain.prototype.lookup = function(moduleName) {
+if (moduleName in this.modules) {
+var module = this.modules[moduleName];
+if (define.debugDependencies) {
+console.log(this.depth + " Using module: " + moduleName);
+}
+return module;
+}
+if (!(moduleName in define.modules)) {
+throw new Error("Missing module: " + moduleName);
+}
+var module = define.modules[moduleName];
+if (define.debugDependencies) {
+console.log(this.depth + " Compiling module: " + moduleName);
+}
+if (module.__uncompiled) {
+if (define.debugDependencies) {
+this.depth += ".";
+}
+var exports = {};
+try {
+var params = module.deps.map(function(dep) {
+if (dep === "require") {
+return this.require.bind(this);
+}
+if (dep === "exports") {
+return exports;
+}
+if (dep === "module") {
+return { id: moduleName, uri: "" };
+}
+return this.lookup(dep);
+}.bind(this));
+var reply = module.apply(null, params);
+module = (reply !== undefined) ? reply : exports;
+}
+catch (ex) {
+dump("Error using module '" + moduleName + "' - " + ex + "\n");
+throw ex;
+}
+if (define.debugDependencies) {
+this.depth = this.depth.slice(0, -1);
+}
+}
+// cache the resulting module object for next time
+this.modules[moduleName] = module;
+return module;
+};
+/**
+* Expose the Domain constructor and a global domain (on the define function
+* to avoid exporting more than we need. This is a common pattern with
+* require systems)
+*/
+define.Domain = Domain;
+define.globalDomain = new Domain();
+/**
+* Expose a default require function which is the require of the global
+* sandbox to make it easy to use.
+*/
+this.require = define.globalDomain.require.bind(define.globalDomain);

The Tor Browser / file comparison

comparison: toolkit/devtools/Require.jsm

toolkit/devtools/Require.jsm