Callback for createI18nUrl. It is called when the urlService implementation classpath is downloaded
@param {Object} args Arguments passed to the Aria.load
@private
421794
function (args) {
            var urlService = this.__getUrlService();
            this.$assert(595, urlService != null);

            var url = urlService.createI18nUrl(args.moduleName, this.session.id, args.locale);

            // Add the global parameters
            url = this.__appendGlobalParams(url, this._params);

            // Add the url to the callback
            // Changing the callback arguments is BAD. Keeping this only for backward compatibility.
            // The right way to pass a result is by using the second parameter of $callback.
            args.callback.args = args.callback.args || {};
            args.callback.args.full = url;

            this.$callback(args.callback, url);
        }
128028
function loadImport(url, callback) {
        xhrLoadText(url, function(content) {
          parseRawLines(content, false, callback); // don't allow recursive imports
        }, null);
      }
383076
function URLHelper(baseUrl) {
    var _this3 = this;

    _classCallCheck(this, URLHelper);

    _defineProperty(this, "baseUrl", '');

    _defineProperty(this, "search", {});

    var t = decodeURI(baseUrl).split('?');
    this.baseUrl = t[0];

    if (t[1]) {
      t[1].split('&').forEach(function (v) {
        var t2 = v.split('=');
        _this3.search[t2[0]] = t2[1] == null ? '' : decodeURIComponent(t2[1]);
      });
    }
  }
1182273
protected void launch(String[] args) throws Exception {
		JarFile.registerUrlProtocolHandler();
		ClassLoader classLoader = createClassLoader(getClassPathArchives());
		launch(args, getMainClass(), classLoader);
	}
739823
function (args) {
    var output = [args.provider, args.caller];
    if (args.onLoad) {
        output.push(args.onLoad);
    }
    if (args.handler) {
        output.push(args.handler);
    }
    if (args.resources) {
        output.push(args.resources.join("-"));
    }
    return output.join("-");
}
1209966
function setupOriginJS(config){
  const web3Provider = new Web3.providers.HttpProvider(config.web3Url)
  // global
  web3 = new Web3(web3Provider)
  console.log(`Web3 URL: ${config.web3Url}`)

  const ipfsUrl = urllib.parse(config.ipfsUrl)
  // global
  o = new Origin({
    ipfsDomain: ipfsUrl.hostname,
    ipfsGatewayProtocol: ipfsUrl.protocol.replace(':',''),
    ipfsGatewayPort: ipfsUrl.port,
    web3
  })
  console.log(`IPFS URL: ${config.ipfsUrl}`)
}
1231006
function (args, callback) {
        ternserver.request({
            query: {
              type: "outline", //$NON-NLS-1$
              file: args.meta.location,
              ast: args.ast
            },
            files: args.files
          },
          function (error, outline) {
            if (error) {
              callback({request: 'outline', error: error.message, message: Messages['failedToComputeOutline']}); //$NON-NLS-1$
            } else if (outline && Array.isArray(outline)) {
              callback({request: 'outline', outline: outline}); //$NON-NLS-1$
            } else {
              callback({request: 'outline', outline: []}); //$NON-NLS-1$
            }
          }
        );
      }
416240
function internalRewire(parentModulePath, targetPath) {
    var targetModule,
        prelude,
        appendix,
        src;

    // Checking params
    if (typeof targetPath !== "string") {
        throw new TypeError("Filename must be a string");
    }

    // Resolve full filename relative to the parent module
    targetPath = Module._resolveFilename(targetPath, parentModulePath);

    // Create testModule as it would be created by require()
    targetModule = new Module(targetPath, parentModulePath);

    // We prepend a list of all globals declared with var so they can be overridden (without changing original globals)
    prelude = getImportGlobalsSrc();

    // Wrap module src inside IIFE so that function declarations do not clash with global variables
    // @see https://github.com/jhnns/rewire/issues/56
    prelude += "(function () { ";

    // We append our special setter and getter.
    appendix = "\n" + getDefinePropertySrc();

    // End of IIFE
    appendix += "})();";

    // Check if the module uses the strict mode.
    // If so we must ensure that "use strict"; stays at the beginning of the module.
    src = fs.readFileSync(targetPath, "utf8");
    if (detectStrictMode(src) === true) {
        prelude = ' "use strict"; ' + prelude;
    }

    moduleEnv.inject(prelude, appendix);
    moduleEnv.load(targetModule);

    return targetModule.exports;
}
119217
def load(*args)
      super(*args)
      self.id = self.uri.split('/').last if self.id.nil? and defined? self.uri
    end
