(function() { var MODULE_LOAD_URL = "/static/build/modules"; var IN_WORKER = typeof importScripts == "function"; var host = location.protocol + "//" + location.hostname + (location.port ? ":" + location.port : ""); var global = (function() { return this; })(); if (!global && typeof window != "undefined") global = window; // can happen in strict mode if (!global && typeof self != "undefined") global = self; // can happen in webworker var commentRegExp = /(\/\*([\s\S]*?)\*\/|([^:]|^)\/\/(.*)$)/gm; var cjsRequireRegExp = /require\s*\(\s*["']([^'"\s]+)["']\s*\)/g; function getInlineDeps(fn) { var deps = []; if (fn.length) { fn.toString() .replace(commentRegExp, "") .replace(cjsRequireRegExp, function(match, dep, index, str) { var i = index; while (str.charCodeAt((i -= 1)) <= 32) {} if (str.charAt(i) !== ".") deps.push(dep); }); deps = ["require", "exports", "module"].concat(deps); } return deps; } var define = function(name, deps, callback) { if (typeof name !== "string") { callback = deps; deps = name; name = null; } if (deps && !Array.isArray(deps)) { callback = deps; deps = null; } if (nextModule) { if (!name || name == nextModule.name) { name = nextModule.name; deps = deps || nextModule.deps; nextModule = null; } } if (!name) return defQueue.push([deps, callback]); if (define.loaded[name]) return; if (!deps && typeof callback == "function") deps = getInlineDeps(callback); define.loaded[name] = { id: name, deps: normalizeNames(name, deps || []), factory: callback, exports: {}, }; if (define.loading[name]) delete define.loading[name]; if (define.lastModule) define.pending.push(name); else define.lastModule = name; }; var defQueue = []; var nextModule; var addToLoadQueue = function(missing, deps, callback, errback) { var toLoad = missing.length; var map = {}; define.queue.push({ deps: deps, map: map, toLoad: toLoad, callback: callback, errback: errback, }); for (var i = 0; i < missing.length; ++i) { var p = missing[i]; map[p] = 1; if (!define.loading[p]) { define.loading[p] = 1; require.load(p); } } }; var processLoadQueue = function(err, id) { var changed = false; if (err) { if (!id) id = err.id; define.errors[id] = err; define.queue.forEach(function(r) { if (r.map[id]) { r.toLoad = -1; if (r.errback) r.errback(err); } }); if (define.lastModule == id) define.lastModule = null; define.pending = define.pending.filter(function(p) { return p != id; }); changed = true; } else if (id && !defQueue.length && !define.loaded[id]) { defQueue = [(config.shim && config.shim[id]) || [[], null]]; } if (defQueue.length) { if (defQueue.length > 1) { console.error("possible error, more than one module in defqueue", defQueue); defQueue = defQueue.slice(-1); } define(id, defQueue[0][0], defQueue[0][1]); defQueue.length = 0; } var pending = define.pending; define.queue.forEach(function(request) { pending.forEach(function(id) { if (request.map[id]) request.toLoad--; }); if (request.map[define.lastModule]) request.toLoad--; if (request.toLoad <= 0) { request.toLoad = NaN; changed = true; _require("", request.deps, request.callback, request.errback); } }); define.lastModule = null; if (pending.length) define.pending = []; if (changed) { define.queue = define.queue.filter(function(r) { return r.toLoad > 0; }); } }; define.amd = {}; define.queue = []; define.loaded = {}; define.errors = {}; define.loading = {}; define.pending = []; define.modules = {require: 1, exports: 1, module: 1}; define.fetchedUrls = {}; var activateModule = function(name) { var module = define.loaded[name]; if (module.getModuleDefinition) module = module.getModuleDefinition(module); var exports = module.exports; if (typeof module.factory !== "function") { exports = module.factory; } else { var req = function(path, callback) { return _require(name, path, callback); }; req.config = config; var missing = checkMissing(module.deps); if (missing.length) return missing; module.define = define; var specialModules = { require: req, exports: exports, module: module, }; if (name.lastIndexOf("architect!", 0) == 0 && !module.pluginFactory) { module.pluginFactory = module.factory; module.factory = activateArchitectModule; } define.modules[name] = exports; var args = module.deps.slice(0, module.factory.length); var returnValue = args.length ? module.factory.apply( module, args.map(function(name) { return specialModules[name] || lookup(name); }) ) : module.factory(req, exports, module); exports = returnValue == undefined ? module.exports : returnValue; } if (!config.$keepLoaders) delete define.loaded[name]; define.modules[name] = exports; }; var checkMissing = function(deps, seen, missing) { missing = missing || {}; seen = seen || {}; for (var i = 0; i < deps.length; ++i) { var depName = deps[i]; if (!define.modules[depName]) { var dep = define.loaded[depName]; if (!dep) missing[depName] = 1; else if (!missing[depName] && !seen[depName]) { seen[depName] = 1; checkMissing(dep.deps, seen, missing); } } } return Object.keys(missing); }; var lookup = function(moduleName) { var mod = define.modules[moduleName]; if (mod === undefined && define.loaded[moduleName]) { activateModule(moduleName); mod = define.modules[moduleName]; } return mod; }; function asyncRequire(parentId, moduleName, callback, errback) { var deps = normalizeNames(parentId, moduleName); var missing = checkMissing(deps); var result; if (!callback && !errback && typeof Promise == "function") { result = new Promise(function(resolve, reject) { callback = function() { resolve([].slice.call(arguments)); }; errback = reject; }); } if (!missing.length) { var args = deps.map(lookup); if (result) result.resolved = args; callback && callback.apply(null, args); } else { addToLoadQueue(missing, deps, callback, errback); } return result; } var _require = function(parentId, moduleName, callback, errback) { if (typeof moduleName === "string") { var depName = normalizeName(parentId, moduleName); var module = lookup(depName); if (module !== undefined) { if (typeof callback == "function") callback(module); return module; } else if (IN_WORKER || syncLoaders.test(moduleName)) { addToLoadQueue([depName], [depName]); return lookup(depName); } } else if (Array.isArray(moduleName)) { return asyncRequire(parentId, moduleName, callback, errback); } }; var normalizeName = function(parentId, moduleName) { if (/!/.test(parentId)) parentId = parentId.split("!").pop(); var i = moduleName.indexOf("!"); if (i !== -1) { return ( normalizeName(parentId, moduleName.slice(0, i)) + "!" + normalizeName(parentId, moduleName.slice(i + 1)) ); } if (moduleName.charAt(0) == ".") { var parentChunks = parentId.split("/"); var parentModule = parentChunks.shift(); if (parentModule.charAt(0) == "@") { parentModule = parentModule + "/" + parentChunks.shift(); } var path = parentChunks.slice(0, -1).join("/"); moduleName = parentModule + (path ? "/" + path : "") + "/" + moduleName; while (moduleName.indexOf(".") !== -1 && previous != moduleName) { var previous = moduleName; moduleName = moduleName.replace(/\/\.\//, "/").replace(/[^\/]+\/\.\.\//, ""); } } return moduleName; }; var normalizeNames = function(parentId, moduleNames) { return moduleNames.map(function(name) { return normalizeName(parentId, name); }); }; var require = function(module, callback, errback) { return _require("", module, callback, errback); }; var config = (require.config = function(cfg) { if (cfg.baseUrl) config.baseUrl = cfg.baseUrl.replace(/\/*$/, "/"); if (cfg.host) host = cfg.host; if (Array.isArray(cfg.packages)) { cfg.packages.forEach(function(pkg) { if (typeof pkg === "string") pkg = {name: pkg}; config.packages[pkg.name] = { name: pkg.name, location: (pkg.location || pkg.name).replace(/\/*$/, "/"), main: (pkg.main || "main").replace(/\.js$/, "").replace(/^\.\//, ""), }; }); } else if (cfg.packages) { config.packages = cfg.packages; } cfg.paths && Object.keys(cfg.paths).forEach(function(p) { config.paths[p] = cfg.paths[p]; }); if ("useDevBundle" in cfg) config.useDevBundle = cfg.useDevBundle; if (cfg.transform) config.transform = cfg.transform; if (/\bes5\b/.test(cfg.transform) && !global.shimIncluded) { if (!console.assert) { console.assert = function assert() {}; // This method is used by the following es6 shim. } var oldFlags = RegExp.prototype.flags; RegExp.prototype.flags = true; require(["js-polyfills/es6"]); RegExp.prototype.flags = oldFlags; global.shimIncluded = true; } if (cfg.MODULE_LOAD_URL) require.MODULE_LOAD_URL = cfg.MODULE_LOAD_URL; if (cfg.assetUrl) config.assetUrl = cfg.assetUrl; if (cfg.$keepLoaders != undefined) config.$keepLoaders = cfg.$keepLoaders; }); require.resetConfig = function(cfg) { config.packages = Object.create(null); config.paths = Object.create(null); config.baseUrl = ""; config.transform = ""; if (cfg) require.config(cfg); }; require.getConfig = function() { var script = document.querySelector("script[src*=mini_require]"); return { host: host, paths: config.paths, baseUrl: config.baseUrl, packages: config.packages, transform: config.transform, useDevBundle: config.useDevBundle, MODULE_LOAD_URL: require.MODULE_LOAD_URL, requireSourceUrl: !config.packed && script && script.src, assetUrl: config.assetUrl, }; }; require.resetConfig(); define.undef = require.undef = function(module, recursive) { module = normalizeName("", module); if (recursive) { var root = (module + "/").replace(/\/+$/, "/"); undefAll(root, define.errors); undefAll(root, define.loaded); undefAll(root, define.modules); undefAll(root, define.loading); } else { undefOne(module, require.toUrl(module, ".js")); } }; function undefOne(module, path) { delete define.errors[module]; delete define.loaded[module]; delete define.modules[module]; delete define.loading[module]; delete define.fetchedUrls[path]; } function undefAll(module, hash) { Object.keys(hash).forEach(function(key) { var i = key.indexOf("!") + 1; if (key.lastIndexOf(module, 0) == 0) undefOne(key, require.toUrl(key, ".js")); if (i) { var plugin = key.slice(0, i - 1); var resource = key.slice(i); if (resource.lastIndexOf(module, 0) == 0 || plugin.lastIndexOf(module, 0) == 0) { undefOne(key, require.toUrl(key, "")); undefOne(resource, require.toUrl(resource, "")); } } }); } require.MODULE_LOAD_URL = MODULE_LOAD_URL; require.toUrl = function(moduleName, ext, skipExt, isStatic) { var absRe = /^([\w\+\.\-]+:|\/)/; var index = moduleName.indexOf("!"); if (index !== -1 || !ext || /^\//.test(moduleName)) ext = ""; var paths = config.paths; var pkgs = config.packages; var testPath = moduleName; var tail = ""; while (testPath) { if (paths[testPath]) { moduleName = paths[testPath] + tail; break; } if (pkgs[testPath]) { moduleName = pkgs[testPath].location + (tail || pkgs[testPath].main); break; } var i = testPath.lastIndexOf("/"); if (i === -1) break; tail = testPath.substr(i) + tail; testPath = testPath.slice(0, i); } if (skipExt) return testPath; var url = ext == ".js" && moduleName.slice(-3) == ext ? moduleName : moduleName + ext; if (ext && moduleName.slice(-3) == ".ts") { url = moduleName.slice(0, -3) + ext; } if (!absRe.test(url)) { if (ext == ".js" && require.config.transform) url = addTransform(url, moduleName); var baseUrl = config.baseUrl; if (!baseUrl) { baseUrl = isStatic ? config.assetUrl || require.MODULE_LOAD_URL + "/../" : require.MODULE_LOAD_URL; } if (baseUrl.slice(-1) != "/") baseUrl += "/"; url = baseUrl + url; } if (url[0] == "/") url = host + url; return url; }; function addTransform(url, moduleName) { var transform = require.config.transform; if (!Array.isArray(transform)) transform = [transform]; return ( "~/" + transform .map(function(part) { if (typeof part == "string") return part; if (moduleName.lastIndexOf(part[0], 0) != -1) return part[1]; }) .filter(Boolean) .join(",") + "/" + url ).replace("//", "/"); } var loadScriptWithTag = function(path, id, callback) { if (IN_WORKER) { nextModule = {name: id, deps: null}; if (path[0] == "/") path = host + path; importScripts(path); return callback(null, id); } var head = document.head || document.documentElement; var s = document.createElement("script"); s.setAttribute("crossorigin", "anonymous"); s.src = path; s.charset = "utf-8"; s.async = true; s.onload = s.onreadystatechange = function(_, isAbort) { if ( isAbort || !s.readyState || s.readyState == "loaded" || s.readyState == "complete" ) { s.remove && s.remove(); s = s.onload = s.onreadystatechange = null; if (!isAbort) callback(null, id); } }; s.onerror = function(e) { processLoadQueue({ message: "Error loading script " + id + ":" + path, id: id, path: path, }); }; head.appendChild(s); }; function loadText(path, sync, callback) { if (!callback) { callback = sync; sync = false; } var xhr = new global.XMLHttpRequest(); xhr.open("GET", path, !sync); xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8"); xhr.onload = function(e) { if (xhr.status > 399 && xhr.status < 600) return callback(xhr); callback(null, xhr.responseText, xhr); }; xhr.onabort = xhr.onerror = function(e) { callback(e); }; xhr.send(""); } var loadScript = function(path, id, callback) { var useDevBundle = config.useDevBundle; if (typeof useDevBundle === "string") useDevBundle = id.match(useDevBundle); var isAbsoluteUrl = path === id; if (useDevBundle && !isAbsoluteUrl) { return loadDevBundle(path, id, callback); } return loadScriptWithTag(path, id, callback); }; function loadDevBundle(path, id, callback) { path = path + "?devBundle=1"; loadText(path, IN_WORKER, function(err, text, xhr) { if (err) return callback(err); parseDevBundle(text); var continuationToken = xhr.getResponseHeader("x-metadata-length"); if (!continuationToken) return callback(err, id); loadText(path + "&continue=" + continuationToken, IN_WORKER, function(err, text) { if (err) return callback(err); parseDevBundle(text, true); callback(err, id); }); }); } var DEV_BUNDLE_SEPARATOR = "\0\0"; function parseDevBundle(text, isDiff) { var parts = text.split(DEV_BUNDLE_SEPARATOR); for (var i = 1; i < parts.length; i += 2) { define.bundlePart(parts[i], parts[i + 1], isDiff); } return parts[0]; } define.bundlePart = function(id, source, reload) { if (reload) require.undef(id); var factory = /text!/.test(id) ? source : undefined; define.loaded[id] = { id: id, deps: [], factory: factory, exports: {}, getModuleDefinition: factory ? undefined : prepareBundlePart, _source: source, }; if (define.loading[id]) delete define.loading[id]; define.pending.push(id); }; function prepareBundlePart(part) { var id = part.id; define.loaded[id] = null; var source = part._source; nextModule = {name: id, deps: []}; var path = require.MODULE_LOAD_URL + "~/amd/" + id.replace(/^[^/!]+!/, "") + ".js"; if (path[0] == "/") path = host + path; global.eval(source + "\n//# sourceURL=" + path); nextModule = null; return define.loaded[id]; } require.load = function(module) { var i = module.indexOf("!") + 1; if (i) { var plugin = module.substring(0, i); module = module.substr(i); if (typeof require[plugin] == "function") { require[plugin](module, processLoadQueue); } else { console.error("require plugin " + plugin + "missing"); } } else { var url = require.toUrl(module, ".js"); if (define.fetchedUrls[url] & 1) return false; define.fetchedUrls[url] |= 1; loadScript(url, module, processLoadQueue); } }; var syncLoaders = /^(language!|webworker!|vfs!|asset-url!)/; require["language!"] = function(module, callback) { define("language!" + module, [], module); callback(); }; require["webworker!"] = function(module, callback) { var url = require.toUrl(module.split("!").pop(), ".js"); define("webworker!" + module, [], url); callback(); }; require["asset-url!"] = function(module, callback) { var url = require.toUrl(module.split("!").pop(), "", "", true); define("asset-url!" + module, [], url); callback(); }; require["vfs!"] = function(module, callback) { var url = require.MODULE_LOAD_URL + "/~node/" + module; if (define.fetchedUrls[url] & 4) return false; define.fetchedUrls[url] |= 4; define("vfs!" + module, [], { srcUrl: url, path: module, }); callback(); }; require["text!"] = function(module, callback) { var url = require.toUrl(module); if (define.fetchedUrls[url] & 2) return false; define.fetchedUrls[url] |= 2; var onLoad = function(e, val) { if (e) console.error("Couldn't load module " + module, e); define("text!" + module, [], val); callback(); }; loadText(url, onLoad); }; require["json!"] = function(module, callback) { require["text!"](module, function() { var val = JSON.parse(require("text!" + module)); define("json!" + module, [], val); callback(); }); }; require["architect-config!"] = function(module, callback) { var url = require.toUrl(module, ".js").replace("~/", "~/config,"); if (define.fetchedUrls[url] & 1) return false; define.fetchedUrls[url] |= 1; loadScript(url, "architect-config!" + module, processLoadQueue); }; require["ace/requirejs/text!"] = function(module, callback) { var url = require.toUrl(module); if (define.fetchedUrls[url] & 2) return false; define.fetchedUrls[url] |= 2; var onLoad = function(e, val) { if (e) console.error("Couldn't load module " + module, e); define("ace/requirejs/text!" + module, [], val); callback(); }; loadText(url, onLoad); }; require["architect!"] = function(module, callback) { var url = require.toUrl(module, ".js"); if (define.fetchedUrls[url] & 1) return false; define.fetchedUrls[url] |= 1; loadScript(url, "architect!" + module, processLoadQueue); }; function activateArchitectModule(_1, _2, _3) { var module = this; var wrapper = function() { module.pluginFactory(_1, _2, _3); var isOldStylePlugin = typeof module.exports == "function" && (module.exports.provides || module.exports.consumes); if (isOldStylePlugin) { return module.exports.apply(this, arguments); } return module.exports; }; wrapper.packagePath = module.id; return wrapper; } if (!global.define || !global.define.packaged) { define.original = global.define; global.define = define; global.define.packaged = true; } if (!global.require || !global.require.packaged) { global.require = require; global.require.packaged = true; } if (!global.requirejs) global.requirejs = require; global.miniRequire = require; })(); define("events",[], function(require, exports, module) { var EventEmitter = (exports.EventEmitter = function() {}); var toString = Object.prototype.toString; var isArray = Array.isArray || function(obj) { return toString.call(obj) === "[object Array]"; }; // var defaultMaxListeners = 10; EventEmitter.prototype.setMaxListeners = function(n) { if (!this._events) this._events = {}; this._events.maxListeners = n; }; EventEmitter.prototype.emit = function(type) { if (!this._events) return; var handler = this._events[type]; if (!handler) return; var returnValue; if (typeof handler == "function") { switch (arguments.length) { case 1: return handler.call(this); case 2: return handler.call(this, arguments[1]); case 3: return handler.call(this, arguments[1], arguments[2]); default: var args = Array.prototype.slice.call(arguments, 1); returnValue = handler.apply(this, args); } } else if (isArray(handler)) { var args = Array.prototype.slice.call(arguments, 1); var listeners = handler.slice(), temp; for (var i = 0, l = listeners.length; i < l; i++) { temp = listeners[i].apply(this, args); if (temp !== undefined) returnValue = temp; } } return returnValue; }; EventEmitter.prototype.addListener = function(type, listener, plugin) { if ("function" !== typeof listener) { throw new Error("addListener only takes instances of Function"); } if (!this._events) this._events = {}; var eventList = this._events[type]; if (!eventList) { this._events[type] = listener; } else if (isArray(eventList)) { if (!eventList.warned) { var m; if (this._events.maxListeners !== undefined) { m = this._events.maxListeners; } else { m = defaultMaxListeners; } if (m && m > 0 && eventList.length > m) { eventList.warned = true; console.error( "warning: possible EventEmitter memory " + 'leak detected. "' + eventList.length + '" listeners of type "' + type + '" added. ' + "Use emitter.setMaxListeners() to increase limit." ); console.trace(); } } eventList.push(listener); } else { this._events[type] = [eventList, listener]; } if (type != "newListener") this.emit("newListener", type, listener); plugin && plugin.addEvent(this, type, listener); return this; }; EventEmitter.prototype.on = EventEmitter.prototype.addListener; EventEmitter.prototype.once = function(type, listener, plugin) { var self = this; var wrapped = function() { self.removeListener(type, wrapped.listener); return wrapped.listener.apply(self, arguments); }; wrapped.listener = listener; self.on(type, wrapped, plugin); if (!listener) { return new Promise(function(resolve) { wrapped.listener = resolve; }); } return this; }; EventEmitter.prototype.removeListener = function(type, listener) { if ("function" !== typeof listener) { throw new Error("removeListener only takes instances of Function"); } if (!this._events || !this._events[type]) return this; var list = this._events[type]; if (isArray(list)) { if ( !list.some(function(l, i) { if ((l.listener || l) == listener) { list.splice(i, 1); return true; } }) ) return this; if (list.length === 0) delete this._events[type]; } else if ((this._events[type].listener || this._events[type]) === listener) { delete this._events[type]; } if (type != "removeListener") this.emit("removeListener", type, listener); return this; }; EventEmitter.prototype.off = EventEmitter.prototype.removeListener; EventEmitter.prototype.removeAllListeners = function(type) { if (type && this._events && this._events[type]) this._events[type] = null; return this; }; EventEmitter.prototype.listeners = function(type) { if (!this._events) this._events = {}; if (!this._events[type]) this._events[type] = []; if (!isArray(this._events[type])) { this._events[type] = [this._events[type]]; } return this._events[type]; }; }); define("architect/imports",[], function(require, exports, module) {"use strict"; exports.$setImports = function(value) { module.exports = value || {}; if (typeof define != "undefined" && define.modules) define.modules["architect/imports"] = value || {}; }; }); define("architect",[], function(require, exports, module) {"use strict"; var USE_PROXY = typeof Proxy != "undefined"; var LOADING = {}; var EventEmitter = require("events").EventEmitter; var currentApp = require("./imports"); currentApp.$setImports(null); function normalizeServiceName(name) { return name.replace(/[._\-]./g, ([dot, letter]) => letter.toUpperCase()); } function registerAlias(app, name, newPlugin, replace) { var normalizedName = normalizeServiceName(name); [ name, normalizedName, name.replace(/[.]./g, (x) => x[1].toUpperCase()), name.replace(/[._]./g, (x) => x[1].toUpperCase()), name.replace(/[a-z\d][A-Z]/g, (x) => x[0] + "." + x[1].toLowerCase()), name.replace(/[a-z\d][A-Z]/g, (x) => x[0] + "_" + x[1].toLowerCase()), ].forEach(function(x) { app.$alias[x] = normalizedName; if (app.$addServiceName) { app.$addServiceName(x); app.$addServiceName(x + "Options"); } }); if (replace || !app.serviceDefinitions[normalizedName]) app.serviceDefinitions[normalizedName] = newPlugin; } class Architect extends EventEmitter { constructor(config) { super(); var app = this; app.config = config; app.serviceToPlugin = {}; app.serviceDefinitions = {}; app.$alias = {}; var services = (app.services = {app, hub: app}); var handler = { get: function(target, name) { const dependency = app.getService(name); if (dependency instanceof Error) throw new Error(`Dependency ${name} failed to load.`); return dependency; }, }; if (USE_PROXY) { app.imports = new Proxy(services, handler); } else { app.imports = {}; app.$addServiceName = function(name) { app.imports.__defineGetter__(name, function() { return handler.get(null, name); }); }; Object.keys(services).forEach(app.$addServiceName); } app.addPlugins(config); services.imports = app.imports; } getService(name) { if (this.$alias[name]) name = this.$alias[name]; if (typeof name == "symbol") return this.services[name]; try { const result = this.services[name] || (name in this.serviceDefinitions && this.$activatePlugin(name)); if (result == LOADING) throw new Error(`Dependency cycle detected when loading ${name}`); if (!result) throw new Error(`Trying to access unknown service ${name}`); return result; } catch (err) { this.services[name] = err; return err; } } activate(pluginNames) { var serviceDefinitions = this.serviceDefinitions; if (!pluginNames) pluginNames = Object.keys(serviceDefinitions); var imports = this.imports; currentApp.$setImports(imports); var errors = {}; pluginNames.forEach((key) => { const service = this.getService(key); if (service instanceof Error) { errors[key] = service; } }); currentApp.$setImports(null); this.emit("ready"); if (Object.keys(errors).length > 0) { const err = new Error( "The following plugins failed to load:\n" + Object.keys(errors) .map((key) => key + ": " + errors[key].message) .reduce((a, b) => a + "\n" + b) ); err.errors = errors; throw err; } } $activatePlugin(name) { name = normalizeServiceName(name); var app = this; var options = this.serviceDefinitions[name]; var setup = options.setup; if (!setup && name.endsWith("Options")) return options; var optionsName = name + "Options"; if (this.serviceDefinitions[optionsName]) options = this.serviceDefinitions[optionsName]; var services = this.services; var imports = this.imports; services[name] = LOADING; function addDefinition(key) { var normalizedName = normalizeServiceName(key); if (services[normalizedName] && services[normalizedName] != LOADING) return console.error(`Plugin ${name} attempted to redefine ${normalizedName}`); services[normalizedName] = providedServices[key]; app.serviceToPlugin[normalizedName] = options; app.emit("service", normalizedName, providedServices[key]); } services[optionsName] = options; currentApp.$setImports(imports); var asyncResult; var asyncErr; var syncResult = setup(options, imports, function(err, result) { if (err) asyncErr = err; asyncResult = result || {}; }); if (asyncErr) { throw asyncErr; } var providedServices = asyncResult || syncResult; if (!providedServices) { throw new Error(`register for "${name}" was not called. Asynchronous registration of services is deprecated`); } if (!providedServices[name]) { if (/^[$_]|^\d+$/.test(name)) providedServices[name] = {}; } Object.keys(providedServices).forEach(addDefinition); if (services[name] == LOADING || !services[name]) { throw new Error(`${name} not provided by ${setup.packagePath || options.packagePath}`); } return services[name]; } addPlugins(newPlugins, options = {}) { Object.keys(newPlugins || {}).forEach((key) => { var newPlugin = newPlugins[key]; if (typeof newPlugin === "function") newPlugin = {setup: newPlugin}; if (!newPlugin.provides && newPlugin.setup) { newPlugin.provides = newPlugin.setup.provides; } if (typeof newPlugin.provides == "string") newPlugin.provides = [newPlugin.provides]; if (newPlugin.provides && newPlugin.provides.length) { newPlugin.provides.forEach((name) => { registerAlias(this, name, newPlugin, options.replace); }); } else { registerAlias(this, key, newPlugin, options.replace); } }); } } function createApp(config, callback) { var app; try { app = new Architect(config); } catch (err) { return callback(err, app); } setTimeout(function() { try { app.activate(); callback(null, app); } catch (err) { callback(err, app); } }); return app; } exports.createApp = createApp; exports.Architect = Architect; exports.$setImports = currentApp.$setImports; }); define("architect/requirejs-loader",[], function(require, exports, module) {"use strict"; exports.resolveConfig = function(config, callback) { return Array.isArray(config) ? resolveArrayConfig(config, callback) : resolveObjectConfig(config, callback); }; function resolveArrayConfig(config, callback) { var packagePaths = config .map(function(plugin) { if (typeof plugin === "string") return plugin; if (plugin.provides && plugin.packagePath && !/!/.test(plugin.packagePath)) return "architect!" + plugin.packagePath; return plugin.packagePath; }) .filter(function(path) { return !!path; }); var request = require(packagePaths); if (request.resolved) done(request.resolved); else request.then(done); function done(modules) { var i = 0; callback( null, config.map(function(plugin) { if (typeof plugin === "string") { return modules[i++]; } else if (plugin.packagePath) { plugin.setup = modules[i++]; return plugin; } else { return plugin; } }) ); } } function resolveObjectConfig(config, callback) { var keys = Object.keys(config); var packagePaths = keys .map(function(key) { var path = config[key]; if (typeof path === "string") return /!/.test(path) ? path : "architect!" + path; }) .filter(function(path) { return !!path; }); var request = require(packagePaths); if (request.resolved) done(request.resolved); else request.then(done); function done(modules) { var i = 0; keys.forEach(function(key) { if (typeof config[key] === "string") { config[key] = modules[i++]; } }); callback(null, config); } } }); define("@c9/ide/shared_bootstrap",[], function(require, exports, module) { exports.startArchitectApp = function(plugins, bootstrapStartTime) { var startingArchitectTime = Date.now(); var architect = require("architect"); var loader = require("architect/requirejs-loader"); return new Promise((resolve, reject) => { loader.resolveConfig( plugins, function(err, config) { if (err) throw err; var app = architect.createApp(config, (err, architectApp) => { onArchitectReady(err, architectApp); if (err) return reject(err); resolve(architectApp); }); app.on("service", function(name, plugin, options) { if (!plugin.name) plugin.name = name; }); }, function loadError(mod) { const loadErrorMessage = "Unable to load html5.js.\n\nThis may be caused by a false positive in your virus scanner. Please try reloading with ?packed=1 added to the URL."; if (mod.id === "@c9/ide/plugins/c9.ide.clipboard/html5") return alert(loadErrorMessage); } ); }); function onArchitectReady(err, architectApp) { var architectReadyTime = Date.now(); var services = architectApp.services; if (err) { const dialogError = services.dialogError; if (dialogError && dialogError.show) { dialogError.show(err); } else { alert(err); } const logger = services.logger; if (logger && logger.logUncaughtException) { logger.logUncaughtException(err); for (const plugin of Object.keys(err.errors)) { logger.logUncaughtException(err.errors[plugin]); } } else { console.error(err.stack); } } if (services.configure) services.configure.services = services; window.app = services; var c9 = services.c9; var clientMetrics = services.clientMetrics; var tabManager = services.tabManager; tabManager.on("tabManagerLoadedState", () => { clientMetrics.addValue( "architectReadyToTabsLoadedTime", Date.now() - architectReadyTime ); clientMetrics.addValue( "bootstrapStartToTabsLoadedTime", Date.now() - bootstrapStartTime ); }); c9.ready(); clientMetrics.addValue( "bootstrapStartToStartArchitect", startingArchitectTime - bootstrapStartTime ); clientMetrics.addValue( "architectCreateAppTime", architectReadyTime - startingArchitectTime ); c9.totalLoadTime = architectReadyTime - bootstrapStartTime; } }; exports.renderLoadingScreen = function(architectReadyPromise, bootstrapStartTime, options = {}) { if (document.readyState === "loading") { document.addEventListener("DOMContentLoaded", () => renderLoadingScreenAfterContentLoaded( architectReadyPromise, bootstrapStartTime, options ) ); } else { renderLoadingScreenAfterContentLoaded(architectReadyPromise, bootstrapStartTime, options); } }; function renderLoadingScreenAfterContentLoaded( architectReadyPromise, bootstrapStartTime, options = {} ) { const onLoadingTooLong = options.onLoadingTooLong || function() {}; document.body.innerHTML = '