First separation commit.
Added LICENSE, README.md, CONTRIBUTORS.md
This commit is contained in:
Erwin de Haan
parent
09513af31b
commit
4678528d00
657 changed files with 422 additions and 0 deletions
418
src/bower_components/alameda/alameda.js
vendored
Normal file
418
src/bower_components/alameda/alameda.js
vendored
Normal file
|
|
@ -0,0 +1,418 @@
|
|||
var requirejs, require, define;
|
||||
! function(global, Promise, undef) {
|
||||
function commentReplace(match, singlePrefix) {
|
||||
return singlePrefix || ""
|
||||
}
|
||||
|
||||
function hasProp(obj, prop) {
|
||||
return hasOwn.call(obj, prop)
|
||||
}
|
||||
|
||||
function getOwn(obj, prop) {
|
||||
return obj && hasProp(obj, prop) && obj[prop]
|
||||
}
|
||||
|
||||
function obj() {
|
||||
return Object.create(null)
|
||||
}
|
||||
|
||||
function eachProp(obj, func) {
|
||||
var prop;
|
||||
for (prop in obj)
|
||||
if (hasProp(obj, prop) && func(obj[prop], prop)) break
|
||||
}
|
||||
|
||||
function mixin(target, source, force, deepStringMixin) {
|
||||
return source && eachProp(source, function(value, prop) {
|
||||
!force && hasProp(target, prop) || (!deepStringMixin || "object" != typeof value || !value || Array.isArray(value) || "function" == typeof value || value instanceof RegExp ? target[prop] = value : (target[prop] || (target[prop] = {}), mixin(target[prop], value, force, deepStringMixin)))
|
||||
}), target
|
||||
}
|
||||
|
||||
function getGlobal(value) {
|
||||
if (!value) return value;
|
||||
var g = global;
|
||||
return value.split(".").forEach(function(part) {
|
||||
g = g[part]
|
||||
}), g
|
||||
}
|
||||
|
||||
function newContext(contextName) {
|
||||
function trimDots(ary) {
|
||||
var i, part, length = ary.length;
|
||||
for (i = 0; i < length; i++)
|
||||
if ("." === (part = ary[i])) ary.splice(i, 1), i -= 1;
|
||||
else if (".." === part) {
|
||||
if (0 === i || 1 === i && ".." === ary[2] || ".." === ary[i - 1]) continue;
|
||||
i > 0 && (ary.splice(i - 1, 2), i -= 2)
|
||||
}
|
||||
}
|
||||
|
||||
function normalize(name, baseName, applyMap) {
|
||||
var mapValue, nameParts, i, j, nameSegment, lastIndex, foundMap, foundI, foundStarMap, starI, baseParts = baseName && baseName.split("/"),
|
||||
normalizedBaseParts = baseParts,
|
||||
map = config.map,
|
||||
starMap = map && map["*"];
|
||||
if (name && (name = name.split("/"), lastIndex = name.length - 1, config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex]) && (name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, "")), "." === name[0].charAt(0) && baseParts && (normalizedBaseParts = baseParts.slice(0, baseParts.length - 1), name = normalizedBaseParts.concat(name)), trimDots(name), name = name.join("/")), applyMap && map && (baseParts || starMap)) {
|
||||
nameParts = name.split("/");
|
||||
outerLoop: for (i = nameParts.length; i > 0; i -= 1) {
|
||||
if (nameSegment = nameParts.slice(0, i).join("/"), baseParts)
|
||||
for (j = baseParts.length; j > 0; j -= 1)
|
||||
if ((mapValue = getOwn(map, baseParts.slice(0, j).join("/"))) && (mapValue = getOwn(mapValue, nameSegment))) {
|
||||
foundMap = mapValue, foundI = i;
|
||||
break outerLoop
|
||||
}! foundStarMap && starMap && getOwn(starMap, nameSegment) && (foundStarMap = getOwn(starMap, nameSegment), starI = i)
|
||||
}!foundMap && foundStarMap && (foundMap = foundStarMap, foundI = starI), foundMap && (nameParts.splice(0, foundI, foundMap), name = nameParts.join("/"))
|
||||
}
|
||||
return getOwn(config.pkgs, name) || name
|
||||
}
|
||||
|
||||
function makeShimExports(value) {
|
||||
function fn() {
|
||||
var ret;
|
||||
return value.init && (ret = value.init.apply(global, arguments)), ret || value.exports && getGlobal(value.exports)
|
||||
}
|
||||
return fn
|
||||
}
|
||||
|
||||
function takeQueue(anonId) {
|
||||
var i, id, args, shim;
|
||||
for (i = 0; i < queue.length; i += 1) {
|
||||
if ("string" != typeof queue[i][0]) {
|
||||
if (!anonId) break;
|
||||
queue[i].unshift(anonId), anonId = undef
|
||||
}
|
||||
args = queue.shift(), id = args[0], i -= 1, id in defined || id in waiting || (id in deferreds ? main.apply(undef, args) : waiting[id] = args)
|
||||
}
|
||||
anonId && (shim = getOwn(config.shim, anonId) || {}, main(anonId, shim.deps || [], shim.exportsFn))
|
||||
}
|
||||
|
||||
function makeRequire(relName, topLevel) {
|
||||
var req = function(deps, callback, errback, alt) {
|
||||
var name, cfg;
|
||||
if (topLevel && takeQueue(), "string" == typeof deps) {
|
||||
if (handlers[deps]) return handlers[deps](relName);
|
||||
if (!((name = makeMap(deps, relName, !0).id) in defined)) throw new Error("Not loaded: " + name);
|
||||
return defined[name]
|
||||
}
|
||||
return deps && !Array.isArray(deps) && (cfg = deps, deps = undef, Array.isArray(callback) && (deps = callback, callback = errback, errback = alt), topLevel) ? req.config(cfg)(deps, callback, errback) : (callback = callback || function() {
|
||||
return slice.call(arguments, 0)
|
||||
}, asyncResolve.then(function() {
|
||||
return takeQueue(), main(undef, deps || [], callback, errback, relName)
|
||||
}))
|
||||
};
|
||||
return req.isBrowser = "undefined" != typeof document && "undefined" != typeof navigator, req.nameToUrl = function(moduleName, ext, skipExt) {
|
||||
var paths, syms, i, parentModule, url, parentPath, bundleId, pkgMain = getOwn(config.pkgs, moduleName);
|
||||
if (pkgMain && (moduleName = pkgMain), bundleId = getOwn(bundlesMap, moduleName)) return req.nameToUrl(bundleId, ext, skipExt);
|
||||
if (urlRegExp.test(moduleName)) url = moduleName + (ext || "");
|
||||
else {
|
||||
for (paths = config.paths, syms = moduleName.split("/"), i = syms.length; i > 0; i -= 1)
|
||||
if (parentModule = syms.slice(0, i).join("/"), parentPath = getOwn(paths, parentModule)) {
|
||||
Array.isArray(parentPath) && (parentPath = parentPath[0]), syms.splice(0, i, parentPath);
|
||||
break
|
||||
} url = syms.join("/"), url += ext || (/^data\:|^blob\:|\?/.test(url) || skipExt ? "" : ".js"), url = ("/" === url.charAt(0) || url.match(/^[\w\+\.\-]+:/) ? "" : config.baseUrl) + url
|
||||
}
|
||||
return config.urlArgs && !/^blob\:/.test(url) ? url + config.urlArgs(moduleName, url) : url
|
||||
}, req.toUrl = function(moduleNamePlusExt) {
|
||||
var ext, index = moduleNamePlusExt.lastIndexOf("."),
|
||||
segment = moduleNamePlusExt.split("/")[0],
|
||||
isRelative = "." === segment || ".." === segment;
|
||||
return -1 !== index && (!isRelative || index > 1) && (ext = moduleNamePlusExt.substring(index, moduleNamePlusExt.length), moduleNamePlusExt = moduleNamePlusExt.substring(0, index)), req.nameToUrl(normalize(moduleNamePlusExt, relName), ext, !0)
|
||||
}, req.defined = function(id) {
|
||||
return makeMap(id, relName, !0).id in defined
|
||||
}, req.specified = function(id) {
|
||||
return (id = makeMap(id, relName, !0).id) in defined || id in deferreds
|
||||
}, req
|
||||
}
|
||||
|
||||
function resolve(name, d, value) {
|
||||
name && (defined[name] = value, requirejs.onResourceLoad && requirejs.onResourceLoad(context, d.map, d.deps)), d.finished = !0, d.resolve(value)
|
||||
}
|
||||
|
||||
function reject(d, err) {
|
||||
d.finished = !0, d.rejected = !0, d.reject(err)
|
||||
}
|
||||
|
||||
function makeNormalize(relName) {
|
||||
return function(name) {
|
||||
return normalize(name, relName, !0)
|
||||
}
|
||||
}
|
||||
|
||||
function defineModule(d) {
|
||||
d.factoryCalled = !0;
|
||||
var ret, name = d.map.id;
|
||||
try {
|
||||
ret = context.execCb(name, d.factory, d.values, defined[name])
|
||||
} catch (err) {
|
||||
return reject(d, err)
|
||||
}
|
||||
name ? ret === undef && (d.cjsModule ? ret = d.cjsModule.exports : d.usingExports && (ret = defined[name])) : requireDeferreds.splice(requireDeferreds.indexOf(d), 1), resolve(name, d, ret)
|
||||
}
|
||||
|
||||
function depFinished(val, i) {
|
||||
this.rejected || this.depDefined[i] || (this.depDefined[i] = !0, this.depCount += 1, this.values[i] = val, this.depending || this.depCount !== this.depMax || defineModule(this))
|
||||
}
|
||||
|
||||
function makeDefer(name, calculatedMap) {
|
||||
var d = {};
|
||||
return d.promise = new Promise(function(resolve, reject) {
|
||||
d.resolve = resolve, d.reject = function(err) {
|
||||
name || requireDeferreds.splice(requireDeferreds.indexOf(d), 1), reject(err)
|
||||
}
|
||||
}), d.map = name ? calculatedMap || makeMap(name) : {}, d.depCount = 0, d.depMax = 0, d.values = [], d.depDefined = [], d.depFinished = depFinished, d.map.pr && (d.deps = [makeMap(d.map.pr)]), d
|
||||
}
|
||||
|
||||
function getDefer(name, calculatedMap) {
|
||||
var d;
|
||||
return name ? (d = name in deferreds && deferreds[name]) || (d = deferreds[name] = makeDefer(name, calculatedMap)) : (d = makeDefer(), requireDeferreds.push(d)), d
|
||||
}
|
||||
|
||||
function makeErrback(d, name) {
|
||||
return function(err) {
|
||||
d.rejected || (err.dynaId || (err.dynaId = "id" + (errCount += 1), err.requireModules = [name]), reject(d, err))
|
||||
}
|
||||
}
|
||||
|
||||
function waitForDep(depMap, relName, d, i) {
|
||||
d.depMax += 1, callDep(depMap, relName).then(function(val) {
|
||||
d.depFinished(val, i)
|
||||
}, makeErrback(d, depMap.id)).catch(makeErrback(d, d.map.id))
|
||||
}
|
||||
|
||||
function makeLoad(id) {
|
||||
function load(value) {
|
||||
fromTextCalled || resolve(id, getDefer(id), value)
|
||||
}
|
||||
var fromTextCalled;
|
||||
return load.error = function(err) {
|
||||
reject(getDefer(id), err)
|
||||
}, load.fromText = function(text, textAlt) {
|
||||
var execError, d = getDefer(id),
|
||||
map = makeMap(makeMap(id).n),
|
||||
plainId = map.id;
|
||||
fromTextCalled = !0, d.factory = function(p, val) {
|
||||
return val
|
||||
}, textAlt && (text = textAlt), hasProp(config.config, id) && (config.config[plainId] = config.config[id]);
|
||||
try {
|
||||
req.exec(text)
|
||||
} catch (e) {
|
||||
execError = new Error("fromText eval for " + plainId + " failed: " + e), execError.requireType = "fromtexteval", reject(d, execError)
|
||||
}
|
||||
takeQueue(plainId), d.deps = [map], waitForDep(map, null, d, d.deps.length)
|
||||
}, load
|
||||
}
|
||||
|
||||
function callPlugin(plugin, map, relName) {
|
||||
plugin.load(map.n, makeRequire(relName), makeLoad(map.id), config)
|
||||
}
|
||||
|
||||
function splitPrefix(name) {
|
||||
var prefix, index = name ? name.indexOf("!") : -1;
|
||||
return index > -1 && (prefix = name.substring(0, index), name = name.substring(index + 1, name.length)), [prefix, name]
|
||||
}
|
||||
|
||||
function breakCycle(d, traced, processed) {
|
||||
var id = d.map.id;
|
||||
traced[id] = !0, !d.finished && d.deps && d.deps.forEach(function(depMap) {
|
||||
var depId = depMap.id,
|
||||
dep = !hasProp(handlers, depId) && getDefer(depId, depMap);
|
||||
!dep || dep.finished || processed[depId] || (hasProp(traced, depId) ? d.deps.forEach(function(depMap, i) {
|
||||
depMap.id === depId && d.depFinished(defined[depId], i)
|
||||
}) : breakCycle(dep, traced, processed))
|
||||
}), processed[id] = !0
|
||||
}
|
||||
|
||||
function check(d) {
|
||||
var err, mid, dfd, notFinished = [],
|
||||
waitInterval = 1e3 * config.waitSeconds,
|
||||
expired = waitInterval && startTime + waitInterval < (new Date).getTime();
|
||||
if (0 === loadCount && (d ? d.finished || breakCycle(d, {}, {}) : requireDeferreds.length && requireDeferreds.forEach(function(d) {
|
||||
breakCycle(d, {}, {})
|
||||
})), expired) {
|
||||
for (mid in deferreds) dfd = deferreds[mid], dfd.finished || notFinished.push(dfd.map.id);
|
||||
err = new Error("Timeout for modules: " + notFinished), err.requireModules = notFinished, err.requireType = "timeout", notFinished.forEach(function(id) {
|
||||
reject(getDefer(id), err)
|
||||
})
|
||||
} else(loadCount || requireDeferreds.length) && (checkingLater || (checkingLater = !0, setTimeout(function() {
|
||||
checkingLater = !1, check()
|
||||
}, 70)))
|
||||
}
|
||||
|
||||
function delayedError(e) {
|
||||
return setTimeout(function() {
|
||||
e.dynaId && trackedErrors[e.dynaId] || (trackedErrors[e.dynaId] = !0, req.onError(e))
|
||||
}), e
|
||||
}
|
||||
var req, main, makeMap, callDep, handlers, checkingLater, load, context, defined = obj(),
|
||||
waiting = obj(),
|
||||
config = {
|
||||
waitSeconds: 7,
|
||||
baseUrl: "./",
|
||||
paths: {},
|
||||
bundles: {},
|
||||
pkgs: {},
|
||||
shim: {},
|
||||
config: {}
|
||||
},
|
||||
mapCache = obj(),
|
||||
requireDeferreds = [],
|
||||
deferreds = obj(),
|
||||
calledDefine = obj(),
|
||||
calledPlugin = obj(),
|
||||
loadCount = 0,
|
||||
startTime = (new Date).getTime(),
|
||||
errCount = 0,
|
||||
trackedErrors = obj(),
|
||||
urlFetched = obj(),
|
||||
bundlesMap = obj(),
|
||||
asyncResolve = Promise.resolve();
|
||||
return load = "function" == typeof importScripts ? function(map) {
|
||||
var url = map.url;
|
||||
urlFetched[url] || (urlFetched[url] = !0, getDefer(map.id), importScripts(url), takeQueue(map.id))
|
||||
} : function(map) {
|
||||
var script, id = map.id,
|
||||
url = map.url;
|
||||
urlFetched[url] || (urlFetched[url] = !0, script = document.createElement("script"), script.setAttribute("data-requiremodule", id), script.type = config.scriptType || "text/javascript", script.charset = "utf-8", script.async = !0, loadCount += 1, script.addEventListener("load", function() {
|
||||
loadCount -= 1, takeQueue(id)
|
||||
}, !1), script.addEventListener("error", function() {
|
||||
loadCount -= 1;
|
||||
var err, pathConfig = getOwn(config.paths, id);
|
||||
if (pathConfig && Array.isArray(pathConfig) && pathConfig.length > 1) {
|
||||
script.parentNode.removeChild(script), pathConfig.shift();
|
||||
var d = getDefer(id);
|
||||
d.map = makeMap(id), d.map.url = req.nameToUrl(id), load(d.map)
|
||||
} else err = new Error("Load failed: " + id + ": " + script.src), err.requireModules = [id], err.requireType = "scripterror", reject(getDefer(id), err)
|
||||
}, !1), script.src = url, 10 === document.documentMode ? asap.then(function() {
|
||||
document.head.appendChild(script)
|
||||
}) : document.head.appendChild(script))
|
||||
}, callDep = function(map, relName) {
|
||||
var args, bundleId, name = map.id,
|
||||
shim = config.shim[name];
|
||||
if (name in waiting) args = waiting[name], delete waiting[name], main.apply(undef, args);
|
||||
else if (!(name in deferreds))
|
||||
if (map.pr) {
|
||||
if (!(bundleId = getOwn(bundlesMap, name))) return callDep(makeMap(map.pr)).then(function(plugin) {
|
||||
var newMap = map.prn ? map : makeMap(name, relName, !0),
|
||||
newId = newMap.id,
|
||||
shim = getOwn(config.shim, newId);
|
||||
return newId in calledPlugin || (calledPlugin[newId] = !0, shim && shim.deps ? req(shim.deps, function() {
|
||||
callPlugin(plugin, newMap, relName)
|
||||
}) : callPlugin(plugin, newMap, relName)), getDefer(newId).promise
|
||||
});
|
||||
map.url = req.nameToUrl(bundleId), load(map)
|
||||
} else shim && shim.deps ? req(shim.deps, function() {
|
||||
load(map)
|
||||
}) : load(map);
|
||||
return getDefer(name).promise
|
||||
}, makeMap = function(name, relName, applyMap) {
|
||||
if ("string" != typeof name) return name;
|
||||
var plugin, url, parts, prefix, result, prefixNormalized, cacheKey = name + " & " + (relName || "") + " & " + !!applyMap;
|
||||
return parts = splitPrefix(name), prefix = parts[0], name = parts[1], !prefix && cacheKey in mapCache ? mapCache[cacheKey] : (prefix && (prefix = normalize(prefix, relName, applyMap), plugin = prefix in defined && defined[prefix]), prefix ? plugin && plugin.normalize ? (name = plugin.normalize(name, makeNormalize(relName)), prefixNormalized = !0) : name = -1 === name.indexOf("!") ? normalize(name, relName, applyMap) : name : (name = normalize(name, relName, applyMap), parts = splitPrefix(name), prefix = parts[0], name = parts[1], url = req.nameToUrl(name)), result = {
|
||||
id: prefix ? prefix + "!" + name : name,
|
||||
n: name,
|
||||
pr: prefix,
|
||||
url: url,
|
||||
prn: prefix && prefixNormalized
|
||||
}, prefix || (mapCache[cacheKey] = result), result)
|
||||
}, handlers = {
|
||||
require: function(name) {
|
||||
return makeRequire(name)
|
||||
},
|
||||
exports: function(name) {
|
||||
var e = defined[name];
|
||||
return void 0 !== e ? e : defined[name] = {}
|
||||
},
|
||||
module: function(name) {
|
||||
return {
|
||||
id: name,
|
||||
uri: "",
|
||||
exports: handlers.exports(name),
|
||||
config: function() {
|
||||
return getOwn(config.config, name) || {}
|
||||
}
|
||||
}
|
||||
}
|
||||
}, main = function(name, deps, factory, errback, relName) {
|
||||
if (name) {
|
||||
if (name in calledDefine) return;
|
||||
calledDefine[name] = !0
|
||||
}
|
||||
var d = getDefer(name);
|
||||
return deps && !Array.isArray(deps) && (factory = deps, deps = []), deps = deps ? slice.call(deps, 0) : null, errback || (hasProp(config, "defaultErrback") ? config.defaultErrback && (errback = config.defaultErrback) : errback = delayedError), errback && d.promise.catch(errback), relName = relName || name, "function" == typeof factory ? (!deps.length && factory.length && (factory.toString().replace(commentRegExp, commentReplace).replace(cjsRequireRegExp, function(match, dep) {
|
||||
deps.push(dep)
|
||||
}), deps = (1 === factory.length ? ["require"] : ["require", "exports", "module"]).concat(deps)), d.factory = factory, d.deps = deps, d.depending = !0, deps.forEach(function(depName, i) {
|
||||
var depMap;
|
||||
deps[i] = depMap = makeMap(depName, relName, !0), depName = depMap.id, "require" === depName ? d.values[i] = handlers.require(name) : "exports" === depName ? (d.values[i] = handlers.exports(name), d.usingExports = !0) : "module" === depName ? d.values[i] = d.cjsModule = handlers.module(name) : void 0 === depName ? d.values[i] = void 0 : waitForDep(depMap, relName, d, i)
|
||||
}), d.depending = !1, d.depCount === d.depMax && defineModule(d)) : name && resolve(name, d, factory), startTime = (new Date).getTime(), name || check(d), d.promise
|
||||
}, req = makeRequire(null, !0), req.config = function(cfg) {
|
||||
if (cfg.context && cfg.context !== contextName) {
|
||||
var existingContext = getOwn(contexts, cfg.context);
|
||||
return existingContext ? existingContext.req.config(cfg) : newContext(cfg.context).config(cfg)
|
||||
}
|
||||
if (mapCache = obj(), cfg.baseUrl && "/" !== cfg.baseUrl.charAt(cfg.baseUrl.length - 1) && (cfg.baseUrl += "/"), "string" == typeof cfg.urlArgs) {
|
||||
var urlArgs = cfg.urlArgs;
|
||||
cfg.urlArgs = function(id, url) {
|
||||
return (-1 === url.indexOf("?") ? "?" : "&") + urlArgs
|
||||
}
|
||||
}
|
||||
var shim = config.shim,
|
||||
objs = {
|
||||
paths: !0,
|
||||
bundles: !0,
|
||||
config: !0,
|
||||
map: !0
|
||||
};
|
||||
return eachProp(cfg, function(value, prop) {
|
||||
objs[prop] ? (config[prop] || (config[prop] = {}), mixin(config[prop], value, !0, !0)) : config[prop] = value
|
||||
}), cfg.bundles && eachProp(cfg.bundles, function(value, prop) {
|
||||
value.forEach(function(v) {
|
||||
v !== prop && (bundlesMap[v] = prop)
|
||||
})
|
||||
}), cfg.shim && (eachProp(cfg.shim, function(value, id) {
|
||||
Array.isArray(value) && (value = {
|
||||
deps: value
|
||||
}), !value.exports && !value.init || value.exportsFn || (value.exportsFn = makeShimExports(value)), shim[id] = value
|
||||
}), config.shim = shim), cfg.packages && cfg.packages.forEach(function(pkgObj) {
|
||||
var location, name;
|
||||
pkgObj = "string" == typeof pkgObj ? {
|
||||
name: pkgObj
|
||||
} : pkgObj, name = pkgObj.name, location = pkgObj.location, location && (config.paths[name] = pkgObj.location), config.pkgs[name] = pkgObj.name + "/" + (pkgObj.main || "main").replace(currDirRegExp, "").replace(jsSuffixRegExp, "")
|
||||
}), (cfg.deps || cfg.callback) && req(cfg.deps, cfg.callback), req
|
||||
}, req.onError = function(err) {
|
||||
throw err
|
||||
}, context = {
|
||||
id: contextName,
|
||||
defined: defined,
|
||||
waiting: waiting,
|
||||
config: config,
|
||||
deferreds: deferreds,
|
||||
req: req,
|
||||
execCb: function(name, callback, args, exports) {
|
||||
return callback.apply(exports, args)
|
||||
}
|
||||
}, contexts[contextName] = context, req
|
||||
}
|
||||
if (!Promise) throw new Error("No Promise implementation available");
|
||||
var topReq, dataMain, src, subPath, bootstrapConfig = requirejs || require,
|
||||
hasOwn = Object.prototype.hasOwnProperty,
|
||||
contexts = {},
|
||||
queue = [],
|
||||
currDirRegExp = /^\.\//,
|
||||
urlRegExp = /^\/|\:|\?|\.js$/,
|
||||
commentRegExp = /\/\*[\s\S]*?\*\/|([^:"'=]|^)\/\/.*$/gm,
|
||||
cjsRequireRegExp = /[^.]\s*require\s*\(\s*["']([^'"\s]+)["']\s*\)/g,
|
||||
jsSuffixRegExp = /\.js$/,
|
||||
slice = Array.prototype.slice;
|
||||
if ("function" != typeof requirejs) {
|
||||
var asap = Promise.resolve(void 0);
|
||||
requirejs = topReq = newContext("_"), "function" != typeof require && (require = topReq), topReq.exec = function(text) {
|
||||
return eval(text)
|
||||
}, topReq.contexts = contexts, define = function() {
|
||||
queue.push(slice.call(arguments, 0))
|
||||
}, define.amd = {
|
||||
jQuery: !0
|
||||
}, bootstrapConfig && topReq.config(bootstrapConfig), topReq.isBrowser && !contexts._.config.skipDataMain && (dataMain = document.querySelectorAll("script[data-main]")[0], (dataMain = dataMain && dataMain.getAttribute("data-main")) && (dataMain = dataMain.replace(jsSuffixRegExp, ""), bootstrapConfig && bootstrapConfig.baseUrl || -1 !== dataMain.indexOf("!") || (src = dataMain.split("/"), dataMain = src.pop(), subPath = src.length ? src.join("/") + "/" : "./", topReq.config({
|
||||
baseUrl: subPath
|
||||
})), topReq([dataMain])))
|
||||
}
|
||||
}(this, "undefined" != typeof Promise ? Promise : void 0);
|
||||
Loading…
Add table
Add a link
Reference in a new issue