1001754
public static void main(String[] args)
    {
        if (args.length==0 || args.length>2)
        {
            System.err.println
                ("\nUsage - java org.browsermob.proxy.jetty.http.HttpServer [<addr>:]<port>");
            System.err.println
                ("\nUsage - java org.browsermob.proxy.jetty.http.HttpServer -r [savefile]");
            System.err.println
                ("  Serves files from '.' directory");
            System.err.println
                ("  Dump handler for not found requests");
            System.err.println
                ("  Default port is 8080");
            System.exit(1);
        }
        
        try{
            
            if (args.length==1)
            {
                // Create the server
                HttpServer server = new HttpServer();
                
                // Default is no virtual host
                String host=null;
                HttpContext context = server.getContext(host,"/");
                context.setResourceBase(".");
                context.addHandler(new ResourceHandler());
                context.addHandler(new DumpHandler());
                context.addHandler(new NotFoundHandler());

                InetAddrPort address = new InetAddrPort(args[0]);
                server.addListener(address);

                server.start();
            }
            else
            {
                Resource resource = Resource.newResource(args[1]);
                ObjectInputStream in = new ObjectInputStream(resource.getInputStream());
                HttpServer server = (HttpServer)in.readObject();
                in.close();
                server.start();
            }
            
        }
        catch (Exception e)
        {
            log.warn(LogSupport.EXCEPTION,e);
        }
    }
236104
private static Object jsConstructor(Object[] args)
    {
        NativeDate obj = new NativeDate();

        // if called as a constructor with no args,
        // return a new Date with the current time.
        if (args.length == 0) {
            obj.date = now();
            return obj;
        }

        // if called with just one arg -
        if (args.length == 1) {
            Object arg0 = args[0];
            if (arg0 instanceof NativeDate) {
                obj.date = ((NativeDate) arg0).date;
                return obj;
            }
            if (arg0 instanceof Scriptable) {
                arg0 = ((Scriptable) arg0).getDefaultValue(null);
            }
            double date;
            if (arg0 instanceof CharSequence) {
                // it's a string; parse it.
                date = date_parseString(arg0.toString());
            } else {
                // if it's not a string, use it as a millisecond date
                date = ScriptRuntime.toNumber(arg0);
            }
            obj.date = TimeClip(date);
            return obj;
        }

        double time = date_msecFromArgs(args);

        if (!Double.isNaN(time) && !Double.isInfinite(time))
            time = TimeClip(internalUTC(time));

        obj.date = time;

        return obj;
    }
