can
Version:
MIT-licensed, client-side, JavaScript framework that makes building rich web applications easy.
1,069 lines (1,068 loc) • 324 kB
JavaScript
/*[system-bundles-config]*/
System.bundles = {"bundles/bit-docs-site/static.css!":["bit-docs-html-canjs@0.4.6#static/canjs.less!$less","bit-docs-prettify@0.1.1#prettify.less!$less","bit-docs-site@0.0.1#styles/styles.less!$less"]};
/*npm-utils*/
define('npm-utils', function (require, exports, module) {
(function (global) {
var slice = Array.prototype.slice;
var npmModuleRegEx = /.+@.+\..+\..+#.+/;
var conditionalModuleRegEx = /#\{[^\}]+\}|#\?.+$/;
var utils = {
extend: function (d, s, deep) {
var val;
for (var prop in s) {
val = s[prop];
if (deep) {
if (utils.isArray(val)) {
d[prop] = slice.call(val);
} else if (utils.isObject(val)) {
d[prop] = utils.extend({}, val, deep);
} else {
d[prop] = s[prop];
}
} else {
d[prop] = s[prop];
}
}
return d;
},
map: function (arr, fn) {
var i = 0, len = arr.length, out = [];
for (; i < len; i++) {
out.push(fn.call(arr, arr[i]));
}
return out;
},
filter: function (arr, fn) {
var i = 0, len = arr.length, out = [], res;
for (; i < len; i++) {
res = fn.call(arr, arr[i]);
if (res) {
out.push(arr[i]);
}
}
return out;
},
forEach: function (arr, fn) {
var i = 0, len = arr.length;
for (; i < len; i++) {
fn.call(arr, arr[i], i);
}
},
isObject: function (obj) {
return typeof obj === 'object';
},
isArray: Array.isArray || function (arr) {
return Object.prototype.toString.call(arr) === '[object Array]';
},
isEnv: function (name) {
return this.isEnv ? this.isEnv(name) : this.env === name;
},
warnOnce: function (msg) {
var w = this._warnings = this._warnings || {};
if (w[msg])
return;
w[msg] = true;
if (typeof steal !== 'undefined' && typeof console !== 'undefined' && console.warn) {
steal.done().then(function () {
console.warn(msg);
});
}
},
relativeURI: function (baseURL, url) {
return typeof steal !== 'undefined' ? steal.relativeURI(baseURL, url) : url;
},
moduleName: {
create: function (descriptor, standard) {
if (standard) {
return descriptor.moduleName;
} else {
if (descriptor === '@empty') {
return descriptor;
}
var modulePath;
if (descriptor.modulePath) {
modulePath = descriptor.modulePath.substr(0, 2) === './' ? descriptor.modulePath.substr(2) : descriptor.modulePath;
}
return descriptor.packageName + (descriptor.version ? '@' + descriptor.version : '') + (modulePath ? '#' + modulePath : '') + (descriptor.plugin ? descriptor.plugin : '');
}
},
isNpm: function (moduleName) {
return npmModuleRegEx.test(moduleName);
},
isConditional: function (moduleName) {
return conditionalModuleRegEx.test(moduleName);
},
isFullyConvertedNpm: function (parsedModuleName) {
return !!(parsedModuleName.packageName && parsedModuleName.version && parsedModuleName.modulePath);
},
isScoped: function (moduleName) {
return moduleName[0] === '@';
},
parse: function (moduleName, currentPackageName, global) {
var pluginParts = moduleName.split('!');
var modulePathParts = pluginParts[0].split('#');
var versionParts = modulePathParts[0].split('@');
if (!modulePathParts[1] && !versionParts[0]) {
versionParts = ['@' + versionParts[1]];
}
if (versionParts.length === 3 && utils.moduleName.isScoped(moduleName)) {
versionParts.splice(0, 1);
versionParts[0] = '@' + versionParts[0];
}
var packageName, modulePath;
if (currentPackageName && utils.path.isRelative(moduleName)) {
packageName = currentPackageName;
modulePath = versionParts[0];
} else {
if (modulePathParts[1]) {
packageName = versionParts[0];
modulePath = modulePathParts[1];
} else {
var folderParts = versionParts[0].split('/');
if (folderParts.length && folderParts[0][0] === '@') {
packageName = folderParts.splice(0, 2).join('/');
} else {
packageName = folderParts.shift();
}
modulePath = folderParts.join('/');
}
}
return {
plugin: pluginParts.length === 2 ? '!' + pluginParts[1] : undefined,
version: versionParts[1],
modulePath: modulePath,
packageName: packageName,
moduleName: moduleName,
isGlobal: global
};
},
parseFromPackage: function (loader, refPkg, name, parentName) {
var packageName = utils.pkg.name(refPkg), parsedModuleName = utils.moduleName.parse(name, packageName), isRelative = utils.path.isRelative(parsedModuleName.modulePath);
if (isRelative && !parentName) {
throw new Error('Cannot resolve a relative module identifier ' + 'with no parent module:', name);
}
if (isRelative) {
var parentParsed = utils.moduleName.parse(parentName, packageName);
if (parentParsed.packageName === parsedModuleName.packageName && parentParsed.modulePath) {
var makePathRelative = true;
if (name === '../' || name === './' || name === '..') {
var relativePath = utils.path.relativeTo(parentParsed.modulePath, name);
var isInRoot = utils.path.isPackageRootDir(relativePath);
if (isInRoot) {
parsedModuleName.modulePath = utils.pkg.main(refPkg);
makePathRelative = false;
} else {
parsedModuleName.modulePath = name + (utils.path.endsWithSlash(name) ? '' : '/') + 'index';
}
}
if (makePathRelative) {
parsedModuleName.modulePath = utils.path.makeRelative(utils.path.joinURIs(parentParsed.modulePath, parsedModuleName.modulePath));
}
}
}
var mapName = utils.moduleName.create(parsedModuleName), mappedName;
if (refPkg.browser && typeof refPkg.browser !== 'string' && mapName in refPkg.browser && (!refPkg.system || !refPkg.system.ignoreBrowser)) {
mappedName = refPkg.browser[mapName] === false ? '@empty' : refPkg.browser[mapName];
}
var global = loader && loader.globalBrowser && loader.globalBrowser[mapName];
if (global) {
mappedName = global.moduleName === false ? '@empty' : global.moduleName;
}
if (mappedName) {
return utils.moduleName.parse(mappedName, packageName, !!global);
} else {
return parsedModuleName;
}
},
nameAndVersion: function (parsedModuleName) {
return parsedModuleName.packageName + '@' + parsedModuleName.version;
}
},
pkg: {
name: function (pkg) {
return pkg.system && pkg.system.name || pkg.name;
},
main: function (pkg) {
var main;
if (pkg.system && pkg.system.main) {
main = pkg.system.main;
} else if (typeof pkg.browser === 'string') {
if (utils.path.endsWithSlash(pkg.browser)) {
main = pkg.browser + 'index';
} else {
main = pkg.browser;
}
} else if (typeof pkg.jam === 'object') {
main = pkg.jam.main;
} else if (pkg.main) {
main = pkg.main;
} else {
main = 'index';
}
return utils.path.removeJS(utils.path.removeDotSlash(main));
},
rootDir: function (pkg, isRoot) {
var root = isRoot ? utils.path.removePackage(pkg.fileUrl) : utils.path.pkgDir(pkg.fileUrl);
var lib = utils.pkg.directoriesLib(pkg);
if (lib) {
root = utils.path.joinURIs(utils.path.addEndingSlash(root), lib);
}
return root;
},
isRoot: function (loader, pkg) {
var root = utils.pkg.getDefault(loader);
return pkg.name === root.name && pkg.version === root.version;
},
getDefault: function (loader) {
return loader.npmPaths.__default;
},
findByModuleNameOrAddress: function (loader, moduleName, moduleAddress) {
if (loader.npm) {
if (moduleName) {
var parsed = utils.moduleName.parse(moduleName);
if (parsed.version && parsed.packageName) {
var name = parsed.packageName + '@' + parsed.version;
if (name in loader.npm) {
return loader.npm[name];
}
}
}
if (moduleAddress) {
var startingAddress = utils.relativeURI(loader.baseURL, moduleAddress);
var packageFolder = utils.pkg.folderAddress(startingAddress);
return packageFolder ? loader.npmPaths[packageFolder] : utils.pkg.getDefault(loader);
} else {
return utils.pkg.getDefault(loader);
}
}
},
folderAddress: function (address) {
var nodeModules = '/node_modules/', nodeModulesIndex = address.lastIndexOf(nodeModules), nextSlash = address.indexOf('/', nodeModulesIndex + nodeModules.length);
if (nodeModulesIndex >= 0) {
return nextSlash >= 0 ? address.substr(0, nextSlash) : address;
}
},
findDep: function (loader, refPkg, name) {
if (loader.npm && refPkg && !utils.path.startsWithDotSlash(name)) {
var nameAndVersion = name + '@' + refPkg.resolutions[name];
var pkg = loader.npm[nameAndVersion];
return pkg;
}
},
findDepWalking: function (loader, refPackage, name) {
if (loader.npm && refPackage && !utils.path.startsWithDotSlash(name)) {
var curPackage = utils.path.depPackageDir(refPackage.fileUrl, name);
while (curPackage) {
var pkg = loader.npmPaths[curPackage];
if (pkg) {
return pkg;
}
var parentAddress = utils.path.parentNodeModuleAddress(curPackage);
if (!parentAddress) {
return;
}
curPackage = parentAddress + '/' + name;
}
}
},
findByName: function (loader, name) {
if (loader.npm && !utils.path.startsWithDotSlash(name)) {
return loader.npm[name];
}
},
findByNameAndVersion: function (loader, name, version) {
if (loader.npm && !utils.path.startsWithDotSlash(name)) {
var nameAndVersion = name + '@' + version;
return loader.npm[nameAndVersion];
}
},
findByUrl: function (loader, url) {
if (loader.npm) {
url = utils.pkg.folderAddress(url);
return loader.npmPaths[url];
}
},
directoriesLib: function (pkg) {
var system = pkg.system;
var lib = system && system.directories && system.directories.lib;
var ignores = [
'.',
'/'
], ignore;
if (!lib)
return undefined;
while (!!(ignore = ignores.shift())) {
if (lib[0] === ignore) {
lib = lib.substr(1);
}
}
return lib;
},
hasDirectoriesLib: function (pkg) {
var system = pkg.system;
return system && system.directories && !!system.directories.lib;
},
findPackageInfo: function (context, pkg) {
var pkgInfo = context.pkgInfo;
if (pkgInfo) {
var out;
utils.forEach(pkgInfo, function (p) {
if (pkg.name === p.name && pkg.version === p.version) {
out = p;
}
});
return out;
}
},
saveResolution: function (context, refPkg, pkg) {
var npmPkg = utils.pkg.findPackageInfo(context, refPkg);
npmPkg.resolutions[pkg.name] = refPkg.resolutions[pkg.name] = pkg.version;
}
},
path: {
makeRelative: function (path) {
if (utils.path.isRelative(path) && path.substr(0, 1) !== '/') {
return path;
} else {
return './' + path;
}
},
removeJS: function (path) {
return path.replace(/\.js(!|$)/, function (whole, part) {
return part;
});
},
removePackage: function (path) {
return path.replace(/\/package\.json.*/, '');
},
addJS: function (path) {
if (/\.js(on)?$/.test(path)) {
return path;
} else {
return path + '.js';
}
},
isRelative: function (path) {
return path.substr(0, 1) === '.';
},
joinURIs: function (base, href) {
function removeDotSegments(input) {
var output = [];
input.replace(/^(\.\.?(\/|$))+/, '').replace(/\/(\.(\/|$))+/g, '/').replace(/\/\.\.$/, '/../').replace(/\/?[^\/]*/g, function (p) {
if (p === '/..') {
output.pop();
} else {
output.push(p);
}
});
return output.join('').replace(/^\//, input.charAt(0) === '/' ? '/' : '');
}
href = parseURI(href || '');
base = parseURI(base || '');
return !href || !base ? null : (href.protocol || base.protocol) + (href.protocol || href.authority ? href.authority : base.authority) + removeDotSegments(href.protocol || href.authority || href.pathname.charAt(0) === '/' ? href.pathname : href.pathname ? (base.authority && !base.pathname ? '/' : '') + base.pathname.slice(0, base.pathname.lastIndexOf('/') + 1) + href.pathname : base.pathname) + (href.protocol || href.authority || href.pathname ? href.search : href.search || base.search) + href.hash;
},
startsWithDotSlash: function (path) {
return path.substr(0, 2) === './';
},
removeDotSlash: function (path) {
return utils.path.startsWithDotSlash(path) ? path.substr(2) : path;
},
endsWithSlash: function (path) {
return path[path.length - 1] === '/';
},
addEndingSlash: function (path) {
return utils.path.endsWithSlash(path) ? path : path + '/';
},
depPackage: function (parentPackageAddress, childName) {
var packageFolderName = parentPackageAddress.replace(/\/package\.json.*/, '');
return (packageFolderName ? packageFolderName + '/' : '') + 'node_modules/' + childName + '/package.json';
},
peerPackage: function (parentPackageAddress, childName) {
var packageFolderName = parentPackageAddress.replace(/\/package\.json.*/, '');
return packageFolderName.substr(0, packageFolderName.lastIndexOf('/')) + '/' + childName + '/package.json';
},
depPackageDir: function (parentPackageAddress, childName) {
return utils.path.depPackage(parentPackageAddress, childName).replace(/\/package\.json.*/, '');
},
peerNodeModuleAddress: function (address) {
var nodeModules = '/node_modules/', nodeModulesIndex = address.lastIndexOf(nodeModules);
if (nodeModulesIndex >= 0) {
return address.substr(0, nodeModulesIndex + nodeModules.length - 1);
}
},
parentNodeModuleAddress: function (address) {
var nodeModules = '/node_modules/', nodeModulesIndex = address.lastIndexOf(nodeModules), prevModulesIndex = address.lastIndexOf(nodeModules, nodeModulesIndex - 1);
if (prevModulesIndex >= 0) {
return address.substr(0, prevModulesIndex + nodeModules.length - 1);
}
},
pkgDir: function (address) {
var nodeModules = '/node_modules/', nodeModulesIndex = address.lastIndexOf(nodeModules), nextSlash = address.indexOf('/', nodeModulesIndex + nodeModules.length);
if (address[nodeModulesIndex + nodeModules.length] === '@') {
nextSlash = address.indexOf('/', nextSlash + 1);
}
if (nodeModulesIndex >= 0) {
return nextSlash >= 0 ? address.substr(0, nextSlash) : address;
}
},
basename: function (address) {
var parts = address.split('/');
return parts[parts.length - 1];
},
relativeTo: function (modulePath, rel) {
var parts = modulePath.split('/');
var idx = 1;
while (rel[idx] === '.') {
parts.pop();
idx++;
}
return parts.join('/');
},
isPackageRootDir: function (pth) {
return pth.indexOf('/') === -1;
}
},
includeInBuild: true
};
function parseURI(url) {
var m = String(url).replace(/^\s+|\s+$/g, '').match(/^([^:\/?#]+:)?(\/\/(?:[^:@]*(?::[^:@]*)?@)?(([^:\/?#]*)(?::(\d*))?))?([^?#]*)(\?[^#]*)?(#[\s\S]*)?/);
return m ? {
href: m[0] || '',
protocol: m[1] || '',
authority: m[2] || '',
host: m[3] || '',
hostname: m[4] || '',
port: m[5] || '',
pathname: m[6] || '',
search: m[7] || '',
hash: m[8] || ''
} : null;
}
module.exports = utils;
}(function () {
return this;
}()));
});
/*npm-extension*/
define('npm-extension', function (require, exports, module) {
(function (global) {
'format cjs';
var utils = require('./npm-utils');
exports.includeInBuild = true;
var isNode = typeof process === 'object' && {}.toString.call(process) === '[object process]';
var isWorker = typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope;
var isBrowser = typeof window !== 'undefined' && !isNode && !isWorker;
exports.addExtension = function (System) {
if (System._extensions) {
System._extensions.push(exports.addExtension);
}
var oldNormalize = System.normalize;
System.normalize = function (name, parentName, parentAddress, pluginNormalize) {
if (parentName && this.npmParentMap && this.npmParentMap[parentName]) {
parentName = this.npmParentMap[parentName];
}
var hasNoParent = !parentName;
var nameIsRelative = utils.path.isRelative(name);
var parentIsNpmModule = utils.moduleName.isNpm(parentName);
var identifierEndsWithSlash = utils.path.endsWithSlash(name);
if (parentName && nameIsRelative && !parentIsNpmModule) {
return oldNormalize.call(this, name, parentName, parentAddress, pluginNormalize);
}
if (utils.moduleName.isConditional(name)) {
return oldNormalize.call(this, name, parentName, parentAddress, pluginNormalize);
}
var hasContextualMap = typeof this.map[parentName] === 'object' && this.map[parentName][name];
if (hasContextualMap) {
return oldNormalize.call(this, name, parentName, parentAddress, pluginNormalize);
}
var refPkg = utils.pkg.findByModuleNameOrAddress(this, parentName, parentAddress);
if (!refPkg) {
return oldNormalize.call(this, name, parentName, parentAddress, pluginNormalize);
}
var parsedModuleName = utils.moduleName.parseFromPackage(this, refPkg, name, parentName);
var isRoot = utils.pkg.isRoot(this, refPkg);
var parsedPackageNameIsReferringPackage = parsedModuleName.packageName === refPkg.name;
var isRelativeToParentNpmModule = parentIsNpmModule && nameIsRelative && parsedPackageNameIsReferringPackage;
var depPkg, wantedPkg;
if (isRelativeToParentNpmModule) {
depPkg = refPkg;
}
var context = this.npmContext;
var crawl = context && context.crawl;
var isDev = !!crawl;
if (!depPkg) {
if (crawl && !isRoot) {
var parentPkg = nameIsRelative ? null : crawl.matchedVersion(context, refPkg.name, refPkg.version);
if (parentPkg) {
wantedPkg = crawl.getDependencyMap(this, parentPkg, isRoot)[parsedModuleName.packageName];
if (wantedPkg) {
var foundPkg = crawl.matchedVersion(this.npmContext, wantedPkg.name, wantedPkg.version);
if (foundPkg) {
depPkg = utils.pkg.findByUrl(this, foundPkg.fileUrl);
}
}
}
} else {
if (isRoot) {
depPkg = utils.pkg.findDepWalking(this, refPkg, parsedModuleName.packageName);
} else {
depPkg = utils.pkg.findDep(this, refPkg, parsedModuleName.packageName);
}
}
}
if (parsedPackageNameIsReferringPackage) {
depPkg = utils.pkg.findByNameAndVersion(this, parsedModuleName.packageName, refPkg.version);
}
var lookupByName = parsedModuleName.isGlobal || hasNoParent;
if (!depPkg) {
depPkg = utils.pkg.findByName(this, parsedModuleName.packageName);
}
var isThePackageWeWant = !isDev || !depPkg || (wantedPkg ? crawl.pkgSatisfies(depPkg, wantedPkg.version) : true);
if (!isThePackageWeWant) {
depPkg = undefined;
} else if (isDev && depPkg) {
utils.pkg.saveResolution(context, refPkg, depPkg);
}
if (!depPkg) {
var browserPackageName = this.globalBrowser[parsedModuleName.packageName];
if (browserPackageName) {
parsedModuleName.packageName = browserPackageName.moduleName;
depPkg = utils.pkg.findByName(this, parsedModuleName.packageName);
}
}
if (!depPkg && isRoot && name === refPkg.main && utils.pkg.hasDirectoriesLib(refPkg)) {
parsedModuleName.version = refPkg.version;
parsedModuleName.packageName = refPkg.name;
parsedModuleName.modulePath = utils.pkg.main(refPkg);
return oldNormalize.call(this, utils.moduleName.create(parsedModuleName), parentName, parentAddress, pluginNormalize);
}
var loader = this;
if (!depPkg) {
if (crawl) {
var parentPkg = crawl.matchedVersion(this.npmContext, refPkg.name, refPkg.version);
if (parentPkg) {
depPkg = crawl.getDependencyMap(this, parentPkg, isRoot)[parsedModuleName.packageName];
}
}
if (!depPkg) {
if (refPkg.browser && refPkg.browser[name]) {
return oldNormalize.call(this, refPkg.browser[name], parentName, parentAddress, pluginNormalize);
}
return oldNormalize.call(this, name, parentName, parentAddress, pluginNormalize);
}
return crawl.dep(this.npmContext, parentPkg, depPkg, isRoot).then(createModuleNameAndNormalize);
} else {
return createModuleNameAndNormalize(depPkg);
}
function createModuleNameAndNormalize(depPkg) {
parsedModuleName.version = depPkg.version;
if (!parsedModuleName.modulePath) {
parsedModuleName.modulePath = utils.pkg.main(depPkg);
}
var moduleName = utils.moduleName.create(parsedModuleName);
if (refPkg.system && refPkg.system.map && typeof refPkg.system.map[moduleName] === 'string') {
moduleName = refPkg.system.map[moduleName];
}
var p = oldNormalize.call(loader, moduleName, parentName, parentAddress, pluginNormalize);
if (identifierEndsWithSlash) {
p.then(function (name) {
if (context && context.forwardSlashMap) {
context.forwardSlashMap[name] = true;
}
});
}
return p;
}
};
var oldLocate = System.locate;
System.locate = function (load) {
var parsedModuleName = utils.moduleName.parse(load.name), loader = this;
if (parsedModuleName.version && this.npm && !loader.paths[load.name]) {
var pkg = this.npm[utils.moduleName.nameAndVersion(parsedModuleName)];
if (pkg) {
return oldLocate.call(this, load).then(function (address) {
var expectedAddress = utils.path.joinURIs(System.baseURL, load.name);
if (isBrowser) {
expectedAddress = expectedAddress.replace(/#/g, '%23');
}
if (address !== expectedAddress + '.js' && address !== expectedAddress) {
return address;
}
var root = utils.pkg.rootDir(pkg, utils.pkg.isRoot(loader, pkg));
if (parsedModuleName.modulePath) {
var npmAddress = utils.path.joinURIs(utils.path.addEndingSlash(root), parsedModuleName.plugin ? parsedModuleName.modulePath : utils.path.addJS(parsedModuleName.modulePath));
address = typeof steal !== 'undefined' ? utils.path.joinURIs(loader.baseURL, npmAddress) : npmAddress;
}
return address;
});
}
}
return oldLocate.call(this, load);
};
var oldFetch = System.fetch;
System.fetch = function (load) {
if (load.metadata.dryRun) {
return oldFetch.apply(this, arguments);
}
var loader = this;
var context = loader.npmContext;
var fetchPromise = Promise.resolve(oldFetch.apply(this, arguments));
if (utils.moduleName.isNpm(load.name)) {
fetchPromise = fetchPromise.then(null, function (err) {
var types = [].slice.call(retryTypes);
return retryAll(types, err);
function retryAll(types, err) {
if (!types.length) {
throw err;
}
var type = types.shift();
if (!type.test(load)) {
throw err;
}
return Promise.resolve(retryFetch.call(loader, load, type)).then(null, function (err) {
return retryAll(types, err);
});
}
});
}
return fetchPromise;
};
var convertName = function (loader, name) {
var pkg = utils.pkg.findByName(loader, name.split('/')[0]);
if (pkg) {
var parsed = utils.moduleName.parse(name, pkg.name);
parsed.version = pkg.version;
if (!parsed.modulePath) {
parsed.modulePath = utils.pkg.main(pkg);
}
return utils.moduleName.create(parsed);
}
return name;
};
var configSpecial = {
map: function (map) {
var newMap = {}, val;
for (var name in map) {
val = map[name];
newMap[convertName(this, name)] = typeof val === 'object' ? configSpecial.map(val) : convertName(this, val);
}
return newMap;
},
meta: function (map) {
var newMap = {};
for (var name in map) {
newMap[convertName(this, name)] = map[name];
}
return newMap;
},
paths: function (paths) {
var newPaths = {};
for (var name in paths) {
newPaths[convertName(this, name)] = paths[name];
}
return newPaths;
}
};
var oldConfig = System.config;
System.config = function (cfg) {
var loader = this;
for (var name in cfg) {
if (configSpecial[name]) {
cfg[name] = configSpecial[name].call(loader, cfg[name]);
}
}
oldConfig.apply(loader, arguments);
};
function retryFetch(load, type) {
var loader = this;
var moduleName = typeof type.name === 'function' ? type.name(loader, load) : load.name + type.name;
var local = utils.extend({}, load);
local.name = moduleName;
local.metadata = { dryRun: true };
return Promise.resolve(loader.locate(local)).then(function (address) {
local.address = address;
return loader.fetch(local);
}).then(function (source) {
load.address = local.address;
loader.npmParentMap[load.name] = local.name;
var npmLoad = loader.npmContext && loader.npmContext.npmLoad;
if (npmLoad) {
npmLoad.saveLoadIfNeeded(loader.npmContext);
if (!isNode) {
utils.warnOnce('Some 404s were encountered ' + 'while loading. Don\'t panic! ' + 'These will only happen in dev ' + 'and are harmless.');
}
}
return source;
});
}
var retryTypes = [
{
name: function (loader, load) {
var context = loader.npmContext;
if (context.forwardSlashMap[load.name]) {
var parts = load.name.split('/');
parts.pop();
return parts.concat(['index']).join('/');
}
return load.name + '/index';
},
test: function () {
return true;
}
},
{
name: '.json',
test: function (load) {
return utils.moduleName.isNpm(load.name) && utils.path.basename(load.address) === 'package.js';
}
}
];
};
}(function () {
return this;
}()));
});
/*npm-load*/
define('npm-load', [], function(){ return {}; });
/*semver*/
define('semver', [], function(){ return {}; });
/*npm-crawl*/
define('npm-crawl', [], function(){ return {}; });
/*npm-convert*/
define('npm-convert', [], function(){ return {}; });
/*npm*/
define('npm', [], function(){ return {}; });
/*package.json!npm*/
define('package.json!npm', [
'@loader',
'npm-extension',
'module'
], function (loader, npmExtension, module) {
npmExtension.addExtension(loader);
if (!loader.main) {
loader.main = 'static';
}
loader._npmExtensions = [].slice.call(arguments, 2);
(function (loader, packages, options) {
var g = loader.global;
if (!g.process) {
g.process = {
cwd: function () {
var baseURL = loader.baseURL;
return baseURL;
},
browser: true,
env: { NODE_ENV: loader.env },
version: '',
platform: navigator && navigator.userAgent && /Windows/.test(navigator.userAgent) ? 'win' : ''
};
}
if (!loader.npm) {
loader.npm = {};
loader.npmPaths = {};
loader.globalBrowser = {};
}
if (!loader.npmParentMap) {
loader.npmParentMap = options.npmParentMap || {};
}
var rootPkg = loader.npmPaths.__default = packages[0];
var lib = packages[0].system && packages[0].system.directories && packages[0].system.directories.lib;
var setGlobalBrowser = function (globals, pkg) {
for (var name in globals) {
loader.globalBrowser[name] = {
pkg: pkg,
moduleName: globals[name]
};
}
};
var setInNpm = function (name, pkg) {
if (!loader.npm[name]) {
loader.npm[name] = pkg;
}
loader.npm[name + '@' + pkg.version] = pkg;
};
var forEach = function (arr, fn) {
var i = 0, len = arr.length;
for (; i < len; i++) {
fn.call(arr, arr[i]);
}
};
var setupLiveReload = function () {
var hasLiveReload = !!(loader.liveReloadInstalled || loader._liveMap);
if (hasLiveReload) {
loader['import']('live-reload', { name: module.id }).then(function (reload) {
reload.dispose(function () {
delete loader.npm;
delete loader.npmPaths;
delete loader.npmParentMap;
delete loader.npmContext;
});
});
}
};
var ignoredConfig = [
'bundle',
'configDependencies',
'transpiler'
];
forEach(packages, function (pkg) {
if (pkg.system) {
var system = pkg.system;
var main = system.main;
delete system.main;
var configDeps = system.configDependencies;
if (pkg !== rootPkg) {
forEach(ignoredConfig, function (name) {
delete system[name];
});
}
loader.config(system);
if (pkg === rootPkg) {
system.configDependencies = configDeps;
}
system.main = main;
}
if (pkg.globalBrowser) {
setGlobalBrowser(pkg.globalBrowser, pkg);
}
var systemName = system && system.name;
if (systemName) {
setInNpm(systemName, pkg);
} else {
setInNpm(pkg.name, pkg);
}
if (!loader.npm[pkg.name]) {
loader.npm[pkg.name] = pkg;
}
loader.npm[pkg.name + '@' + pkg.version] = pkg;
var pkgAddress = pkg.fileUrl.replace(/\/package\.json.*/, '');
loader.npmPaths[pkgAddress] = pkg;
});
forEach(loader._npmExtensions || [], function (ext) {
if (ext.systemConfig) {
loader.config(ext.systemConfig);
}
});
setupLiveReload();
}(loader, [
{
'name': 'bit-docs-site',
'version': '0.0.1',
'fileUrl': './package.json',
'main': 'static.js',
'system': { 'npmAlgorithm': 'flat' },
'globalBrowser': {},
'browser': {},
'resolutions': {
'bit-docs-site': '0.0.1',
'bit-docs-html-canjs': '0.4.6',
'bit-docs-prettify': '0.1.1',
'bit-docs-html-highlight-line': '0.2.3',
'bit-docs-tag-demo': '0.3.0'
}
},
{
'name': 'bit-docs-html-canjs',
'version': '0.4.6',
'fileUrl': './node_modules/bit-docs-html-canjs/package.json',
'main': 'static/canjs',
'system': {},
'globalBrowser': {},
'browser': {},
'resolutions': { 'bit-docs-html-canjs': '0.4.6' }
},
{
'name': 'bit-docs-prettify',
'version': '0.1.1',
'fileUrl': './node_modules/bit-docs-prettify/package.json',
'main': 'prettify.js',
'system': { 'meta': { 'bit-docs-prettify@0.1.1#prettify-engine': { 'format': 'global' } } },
'globalBrowser': {},
'browser': {},
'resolutions': { 'bit-docs-prettify': '0.1.1' }
},
{
'name': 'bit-docs-tag-demo',
'version': '0.3.0',
'fileUrl': './node_modules/bit-docs-tag-demo/package.json',
'main': 'demo.js',
'globalBrowser': {},
'browser': {},
'resolutions': { 'bit-docs-tag-demo': '0.3.0' }
},
{
'name': 'bit-docs-html-highlight-line',
'version': '0.2.3',
'fileUrl': './node_modules/bit-docs-html-highlight-line/package.json',
'main': 'highlight-line.js',
'globalBrowser': {},
'browser': {},
'resolutions': {}
},
{
'name': 'jquery',
'version': '2.2.4',
'fileUrl': './node_modules/jquery/package.json',
'main': 'dist/jquery.js',
'globalBrowser': {},
'browser': {},
'resolutions': {}
}
], { 'npmParentMap': {} }));
});
/*$css*/
define('$css', function (require, exports, module) {
var loader = require('@loader');
if (isProduction()) {
exports.fetch = function (load) {
var cssFile = load.address;
var link = document.createElement('link');
link.rel = 'stylesheet';
link.href = cssFile;
document.head.appendChild(link);
return '';
};
} else {
exports.instantiate = function (load) {
var loader = this;
load.metadata.deps = [];
load.metadata.execute = function () {
var source = load.source + '/*# sourceURL=' + load.address + ' */';
source = source.replace(/url\(['"]?([^'"\)]*)['"]?\)/g, function (whole, part) {
return 'url(' + steal.joinURIs(load.address, part) + ')';
});
source = source.replace(/@import [^uU]['"]?([^'"\)]*)['"]?/g, function (whole, part) {
return '@import url(' + steal.joinURIs(load.address, part) + ')';
});
if (load.source && typeof document !== 'undefined') {
var doc = document.head ? document : document.getElementsByTagName ? document : document.documentElement;
var head = doc.head || doc.getElementsByTagName('head')[0], style = document.createElement('style');
if (!head) {
var docEl = doc.documentElement || doc;
head = document.createElement('head');
docEl.insertBefore(head, docEl.firstChild);
}
style.type = 'text/css';
if (style.styleSheet) {
style.styleSheet.cssText = source;
} else {
style.appendChild(document.createTextNode(source));
}
head.appendChild(style);
if (loader.has('live-reload')) {
var cssReload = loader['import']('live-reload', { name: '$css' });
Promise.resolve(cssReload).then(function (reload) {
loader['import'](load.name).then(function () {
reload.once(load.name, function () {
head.removeChild(style);
});
});
});
}
}
return System.newModule({ source: source });
};
load.metadata.format = 'css';
};
}
function isProduction() {
return loader.isEnv && loader.isEnv('production') || loader.env === 'production';
}
exports.locateScheme = true;
exports.buildType = 'css';
exports.includeInBuild = true;
});
/*@less-engine*/
define('@less-engine', [], function(){ return {}; });
/*$less*/
define('$less', [], function(){ return {}; });
/*jquery@2.2.4#dist/jquery*/
(function (global, factory) {
if (typeof module === 'object' && typeof module.exports === 'object') {
module.exports = global.document ? factory(global, true) : function (w) {
if (!w.document) {
throw new Error('jQuery requires a window with a document');
}
return factory(w);
};
} else {
factory(global);
}
}(typeof window !== 'undefined' ? window : this, function (window, noGlobal) {
var arr = [];
var document = window.document;
var slice = arr.slice;
var concat = arr.concat;
var push = arr.push;
var indexOf = arr.indexOf;
var class2type = {};
var toString = class2type.toString;
var hasOwn = class2type.hasOwnProperty;
var support = {};
var version = '2.2.4', jQuery = function (selector, context) {
return new jQuery.fn.init(selector, context);
}, rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, rmsPrefix = /^-ms-/, rdashAlpha = /-([\da-z])/gi, fcamelCase = function (all, letter) {
return letter.toUpperCase();
};
jQuery.fn = jQuery.prototype = {
jquery: version,
constructor: jQuery,
selector: '',
length: 0,
toArray: function () {
return slice.call(this);
},
get: function (num) {
return num != null ? num < 0 ? this[num + this.length] : this[num] : slice.call(this);
},
pushStack: function (elems) {
var ret = jQuery.merge(this.constructor(), elems);
ret.prevObject = this;
ret.context = this.context;
return ret;
},
each: function (callback) {
return jQuery.each(this, callback);
},
map: function (callback) {
return this.pushStack(jQuery.map(this, function (elem, i) {
return callback.call(elem, i, elem);
}));
},
slice: function () {
return this.pushStack(slice.apply(this, arguments));
},
first: function () {
return this.eq(0);
},
last: function () {
return this.eq(-1);
},
eq: function (i) {
var len = this.length, j = +i + (i < 0 ? len : 0);
return this.pushStack(j >= 0 && j < len ? [this[j]] : []);
},
end: function () {
return this.prevObject || this.constructor();
},
push: push,
sort: arr.sort,
splice: arr.splice
};
jQuery.extend = jQuery.fn.extend = function () {
var options, name, src, copy, copyIsArray, clone, target = arguments[0] || {}, i = 1, length = arguments.length, deep = false;
if (typeof target === 'boolean') {
deep = target;
target = arguments[i] || {};
i++;
}
if (typeof target !== 'object' && !jQuery.isFunction(target)) {
target = {};
}
if (i === length) {
target = this;
i--;
}
for (; i < length; i++) {
if ((options = arguments[i]) != null) {
for (name in options) {