fuse-box
Version:
Fuse-Box a bundler that does it right
433 lines (409 loc) • 12.5 kB
JavaScript
/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.
See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
/* global global, define, System, Reflect, Promise */
var __extends;
var __assign;
var __rest;
var __decorate;
var __param;
var __metadata;
var __awaiter;
var __generator;
var __exportStar;
var __values;
var __read;
var __spread;
var __spreadArrays;
var __await;
var __asyncGenerator;
var __asyncDelegator;
var __asyncValues;
var __makeTemplateObject;
var __importStar;
var __importDefault;
(function(factory) {
var root =
typeof global === 'object' ? global : typeof self === 'object' ? self : typeof this === 'object' ? this : {};
if (typeof define === 'function' && define.amd) {
define('tslib', ['exports'], function(exports) {
factory(createExporter(root, createExporter(exports)));
});
} else if (typeof module === 'object' && typeof module.exports === 'object') {
factory(createExporter(root, createExporter(module.exports)));
} else {
factory(createExporter(root));
}
function createExporter(exports, previous) {
if (exports !== root) {
if (typeof Object.create === 'function') {
Object.defineProperty(exports, '__esModule', { value: true });
} else {
exports.__esModule = true;
}
}
return function(id, v) {
return (exports[id] = previous ? previous(id, v) : v);
};
}
})(function(exporter) {
var extendStatics =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function(d, b) {
d.__proto__ = b;
}) ||
function(d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
};
__extends = function(d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype = b === null ? Object.create(b) : ((__.prototype = b.prototype), new __());
};
__assign =
Object.assign ||
function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
}
return t;
};
__rest = function(s, e) {
var t = {};
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === 'function')
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
}
return t;
};
__decorate = function(decorators, target, key, desc) {
var c = arguments.length,
r = c < 3 ? target : desc === null ? (desc = Object.getOwnPropertyDescriptor(target, key)) : desc,
d;
if (typeof Reflect === 'object' && typeof Reflect.decorate === 'function')
r = Reflect.decorate(decorators, target, key, desc);
else
for (var i = decorators.length - 1; i >= 0; i--)
if ((d = decorators[i])) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
__param = function(paramIndex, decorator) {
return function(target, key) {
decorator(target, key, paramIndex);
};
};
__metadata = function(metadataKey, metadataValue) {
if (typeof Reflect === 'object' && typeof Reflect.metadata === 'function')
return Reflect.metadata(metadataKey, metadataValue);
};
__awaiter = function(thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function(resolve, reject) {
function fulfilled(value) {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
}
function rejected(value) {
try {
step(generator['throw'](value));
} catch (e) {
reject(e);
}
}
function step(result) {
result.done
? resolve(result.value)
: new P(function(resolve) {
resolve(result.value);
}).then(fulfilled, rejected);
}
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
__generator = function(thisArg, body) {
var _ = {
label: 0,
ops: [],
sent: function() {
if (1 & t[0]) throw t[1];
return t[1];
},
trys: [],
},
f,
y,
t,
g;
return (
(g = { next: verb(0), return: verb(2), throw: verb(1) }),
typeof Symbol === 'function' &&
(g[Symbol.iterator] = function() {
return this;
}),
g
);
function verb(n) {
return function(v) {
return step([n, v]);
};
}
function step(op) {
if (f) throw new TypeError('Generator is already executing.');
while (_)
try {
if (
((f = 1),
y &&
(t = 2 & op[0] ? y['return'] : op[0] ? y['throw'] || ((t = y['return']) && t.call(y), 0) : y.next) &&
!(t = t.call(y, op[1])).done)
)
return t;
if (((y = 0), t)) op = [2 & op[0], t.value];
switch (op[0]) {
case 0:
case 1:
t = op;
break;
case 4:
_.label++;
return { done: false, value: op[1] };
case 5:
_.label++;
y = op[1];
op = [0];
continue;
case 7:
op = _.ops.pop();
_.trys.pop();
continue;
default:
if (!((t = _.trys), (t = t.length > 0 && t[t.length - 1])) && (op[0] === 6 || op[0] === 2)) {
_ = 0;
continue;
}
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
_.label = op[1];
break;
}
if (op[0] === 6 && _.label < t[1]) {
_.label = t[1];
t = op;
break;
}
if (t && _.label < t[2]) {
_.label = t[2];
_.ops.push(op);
break;
}
if (t[2]) _.ops.pop();
_.trys.pop();
continue;
}
op = body.call(thisArg, _);
} catch (e) {
op = [6, e];
y = 0;
} finally {
f = t = 0;
}
if (5 & op[0]) throw op[1];
return { done: true, value: op[0] ? op[1] : void 0 };
}
};
__exportStar = function(m, exports) {
for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
};
__values = function(o) {
var m = typeof Symbol === 'function' && o[Symbol.iterator],
i = 0;
if (m) return m.call(o);
return {
next: function() {
if (o && i >= o.length) o = void 0;
return { done: !o, value: o && o[i++] };
},
};
};
__read = function(o, n) {
var m = typeof Symbol === 'function' && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o),
r,
ar = [],
e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
} catch (error) {
e = { error: error };
} finally {
try {
if (r && !r.done && (m = i['return'])) m.call(i);
} finally {
if (e) throw e.error;
}
}
return ar;
};
__spread = function() {
for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
return ar;
};
__spreadArrays = function() {
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) r[k] = a[j];
return r;
};
__await = function(v) {
return this instanceof __await ? ((this.v = v), this) : new __await(v);
};
__asyncGenerator = function(thisArg, _arguments, generator) {
if (!Symbol.asyncIterator) throw new TypeError('Symbol.asyncIterator is not defined.');
var g = generator.apply(thisArg, _arguments || []),
i,
q = [];
return (
(i = {}),
verb('next'),
verb('throw'),
verb('return'),
(i[Symbol.asyncIterator] = function() {
return this;
}),
i
);
function verb(n) {
if (g[n])
i[n] = function(v) {
return new Promise(function(a, b) {
q.push([n, v, a, b]) > 1 || resume(n, v);
});
};
}
function resume(n, v) {
try {
step(g[n](v));
} catch (e) {
settle(q[0][3], e);
}
}
function step(r) {
r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
}
function fulfill(value) {
resume('next', value);
}
function reject(value) {
resume('throw', value);
}
function settle(f, v) {
if ((f(v), q.shift(), q.length)) resume(q[0][0], q[0][1]);
}
};
__asyncDelegator = function(o) {
var i, p;
return (
(i = {}),
verb('next'),
verb('throw', function(e) {
throw e;
}),
verb('return'),
(i[Symbol.iterator] = function() {
return this;
}),
i
);
function verb(n, f) {
i[n] = o[n]
? function(v) {
return (p = !p) ? { done: n === 'return', value: __await(o[n](v)) } : f ? f(v) : v;
}
: f;
}
};
__asyncValues = function(o) {
if (!Symbol.asyncIterator) throw new TypeError('Symbol.asyncIterator is not defined.');
var m = o[Symbol.asyncIterator],
i;
return m
? m.call(o)
: ((o = typeof __values === 'function' ? __values(o) : o[Symbol.iterator]()),
(i = {}),
verb('next'),
verb('throw'),
verb('return'),
(i[Symbol.asyncIterator] = function() {
return this;
}),
i);
function verb(n) {
i[n] =
o[n] &&
function(v) {
return new Promise(function(resolve, reject) {
(v = o[n](v)), settle(resolve, reject, v.done, v.value);
});
};
}
function settle(resolve, reject, d, v) {
Promise.resolve(v).then(function(v) {
resolve({ done: d, value: v });
}, reject);
}
};
__makeTemplateObject = function(cooked, raw) {
if (Object.defineProperty) {
Object.defineProperty(cooked, 'raw', { value: raw });
} else {
cooked.raw = raw;
}
return cooked;
};
__importStar = function(mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
result['default'] = mod;
return result;
};
__importDefault = function(mod) {
return mod && mod.__esModule ? mod : { default: mod };
};
exporter('__extends', __extends);
exporter('__assign', __assign);
exporter('__rest', __rest);
exporter('__decorate', __decorate);
exporter('__param', __param);
exporter('__metadata', __metadata);
exporter('__awaiter', __awaiter);
exporter('__generator', __generator);
exporter('__exportStar', __exportStar);
exporter('__values', __values);
exporter('__read', __read);
exporter('__spread', __spread);
exporter('__spreadArrays', __spreadArrays);
exporter('__await', __await);
exporter('__asyncGenerator', __asyncGenerator);
exporter('__asyncDelegator', __asyncDelegator);
exporter('__asyncValues', __asyncValues);
exporter('__makeTemplateObject', __makeTemplateObject);
exporter('__importStar', __importStar);
exporter('__importDefault', __importDefault);
});