720358
function WebWorker(source,    // @arg URLString|JavaScriptFragmentString - new Worker(source) or inline worker source
                   callback,  // @arg Function = null - callback(err:Error, body:Any, param:Object):void
                   options) { // @arg Object - { name, origin, import, inline, verbose }
                              // @options.name String = "" - Worker name.
                              // @options.origin URLString = "" - set WorkerGlobalScope.origin.
                              // @options.import URLStringArray = [] - importScripts(...) files.
                              // @options.inline Boolean = false - use inline WebWorker.
                              // @options.verbose Boolean = false - verbose mode.
                              // @desc init Worker session.
//{@dev
    $valid($type(source,         "String"),        WebWorker, "source");
    $valid($type(callback,       "Function|omit"), WebWorker, "callback");
    $valid($type(options,        "Object|null"),   WebWorker, "options");
    $valid($keys(options,        "name|origin|import|inline|verbose"),
                                                   WebWorker, "options");
    $valid($type(options.name,   "String|omit"),   WebWorker, "options.name");
    $valid($type(options.origin, "String|omit"),   WebWorker, "options.origin");
    $valid($type(options.import, "Array|omit"),    WebWorker, "options.import");
    $valid($type(options.inline, "Boolean|omit"),  WebWorker, "options.inline");
    $valid($type(options.verbose,"Boolean|omit"),  WebWorker, "options.verbose");
//}@dev

    this._source    = source;
    this._callback  = callback || null;
    this._name      = options["name"]    || "";
    this._origin    = options["origin"]  || "";
    this._import    = options["import"]  || [];
    this._inline    = options["inline"]  || "";
    this._verbose   = options["verbose"] || false;

//{@dev
    $valid(WMURL.isValid(this._origin), WebWorker, "options.origin");
    $valid(WMURL.isValid(this._import), WebWorker, "options.import");
//}@dev

    this._on        = {}; // { method: methodCallback, ... }
    this._blobURL   = ""; // blob url for inline worker
    this._worker    = null; // new Worker(source) instance
    this._workerID  = ++_workerID;
    this._requestID = 0;
    this._name      = this._name || this._workerID;

    _tickets[this._name] = _tickets[this._name] || {};
}
884939
private static Object jsConstructor(Context cx, Scriptable scope,
                                        Object[] args)
    {
        if (args.length == 0)
            return new NativeArray(0);

        // Only use 1 arg as first element for version 1.2; for
        // any other version (including 1.3) follow ECMA and use it as
        // a length.
        if (cx.getLanguageVersion() == Context.VERSION_1_2) {
            return new NativeArray(args);
        }
        Object arg0 = args[0];
        if (args.length > 1 || !(arg0 instanceof Number)) {
            return new NativeArray(args);
        }
        long len = ScriptRuntime.toUint32(arg0);
        if (len != ((Number)arg0).doubleValue()) {
            String msg = ScriptRuntime.getMessage0("msg.arraylength.bad");
            throw ScriptRuntime.constructError("RangeError", msg);
        }
        return new NativeArray(len);
    }
215578
function () {
                    var value;

                    if (input.charAt(i) !== 'u' || !$(/^url\(/)) return;
                    value = $(this.entities.quoted)  || $(this.entities.variable) ||
                            $(/^(?:(?:\\[\(\)'"])|[^\(\)'"])+/) || "";

                    expect(')');

                    return new(tree.URL)((value.value != null || value instanceof tree.Variable)
                                        ? value : new(tree.Anonymous)(value), imports.paths);
                }
577233
function loadParser (parserName) {
  var parser = parsers[parserName]

  if (parser !== undefined) {
    return parser
  }

  // this uses a switch for static require analysis
  switch (parserName) {
    case 'json':
      parser = require('./lib/types/json')
      break
    case 'raw':
      parser = require('./lib/types/raw')
      break
    case 'text':
      parser = require('./lib/types/text')
      break
    case 'urlencoded':
      parser = require('./lib/types/urlencoded')
      break
  }

  // store to prevent invoking require()
  return (parsers[parserName] = parser)
}
898168
function loadResourcesHandler (classpath, self) {
        var Handler = Aria.getClassRef(classpath);

        if (Handler) {
            return new Handler();
        } else {
            var callbackArgs = {
                scope : self,
                classpath : classpath
            };

            Aria.load({
                classes : [classpath],
                oncomplete : {
                    fn : delayLoading,
                    args : callbackArgs
                },
                onerror : {
                    fn : resourcesHandlerError,
                    args : callbackArgs
                }
            });

            return new PromisedHandler();
        }
    }
287058
@Nullable
  @OverrideOnDemand
  protected IHCElement <?> createSingleErrorNode (@Nonnull final IError aError, @Nonnull final Locale aContentLocale)
  {
    return BootstrapFormHelper.createDefaultErrorNode (aError, aContentLocale);
  }