2855 lines
88 KiB
JavaScript
2855 lines
88 KiB
JavaScript
(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var _get = require('babel-runtime/helpers/get')['default'];
|
|
|
|
var _inherits = require('babel-runtime/helpers/inherits')['default'];
|
|
|
|
var _createClass = require('babel-runtime/helpers/create-class')['default'];
|
|
|
|
var _classCallCheck = require('babel-runtime/helpers/class-call-check')['default'];
|
|
|
|
var _Object$assign = require('babel-runtime/core-js/object/assign')['default'];
|
|
|
|
var _Map = require('babel-runtime/core-js/map')['default'];
|
|
|
|
var EventEmitter = require('events').EventEmitter;
|
|
var Canvas = require('./view/canvas');
|
|
var LoadIndicator = require('./view/load-indicator');
|
|
var ProgressBar = require('./view/progress-bar');
|
|
|
|
var ComicBook = (function (_EventEmitter) {
|
|
_inherits(ComicBook, _EventEmitter);
|
|
|
|
function ComicBook(srcs, options) {
|
|
if (srcs === undefined) srcs = [];
|
|
|
|
_classCallCheck(this, ComicBook);
|
|
|
|
_get(Object.getPrototypeOf(ComicBook.prototype), 'constructor', this).call(this);
|
|
|
|
this.options = _Object$assign({
|
|
// manga mode
|
|
rtl: false,
|
|
doublePage: false
|
|
}, options);
|
|
|
|
// requested image srcs
|
|
this.srcs = srcs;
|
|
|
|
// loaded image objects
|
|
this.pages = new _Map();
|
|
|
|
this.preloadBuffer = 4;
|
|
|
|
// TODO move this logic into the router
|
|
this.currentPageIndex = 0;
|
|
|
|
this.canvas = new Canvas();
|
|
this.loadIndicator = new LoadIndicator();
|
|
this.progressBar = new ProgressBar();
|
|
|
|
this.addEventListeners();
|
|
}
|
|
|
|
_createClass(ComicBook, [{
|
|
key: 'addEventListeners',
|
|
value: function addEventListeners() {
|
|
this.on('preload:start', this.loadIndicator.show.bind(this.loadIndicator));
|
|
this.on('preload:start', this.progressBar.show.bind(this.progressBar));
|
|
this.on('preload:image', this.updateProgressBar.bind(this));
|
|
this.on('preload:ready', this.loadIndicator.hide.bind(this.loadIndicator));
|
|
this.on('preload:ready', this.drawPage.bind(this));
|
|
this.on('preload:finish', this.progressBar.hide.bind(this.progressBar));
|
|
}
|
|
}, {
|
|
key: 'render',
|
|
value: function render() {
|
|
this.pageRendered = false;
|
|
this.el = document.createElement('div');
|
|
this.el.appendChild(this.canvas.canvas);
|
|
this.el.appendChild(this.progressBar.el);
|
|
this.el.appendChild(this.loadIndicator.el);
|
|
this.drawPage();
|
|
return this;
|
|
}
|
|
}, {
|
|
key: 'preload',
|
|
|
|
// TODO use a queue, only allow x concurrent downloads at a time
|
|
// TODO preload in both directions
|
|
// TODO fire ready on forward direction only
|
|
value: function preload(startIndex) {
|
|
var _this = this;
|
|
|
|
this.emit('preload:start');
|
|
|
|
if (startIndex == null || startIndex >= this.srcs.length) {
|
|
startIndex = this.currentPageIndex;
|
|
}
|
|
|
|
// reorder srcs to start from the requested index
|
|
var _srcs = this.srcs.slice();
|
|
var srcs = _srcs.splice(startIndex).concat(_srcs);
|
|
|
|
this.currentPageIndex = startIndex;
|
|
|
|
srcs.forEach(function (src, pageIndex) {
|
|
|
|
// allow preload to be run multiple times without duplicating requests
|
|
if (_this.pages.has(pageIndex)) return;
|
|
|
|
var image = new window.Image();
|
|
|
|
image.src = src;
|
|
image.onload = setImage.bind(_this, image, pageIndex);
|
|
|
|
function setImage(image, index) {
|
|
this.pages.set(index, image);
|
|
this.emit('preload:image', image);
|
|
|
|
if (this.pages.size >= this.preloadBuffer && !this.pageRendered) {
|
|
this.emit('preload:ready');
|
|
}
|
|
|
|
if (this.pages.size === this.srcs.length) {
|
|
this.emit('preload:finish');
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: 'updateProgressBar',
|
|
value: function updateProgressBar() {
|
|
var percentage = Math.floor(this.pages.size / this.srcs.length * 100);
|
|
this.progressBar.update(percentage);
|
|
}
|
|
}, {
|
|
key: 'drawPage',
|
|
value: function drawPage(pageIndex) {
|
|
if (typeof pageIndex !== 'number') pageIndex = this.currentPageIndex;
|
|
|
|
var page = this.pages.get(pageIndex);
|
|
|
|
// if the requested image hasn't been loaded yet, force another preload run
|
|
if (!page) return this.preload(pageIndex);
|
|
|
|
var args = [page];
|
|
|
|
if (this.options.doublePage) {
|
|
var page2Index = pageIndex + 1;
|
|
var page2 = this.pages.get(page2Index);
|
|
|
|
if (page2Index <= this.pages.size - 1 && !page2) {
|
|
return this.preload(page2Index);
|
|
}
|
|
|
|
args.push(page2);
|
|
|
|
if (this.options.rtl) {
|
|
args.reverse();
|
|
}
|
|
}
|
|
|
|
args.push(this.options);
|
|
|
|
try {
|
|
this.canvas.drawImage.apply(this.canvas, args);
|
|
this.currentPageIndex = pageIndex;
|
|
this.pageRendered = true;
|
|
} catch (e) {
|
|
if (e.message !== 'Invalid image') throw e;
|
|
}
|
|
}
|
|
}, {
|
|
key: 'drawNextPage',
|
|
value: function drawNextPage() {
|
|
var increment = this.options.doublePage ? 2 : 1;
|
|
var index = this.currentPageIndex + increment;
|
|
if (index >= this.pages.size) {
|
|
index = this.pages.size - 1;
|
|
}
|
|
this.drawPage(index);
|
|
}
|
|
}, {
|
|
key: 'drawPreviousPage',
|
|
value: function drawPreviousPage() {
|
|
var increment = this.options.doublePage ? 2 : 1;
|
|
var index = this.currentPageIndex - increment;
|
|
if (index < 0) index = 0;
|
|
this.drawPage(index);
|
|
}
|
|
}]);
|
|
|
|
return ComicBook;
|
|
})(EventEmitter);
|
|
|
|
module.exports = ComicBook;
|
|
|
|
},{"./view/canvas":3,"./view/load-indicator":4,"./view/progress-bar":5,"babel-runtime/core-js/map":7,"babel-runtime/core-js/object/assign":8,"babel-runtime/helpers/class-call-check":12,"babel-runtime/helpers/create-class":13,"babel-runtime/helpers/get":14,"babel-runtime/helpers/inherits":15,"events":53}],2:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var ComicBook = window.ComicBook = require('./comic-book');
|
|
var debounce = require('lodash.debounce');
|
|
var srcs = ['https://raw.githubusercontent.com/balaclark/HTML5-Comic-Book-Reader/master/examples/goldenboy/goldenboy_00.jpg', 'https://raw.githubusercontent.com/balaclark/HTML5-Comic-Book-Reader/master/examples/goldenboy/goldenboy_01.jpg', 'https://raw.githubusercontent.com/balaclark/HTML5-Comic-Book-Reader/master/examples/goldenboy/goldenboy_02.jpg', 'https://raw.githubusercontent.com/balaclark/HTML5-Comic-Book-Reader/master/examples/goldenboy/goldenboy_03.jpg', 'https://raw.githubusercontent.com/balaclark/HTML5-Comic-Book-Reader/master/examples/goldenboy/goldenboy_04.jpg', 'https://raw.githubusercontent.com/balaclark/HTML5-Comic-Book-Reader/master/examples/goldenboy/goldenboy_05.jpg', 'https://raw.githubusercontent.com/balaclark/HTML5-Comic-Book-Reader/master/examples/goldenboy/goldenboy_06.jpg', 'https://raw.githubusercontent.com/balaclark/HTML5-Comic-Book-Reader/master/examples/goldenboy/goldenboy_07.jpg', 'https://raw.githubusercontent.com/balaclark/HTML5-Comic-Book-Reader/master/examples/goldenboy/goldenboy_08.jpg', 'https://raw.githubusercontent.com/balaclark/HTML5-Comic-Book-Reader/master/examples/goldenboy/goldenboy_09.jpg', 'https://raw.githubusercontent.com/balaclark/HTML5-Comic-Book-Reader/master/examples/goldenboy/goldenboy_10.jpg'];
|
|
var comic = window.comic = new ComicBook(srcs, { doublePage: true });
|
|
|
|
comic.render().drawPage(5);
|
|
|
|
window.addEventListener('resize', debounce(comic.drawPage.bind(comic), 100));
|
|
|
|
document.addEventListener('DOMContentLoaded', function () {
|
|
document.body.appendChild(comic.el);
|
|
}, false);
|
|
|
|
},{"./comic-book":1,"lodash.debounce":63}],3:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var _get = require('babel-runtime/helpers/get')['default'];
|
|
|
|
var _inherits = require('babel-runtime/helpers/inherits')['default'];
|
|
|
|
var _createClass = require('babel-runtime/helpers/create-class')['default'];
|
|
|
|
var _classCallCheck = require('babel-runtime/helpers/class-call-check')['default'];
|
|
|
|
var _Object$assign = require('babel-runtime/core-js/object/assign')['default'];
|
|
|
|
var EventEmitter = require('events').EventEmitter;
|
|
|
|
// TODO replace
|
|
function windowWidth() {
|
|
return window.innerWidth;
|
|
}
|
|
|
|
var Canvas = (function (_EventEmitter) {
|
|
_inherits(Canvas, _EventEmitter);
|
|
|
|
function Canvas(options) {
|
|
_classCallCheck(this, Canvas);
|
|
|
|
_get(Object.getPrototypeOf(Canvas.prototype), 'constructor', this).call(this);
|
|
this.canvas = document.createElement('canvas');
|
|
this.context = this.canvas.getContext('2d');
|
|
}
|
|
|
|
_createClass(Canvas, [{
|
|
key: 'drawImage',
|
|
value: function drawImage(page, page2) {
|
|
var opts = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
|
|
|
|
this.emit('draw:start');
|
|
|
|
if (page2 === null || !(page2 instanceof window.Image)) {
|
|
opts = page2 || opts;
|
|
}
|
|
|
|
var options = _Object$assign({
|
|
doublePage: false,
|
|
zoomMode: 'fitWidth'
|
|
}, opts);
|
|
|
|
if (!(page instanceof window.Image) || options.doublePage && page2 === null) {
|
|
throw new Error('Invalid image');
|
|
}
|
|
|
|
var zoomScale = undefined;
|
|
var offsetW = 0;
|
|
var offsetH = 0;
|
|
var width = page.width;
|
|
var height = page.height;
|
|
var doublePageMode = options.doublePage;
|
|
var canvasWidth = undefined;
|
|
var canvasHeight = undefined;
|
|
var pageWidth = undefined;
|
|
var pageHeight = undefined;
|
|
|
|
// reset the canvas to stop duplicate pages showing
|
|
this.canvas.width = 0;
|
|
this.canvas.height = 0;
|
|
|
|
// show double page spreads on a single page
|
|
var isDoublePageSpread = page2 && (page.width > page.height || page2.width > page2.height) && doublePageMode;
|
|
|
|
if (isDoublePageSpread) doublePageMode = false;
|
|
|
|
if (doublePageMode) {
|
|
|
|
// for double page spreads, factor in the width of both pages
|
|
if (page2 instanceof window.Image) {
|
|
width += page2.width
|
|
// if this is the last page and there is no page2, still keep the canvas wide
|
|
;
|
|
} else {
|
|
width += width;
|
|
}
|
|
}
|
|
|
|
// update the page this.scale if a non manual mode has been chosen
|
|
switch (options.zoomMode) {
|
|
|
|
case 'manual':
|
|
document.body.style.overflowX = 'auto';
|
|
zoomScale = doublePageMode ? this.scale * 2 : this.scale;
|
|
break;
|
|
|
|
case 'fitWidth':
|
|
document.body.style.overflowX = 'hidden';
|
|
|
|
// this.scale up if the window is wider than the page, scale down if the window
|
|
// is narrower than the page
|
|
zoomScale = windowWidth() > width ? (windowWidth() - width) / windowWidth() + 1 : windowWidth() / width;
|
|
this.scale = zoomScale;
|
|
break;
|
|
|
|
case 'fitWindow':
|
|
document.body.style.overflowX = 'hidden';
|
|
|
|
var widthScale = windowWidth() > width ? (windowWidth() - width) / windowWidth() + 1 // scale up if the window is wider than the page
|
|
: windowWidth() / width; // scale down if the window is narrower than the page
|
|
var windowHeight = window.innerHeight;
|
|
var heightScale = windowHeight > height ? (windowHeight - height) / windowHeight + 1 // scale up if the window is wider than the page
|
|
: windowHeight / height; // scale down if the window is narrower than the page
|
|
|
|
zoomScale = widthScale > heightScale ? heightScale : widthScale;
|
|
this.scale = zoomScale;
|
|
break;
|
|
}
|
|
|
|
canvasWidth = page.width * zoomScale;
|
|
canvasHeight = page.height * zoomScale;
|
|
|
|
pageWidth = options.zoomMode === 'manual' ? page.width * this.scale : canvasWidth;
|
|
pageHeight = options.zoomMode === 'manual' ? page.height * this.scale : canvasHeight;
|
|
|
|
canvasHeight = pageHeight;
|
|
|
|
// make sure the canvas is always at least full screen, even if the page is narrower than the screen
|
|
this.canvas.width = canvasWidth < windowWidth() ? windowWidth() : canvasWidth;
|
|
this.canvas.height = canvasHeight < window.innerHeight ? window.innerHeight : canvasHeight;
|
|
|
|
// always keep pages centered
|
|
if (options.zoomMode === 'manual' || options.zoomMode === 'fitWindow') {
|
|
|
|
// work out a horizontal position
|
|
if (canvasWidth < windowWidth()) {
|
|
offsetW = (windowWidth() - pageWidth) / 2;
|
|
if (options.doublePage) {
|
|
offsetW = offsetW - pageWidth / 2;
|
|
}
|
|
}
|
|
|
|
// work out a vertical position
|
|
if (canvasHeight < window.innerHeight) {
|
|
offsetH = (window.innerHeight - pageHeight) / 2;
|
|
}
|
|
}
|
|
|
|
// draw the page(s)
|
|
this.context.drawImage(page, offsetW, offsetH, pageWidth, pageHeight);
|
|
if (options.doublePage && typeof page2 === 'object') {
|
|
this.context.drawImage(page2, pageWidth + offsetW, offsetH, pageWidth, pageHeight);
|
|
}
|
|
|
|
this.emit('draw:finish');
|
|
}
|
|
}]);
|
|
|
|
return Canvas;
|
|
})(EventEmitter);
|
|
|
|
module.exports = Canvas;
|
|
|
|
},{"babel-runtime/core-js/object/assign":8,"babel-runtime/helpers/class-call-check":12,"babel-runtime/helpers/create-class":13,"babel-runtime/helpers/get":14,"babel-runtime/helpers/inherits":15,"events":53}],4:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var _get = require('babel-runtime/helpers/get')['default'];
|
|
|
|
var _inherits = require('babel-runtime/helpers/inherits')['default'];
|
|
|
|
var _createClass = require('babel-runtime/helpers/create-class')['default'];
|
|
|
|
var _classCallCheck = require('babel-runtime/helpers/class-call-check')['default'];
|
|
|
|
var EventEmitter = require('events').EventEmitter;
|
|
|
|
var LoadIndicator = (function (_EventEmitter) {
|
|
_inherits(LoadIndicator, _EventEmitter);
|
|
|
|
function LoadIndicator() {
|
|
_classCallCheck(this, LoadIndicator);
|
|
|
|
_get(Object.getPrototypeOf(LoadIndicator.prototype), 'constructor', this).call(this);
|
|
this.render().hide();
|
|
}
|
|
|
|
_createClass(LoadIndicator, [{
|
|
key: 'render',
|
|
value: function render() {
|
|
this.el = document.createElement('div');
|
|
this.el.id = 'cb-loading-overlay';
|
|
return this;
|
|
}
|
|
}, {
|
|
key: 'show',
|
|
value: function show() {
|
|
this.el.style.display = 'block';
|
|
this.emit('show', this);
|
|
}
|
|
}, {
|
|
key: 'hide',
|
|
value: function hide() {
|
|
this.el.style.display = 'none';
|
|
this.emit('hide', this);
|
|
}
|
|
}]);
|
|
|
|
return LoadIndicator;
|
|
})(EventEmitter);
|
|
|
|
module.exports = LoadIndicator;
|
|
|
|
},{"babel-runtime/helpers/class-call-check":12,"babel-runtime/helpers/create-class":13,"babel-runtime/helpers/get":14,"babel-runtime/helpers/inherits":15,"events":53}],5:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var _createClass = require('babel-runtime/helpers/create-class')['default'];
|
|
|
|
var _classCallCheck = require('babel-runtime/helpers/class-call-check')['default'];
|
|
|
|
var template = require('./template/progress-bar.handlebars');
|
|
|
|
var ProgressBar = (function () {
|
|
function ProgressBar() {
|
|
_classCallCheck(this, ProgressBar);
|
|
|
|
this.createElements();
|
|
this.hide();
|
|
}
|
|
|
|
_createClass(ProgressBar, [{
|
|
key: 'createElements',
|
|
value: function createElements() {
|
|
var el = document.createElement('div');
|
|
el.innerHTML = template();
|
|
this.el = el.firstChild;
|
|
this.progressEl = this.el.querySelector('.progressbar-value');
|
|
}
|
|
}, {
|
|
key: 'update',
|
|
value: function update(percentage) {
|
|
this.progressEl.style.width = percentage + '%';
|
|
}
|
|
}, {
|
|
key: 'show',
|
|
value: function show() {
|
|
this.el.style.display = 'block';
|
|
}
|
|
}, {
|
|
key: 'hide',
|
|
value: function hide() {
|
|
this.el.style.display = 'none';
|
|
}
|
|
}]);
|
|
|
|
return ProgressBar;
|
|
})();
|
|
|
|
module.exports = ProgressBar;
|
|
|
|
},{"./template/progress-bar.handlebars":6,"babel-runtime/helpers/class-call-check":12,"babel-runtime/helpers/create-class":13}],6:[function(require,module,exports){
|
|
var templater = require("handlebars/runtime")["default"].template;module.exports = templater({"compiler":[6,">= 2.0.0-beta.1"],"main":function(depth0,helpers,partials,data) {
|
|
return "<div id=\"cb-status\" class=\"cb-control\">\n <div id=\"cb-progress-bar\">\n <div class=\"progressbar-value\"></div>\n </div>\n</div>\n";
|
|
},"useData":true});
|
|
},{"handlebars/runtime":61}],7:[function(require,module,exports){
|
|
module.exports = { "default": require("core-js/library/fn/map"), __esModule: true };
|
|
},{"core-js/library/fn/map":16}],8:[function(require,module,exports){
|
|
module.exports = { "default": require("core-js/library/fn/object/assign"), __esModule: true };
|
|
},{"core-js/library/fn/object/assign":17}],9:[function(require,module,exports){
|
|
module.exports = { "default": require("core-js/library/fn/object/create"), __esModule: true };
|
|
},{"core-js/library/fn/object/create":18}],10:[function(require,module,exports){
|
|
module.exports = { "default": require("core-js/library/fn/object/define-property"), __esModule: true };
|
|
},{"core-js/library/fn/object/define-property":19}],11:[function(require,module,exports){
|
|
module.exports = { "default": require("core-js/library/fn/object/get-own-property-descriptor"), __esModule: true };
|
|
},{"core-js/library/fn/object/get-own-property-descriptor":20}],12:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
exports["default"] = function (instance, Constructor) {
|
|
if (!(instance instanceof Constructor)) {
|
|
throw new TypeError("Cannot call a class as a function");
|
|
}
|
|
};
|
|
|
|
exports.__esModule = true;
|
|
},{}],13:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
var _Object$defineProperty = require("babel-runtime/core-js/object/define-property")["default"];
|
|
|
|
exports["default"] = (function () {
|
|
function defineProperties(target, props) {
|
|
for (var i = 0; i < props.length; i++) {
|
|
var descriptor = props[i];
|
|
descriptor.enumerable = descriptor.enumerable || false;
|
|
descriptor.configurable = true;
|
|
if ("value" in descriptor) descriptor.writable = true;
|
|
|
|
_Object$defineProperty(target, descriptor.key, descriptor);
|
|
}
|
|
}
|
|
|
|
return function (Constructor, protoProps, staticProps) {
|
|
if (protoProps) defineProperties(Constructor.prototype, protoProps);
|
|
if (staticProps) defineProperties(Constructor, staticProps);
|
|
return Constructor;
|
|
};
|
|
})();
|
|
|
|
exports.__esModule = true;
|
|
},{"babel-runtime/core-js/object/define-property":10}],14:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
var _Object$getOwnPropertyDescriptor = require("babel-runtime/core-js/object/get-own-property-descriptor")["default"];
|
|
|
|
exports["default"] = function get(_x, _x2, _x3) {
|
|
var _again = true;
|
|
|
|
_function: while (_again) {
|
|
var object = _x,
|
|
property = _x2,
|
|
receiver = _x3;
|
|
desc = parent = getter = undefined;
|
|
_again = false;
|
|
if (object === null) object = Function.prototype;
|
|
|
|
var desc = _Object$getOwnPropertyDescriptor(object, property);
|
|
|
|
if (desc === undefined) {
|
|
var parent = Object.getPrototypeOf(object);
|
|
|
|
if (parent === null) {
|
|
return undefined;
|
|
} else {
|
|
_x = parent;
|
|
_x2 = property;
|
|
_x3 = receiver;
|
|
_again = true;
|
|
continue _function;
|
|
}
|
|
} else if ("value" in desc) {
|
|
return desc.value;
|
|
} else {
|
|
var getter = desc.get;
|
|
|
|
if (getter === undefined) {
|
|
return undefined;
|
|
}
|
|
|
|
return getter.call(receiver);
|
|
}
|
|
}
|
|
};
|
|
|
|
exports.__esModule = true;
|
|
},{"babel-runtime/core-js/object/get-own-property-descriptor":11}],15:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
var _Object$create = require("babel-runtime/core-js/object/create")["default"];
|
|
|
|
exports["default"] = function (subClass, superClass) {
|
|
if (typeof superClass !== "function" && superClass !== null) {
|
|
throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
|
|
}
|
|
|
|
subClass.prototype = _Object$create(superClass && superClass.prototype, {
|
|
constructor: {
|
|
value: subClass,
|
|
enumerable: false,
|
|
writable: true,
|
|
configurable: true
|
|
}
|
|
});
|
|
if (superClass) subClass.__proto__ = superClass;
|
|
};
|
|
|
|
exports.__esModule = true;
|
|
},{"babel-runtime/core-js/object/create":9}],16:[function(require,module,exports){
|
|
require('../modules/es6.object.to-string');
|
|
require('../modules/es6.string.iterator');
|
|
require('../modules/web.dom.iterable');
|
|
require('../modules/es6.map');
|
|
require('../modules/es7.map.to-json');
|
|
module.exports = require('../modules/$').core.Map;
|
|
},{"../modules/$":36,"../modules/es6.map":46,"../modules/es6.object.to-string":49,"../modules/es6.string.iterator":50,"../modules/es7.map.to-json":51,"../modules/web.dom.iterable":52}],17:[function(require,module,exports){
|
|
require('../../modules/es6.object.assign');
|
|
module.exports = require('../../modules/$').core.Object.assign;
|
|
},{"../../modules/$":36,"../../modules/es6.object.assign":47}],18:[function(require,module,exports){
|
|
var $ = require('../../modules/$');
|
|
module.exports = function create(P, D){
|
|
return $.create(P, D);
|
|
};
|
|
},{"../../modules/$":36}],19:[function(require,module,exports){
|
|
var $ = require('../../modules/$');
|
|
module.exports = function defineProperty(it, key, desc){
|
|
return $.setDesc(it, key, desc);
|
|
};
|
|
},{"../../modules/$":36}],20:[function(require,module,exports){
|
|
var $ = require('../../modules/$');
|
|
require('../../modules/es6.object.statics-accept-primitives');
|
|
module.exports = function getOwnPropertyDescriptor(it, key){
|
|
return $.getDesc(it, key);
|
|
};
|
|
},{"../../modules/$":36,"../../modules/es6.object.statics-accept-primitives":48}],21:[function(require,module,exports){
|
|
var $ = require('./$');
|
|
function assert(condition, msg1, msg2){
|
|
if(!condition)throw TypeError(msg2 ? msg1 + msg2 : msg1);
|
|
}
|
|
assert.def = $.assertDefined;
|
|
assert.fn = function(it){
|
|
if(!$.isFunction(it))throw TypeError(it + ' is not a function!');
|
|
return it;
|
|
};
|
|
assert.obj = function(it){
|
|
if(!$.isObject(it))throw TypeError(it + ' is not an object!');
|
|
return it;
|
|
};
|
|
assert.inst = function(it, Constructor, name){
|
|
if(!(it instanceof Constructor))throw TypeError(name + ": use the 'new' operator!");
|
|
return it;
|
|
};
|
|
module.exports = assert;
|
|
},{"./$":36}],22:[function(require,module,exports){
|
|
var $ = require('./$')
|
|
, enumKeys = require('./$.enum-keys');
|
|
// 19.1.2.1 Object.assign(target, source, ...)
|
|
/* eslint-disable no-unused-vars */
|
|
module.exports = Object.assign || function assign(target, source){
|
|
/* eslint-enable no-unused-vars */
|
|
var T = Object($.assertDefined(target))
|
|
, l = arguments.length
|
|
, i = 1;
|
|
while(l > i){
|
|
var S = $.ES5Object(arguments[i++])
|
|
, keys = enumKeys(S)
|
|
, length = keys.length
|
|
, j = 0
|
|
, key;
|
|
while(length > j)T[key = keys[j++]] = S[key];
|
|
}
|
|
return T;
|
|
};
|
|
},{"./$":36,"./$.enum-keys":29}],23:[function(require,module,exports){
|
|
var $ = require('./$')
|
|
, TAG = require('./$.wks')('toStringTag')
|
|
, toString = {}.toString;
|
|
function cof(it){
|
|
return toString.call(it).slice(8, -1);
|
|
}
|
|
cof.classof = function(it){
|
|
var O, T;
|
|
return it == undefined ? it === undefined ? 'Undefined' : 'Null'
|
|
: typeof (T = (O = Object(it))[TAG]) == 'string' ? T : cof(O);
|
|
};
|
|
cof.set = function(it, tag, stat){
|
|
if(it && !$.has(it = stat ? it : it.prototype, TAG))$.hide(it, TAG, tag);
|
|
};
|
|
module.exports = cof;
|
|
},{"./$":36,"./$.wks":44}],24:[function(require,module,exports){
|
|
'use strict';
|
|
var $ = require('./$')
|
|
, ctx = require('./$.ctx')
|
|
, safe = require('./$.uid').safe
|
|
, assert = require('./$.assert')
|
|
, forOf = require('./$.for-of')
|
|
, step = require('./$.iter').step
|
|
, $has = $.has
|
|
, set = $.set
|
|
, isObject = $.isObject
|
|
, hide = $.hide
|
|
, isExtensible = Object.isExtensible || isObject
|
|
, ID = safe('id')
|
|
, O1 = safe('O1')
|
|
, LAST = safe('last')
|
|
, FIRST = safe('first')
|
|
, ITER = safe('iter')
|
|
, SIZE = $.DESC ? safe('size') : 'size'
|
|
, id = 0;
|
|
|
|
function fastKey(it, create){
|
|
// return primitive with prefix
|
|
if(!isObject(it))return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;
|
|
if(!$has(it, ID)){
|
|
// can't set id to frozen object
|
|
if(!isExtensible(it))return 'F';
|
|
// not necessary to add id
|
|
if(!create)return 'E';
|
|
// add missing object id
|
|
hide(it, ID, ++id);
|
|
// return object id with prefix
|
|
} return 'O' + it[ID];
|
|
}
|
|
|
|
function getEntry(that, key){
|
|
// fast case
|
|
var index = fastKey(key), entry;
|
|
if(index !== 'F')return that[O1][index];
|
|
// frozen object case
|
|
for(entry = that[FIRST]; entry; entry = entry.n){
|
|
if(entry.k == key)return entry;
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
getConstructor: function(wrapper, NAME, IS_MAP, ADDER){
|
|
var C = wrapper(function(that, iterable){
|
|
assert.inst(that, C, NAME);
|
|
set(that, O1, $.create(null));
|
|
set(that, SIZE, 0);
|
|
set(that, LAST, undefined);
|
|
set(that, FIRST, undefined);
|
|
if(iterable != undefined)forOf(iterable, IS_MAP, that[ADDER], that);
|
|
});
|
|
require('./$.mix')(C.prototype, {
|
|
// 23.1.3.1 Map.prototype.clear()
|
|
// 23.2.3.2 Set.prototype.clear()
|
|
clear: function clear(){
|
|
for(var that = this, data = that[O1], entry = that[FIRST]; entry; entry = entry.n){
|
|
entry.r = true;
|
|
if(entry.p)entry.p = entry.p.n = undefined;
|
|
delete data[entry.i];
|
|
}
|
|
that[FIRST] = that[LAST] = undefined;
|
|
that[SIZE] = 0;
|
|
},
|
|
// 23.1.3.3 Map.prototype.delete(key)
|
|
// 23.2.3.4 Set.prototype.delete(value)
|
|
'delete': function(key){
|
|
var that = this
|
|
, entry = getEntry(that, key);
|
|
if(entry){
|
|
var next = entry.n
|
|
, prev = entry.p;
|
|
delete that[O1][entry.i];
|
|
entry.r = true;
|
|
if(prev)prev.n = next;
|
|
if(next)next.p = prev;
|
|
if(that[FIRST] == entry)that[FIRST] = next;
|
|
if(that[LAST] == entry)that[LAST] = prev;
|
|
that[SIZE]--;
|
|
} return !!entry;
|
|
},
|
|
// 23.2.3.6 Set.prototype.forEach(callbackfn, thisArg = undefined)
|
|
// 23.1.3.5 Map.prototype.forEach(callbackfn, thisArg = undefined)
|
|
forEach: function forEach(callbackfn /*, that = undefined */){
|
|
var f = ctx(callbackfn, arguments[1], 3)
|
|
, entry;
|
|
while(entry = entry ? entry.n : this[FIRST]){
|
|
f(entry.v, entry.k, this);
|
|
// revert to the last existing entry
|
|
while(entry && entry.r)entry = entry.p;
|
|
}
|
|
},
|
|
// 23.1.3.7 Map.prototype.has(key)
|
|
// 23.2.3.7 Set.prototype.has(value)
|
|
has: function has(key){
|
|
return !!getEntry(this, key);
|
|
}
|
|
});
|
|
if($.DESC)$.setDesc(C.prototype, 'size', {
|
|
get: function(){
|
|
return assert.def(this[SIZE]);
|
|
}
|
|
});
|
|
return C;
|
|
},
|
|
def: function(that, key, value){
|
|
var entry = getEntry(that, key)
|
|
, prev, index;
|
|
// change existing entry
|
|
if(entry){
|
|
entry.v = value;
|
|
// create new entry
|
|
} else {
|
|
that[LAST] = entry = {
|
|
i: index = fastKey(key, true), // <- index
|
|
k: key, // <- key
|
|
v: value, // <- value
|
|
p: prev = that[LAST], // <- previous entry
|
|
n: undefined, // <- next entry
|
|
r: false // <- removed
|
|
};
|
|
if(!that[FIRST])that[FIRST] = entry;
|
|
if(prev)prev.n = entry;
|
|
that[SIZE]++;
|
|
// add to index
|
|
if(index !== 'F')that[O1][index] = entry;
|
|
} return that;
|
|
},
|
|
getEntry: getEntry,
|
|
// add .keys, .values, .entries, [@@iterator]
|
|
// 23.1.3.4, 23.1.3.8, 23.1.3.11, 23.1.3.12, 23.2.3.5, 23.2.3.8, 23.2.3.10, 23.2.3.11
|
|
setIter: function(C, NAME, IS_MAP){
|
|
require('./$.iter-define')(C, NAME, function(iterated, kind){
|
|
set(this, ITER, {o: iterated, k: kind});
|
|
}, function(){
|
|
var iter = this[ITER]
|
|
, kind = iter.k
|
|
, entry = iter.l;
|
|
// revert to the last existing entry
|
|
while(entry && entry.r)entry = entry.p;
|
|
// get next entry
|
|
if(!iter.o || !(iter.l = entry = entry ? entry.n : iter.o[FIRST])){
|
|
// or finish the iteration
|
|
iter.o = undefined;
|
|
return step(1);
|
|
}
|
|
// return step by kind
|
|
if(kind == 'keys' )return step(0, entry.k);
|
|
if(kind == 'values')return step(0, entry.v);
|
|
return step(0, [entry.k, entry.v]);
|
|
}, IS_MAP ? 'entries' : 'values' , !IS_MAP, true);
|
|
}
|
|
};
|
|
},{"./$":36,"./$.assert":21,"./$.ctx":27,"./$.for-of":30,"./$.iter":35,"./$.iter-define":34,"./$.mix":37,"./$.uid":42}],25:[function(require,module,exports){
|
|
// https://github.com/DavidBruant/Map-Set.prototype.toJSON
|
|
var $def = require('./$.def')
|
|
, forOf = require('./$.for-of');
|
|
module.exports = function(NAME){
|
|
$def($def.P, NAME, {
|
|
toJSON: function toJSON(){
|
|
var arr = [];
|
|
forOf(this, false, arr.push, arr);
|
|
return arr;
|
|
}
|
|
});
|
|
};
|
|
},{"./$.def":28,"./$.for-of":30}],26:[function(require,module,exports){
|
|
'use strict';
|
|
var $ = require('./$')
|
|
, $def = require('./$.def')
|
|
, $iter = require('./$.iter')
|
|
, BUGGY = $iter.BUGGY
|
|
, forOf = require('./$.for-of')
|
|
, assertInstance = require('./$.assert').inst
|
|
, INTERNAL = require('./$.uid').safe('internal');
|
|
|
|
module.exports = function(NAME, wrapper, methods, common, IS_MAP, IS_WEAK){
|
|
var Base = $.g[NAME]
|
|
, C = Base
|
|
, ADDER = IS_MAP ? 'set' : 'add'
|
|
, proto = C && C.prototype
|
|
, O = {};
|
|
if(!$.DESC || !$.isFunction(C) || !(IS_WEAK || !BUGGY && proto.forEach && proto.entries)){
|
|
// create collection constructor
|
|
C = common.getConstructor(wrapper, NAME, IS_MAP, ADDER);
|
|
require('./$.mix')(C.prototype, methods);
|
|
} else {
|
|
C = wrapper(function(target, iterable){
|
|
assertInstance(target, C, NAME);
|
|
target[INTERNAL] = new Base;
|
|
if(iterable != undefined)forOf(iterable, IS_MAP, target[ADDER], target);
|
|
});
|
|
$.each.call('add,clear,delete,forEach,get,has,set,keys,values,entries'.split(','),function(KEY){
|
|
var chain = KEY == 'add' || KEY == 'set';
|
|
if(KEY in proto)$.hide(C.prototype, KEY, function(a, b){
|
|
var result = this[INTERNAL][KEY](a === 0 ? 0 : a, b);
|
|
return chain ? this : result;
|
|
});
|
|
});
|
|
if('size' in proto)$.setDesc(C.prototype, 'size', {
|
|
get: function(){
|
|
return this[INTERNAL].size;
|
|
}
|
|
});
|
|
}
|
|
|
|
require('./$.cof').set(C, NAME);
|
|
|
|
O[NAME] = C;
|
|
$def($def.G + $def.W + $def.F, O);
|
|
require('./$.species')(C);
|
|
|
|
if(!IS_WEAK)common.setIter(C, NAME, IS_MAP);
|
|
|
|
return C;
|
|
};
|
|
},{"./$":36,"./$.assert":21,"./$.cof":23,"./$.def":28,"./$.for-of":30,"./$.iter":35,"./$.mix":37,"./$.species":40,"./$.uid":42}],27:[function(require,module,exports){
|
|
// Optional / simple context binding
|
|
var assertFunction = require('./$.assert').fn;
|
|
module.exports = function(fn, that, length){
|
|
assertFunction(fn);
|
|
if(~length && that === undefined)return fn;
|
|
switch(length){
|
|
case 1: return function(a){
|
|
return fn.call(that, a);
|
|
};
|
|
case 2: return function(a, b){
|
|
return fn.call(that, a, b);
|
|
};
|
|
case 3: return function(a, b, c){
|
|
return fn.call(that, a, b, c);
|
|
};
|
|
} return function(/* ...args */){
|
|
return fn.apply(that, arguments);
|
|
};
|
|
};
|
|
},{"./$.assert":21}],28:[function(require,module,exports){
|
|
var $ = require('./$')
|
|
, global = $.g
|
|
, core = $.core
|
|
, isFunction = $.isFunction;
|
|
function ctx(fn, that){
|
|
return function(){
|
|
return fn.apply(that, arguments);
|
|
};
|
|
}
|
|
// type bitmap
|
|
$def.F = 1; // forced
|
|
$def.G = 2; // global
|
|
$def.S = 4; // static
|
|
$def.P = 8; // proto
|
|
$def.B = 16; // bind
|
|
$def.W = 32; // wrap
|
|
function $def(type, name, source){
|
|
var key, own, out, exp
|
|
, isGlobal = type & $def.G
|
|
, isProto = type & $def.P
|
|
, target = isGlobal ? global : type & $def.S
|
|
? global[name] : (global[name] || {}).prototype
|
|
, exports = isGlobal ? core : core[name] || (core[name] = {});
|
|
if(isGlobal)source = name;
|
|
for(key in source){
|
|
// contains in native
|
|
own = !(type & $def.F) && target && key in target;
|
|
if(own && key in exports)continue;
|
|
// export native or passed
|
|
out = own ? target[key] : source[key];
|
|
// prevent global pollution for namespaces
|
|
if(isGlobal && !isFunction(target[key]))exp = source[key];
|
|
// bind timers to global for call from export context
|
|
else if(type & $def.B && own)exp = ctx(out, global);
|
|
// wrap global constructors for prevent change them in library
|
|
else if(type & $def.W && target[key] == out)!function(C){
|
|
exp = function(param){
|
|
return this instanceof C ? new C(param) : C(param);
|
|
};
|
|
exp.prototype = C.prototype;
|
|
}(out);
|
|
else exp = isProto && isFunction(out) ? ctx(Function.call, out) : out;
|
|
// export
|
|
exports[key] = exp;
|
|
if(isProto)(exports.prototype || (exports.prototype = {}))[key] = out;
|
|
}
|
|
}
|
|
module.exports = $def;
|
|
},{"./$":36}],29:[function(require,module,exports){
|
|
var $ = require('./$');
|
|
module.exports = function(it){
|
|
var keys = $.getKeys(it)
|
|
, getDesc = $.getDesc
|
|
, getSymbols = $.getSymbols;
|
|
if(getSymbols)$.each.call(getSymbols(it), function(key){
|
|
if(getDesc(it, key).enumerable)keys.push(key);
|
|
});
|
|
return keys;
|
|
};
|
|
},{"./$":36}],30:[function(require,module,exports){
|
|
var ctx = require('./$.ctx')
|
|
, get = require('./$.iter').get
|
|
, call = require('./$.iter-call');
|
|
module.exports = function(iterable, entries, fn, that){
|
|
var iterator = get(iterable)
|
|
, f = ctx(fn, that, entries ? 2 : 1)
|
|
, step;
|
|
while(!(step = iterator.next()).done){
|
|
if(call(iterator, f, step.value, entries) === false){
|
|
return call.close(iterator);
|
|
}
|
|
}
|
|
};
|
|
},{"./$.ctx":27,"./$.iter":35,"./$.iter-call":33}],31:[function(require,module,exports){
|
|
module.exports = function($){
|
|
$.FW = false;
|
|
$.path = $.core;
|
|
return $;
|
|
};
|
|
},{}],32:[function(require,module,exports){
|
|
// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window
|
|
var $ = require('./$')
|
|
, toString = {}.toString
|
|
, getNames = $.getNames;
|
|
|
|
var windowNames = typeof window == 'object' && Object.getOwnPropertyNames
|
|
? Object.getOwnPropertyNames(window) : [];
|
|
|
|
function getWindowNames(it){
|
|
try {
|
|
return getNames(it);
|
|
} catch(e){
|
|
return windowNames.slice();
|
|
}
|
|
}
|
|
|
|
module.exports.get = function getOwnPropertyNames(it){
|
|
if(windowNames && toString.call(it) == '[object Window]')return getWindowNames(it);
|
|
return getNames($.toObject(it));
|
|
};
|
|
},{"./$":36}],33:[function(require,module,exports){
|
|
var assertObject = require('./$.assert').obj;
|
|
function close(iterator){
|
|
var ret = iterator['return'];
|
|
if(ret !== undefined)assertObject(ret.call(iterator));
|
|
}
|
|
function call(iterator, fn, value, entries){
|
|
try {
|
|
return entries ? fn(assertObject(value)[0], value[1]) : fn(value);
|
|
} catch(e){
|
|
close(iterator);
|
|
throw e;
|
|
}
|
|
}
|
|
call.close = close;
|
|
module.exports = call;
|
|
},{"./$.assert":21}],34:[function(require,module,exports){
|
|
var $def = require('./$.def')
|
|
, $redef = require('./$.redef')
|
|
, $ = require('./$')
|
|
, cof = require('./$.cof')
|
|
, $iter = require('./$.iter')
|
|
, SYMBOL_ITERATOR = require('./$.wks')('iterator')
|
|
, FF_ITERATOR = '@@iterator'
|
|
, KEYS = 'keys'
|
|
, VALUES = 'values'
|
|
, Iterators = $iter.Iterators;
|
|
module.exports = function(Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCE){
|
|
$iter.create(Constructor, NAME, next);
|
|
function createMethod(kind){
|
|
function $$(that){
|
|
return new Constructor(that, kind);
|
|
}
|
|
switch(kind){
|
|
case KEYS: return function keys(){ return $$(this); };
|
|
case VALUES: return function values(){ return $$(this); };
|
|
} return function entries(){ return $$(this); };
|
|
}
|
|
var TAG = NAME + ' Iterator'
|
|
, proto = Base.prototype
|
|
, _native = proto[SYMBOL_ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT]
|
|
, _default = _native || createMethod(DEFAULT)
|
|
, methods, key;
|
|
// Fix native
|
|
if(_native){
|
|
var IteratorPrototype = $.getProto(_default.call(new Base));
|
|
// Set @@toStringTag to native iterators
|
|
cof.set(IteratorPrototype, TAG, true);
|
|
// FF fix
|
|
if($.FW && $.has(proto, FF_ITERATOR))$iter.set(IteratorPrototype, $.that);
|
|
}
|
|
// Define iterator
|
|
if($.FW || FORCE)$iter.set(proto, _default);
|
|
// Plug for library
|
|
Iterators[NAME] = _default;
|
|
Iterators[TAG] = $.that;
|
|
if(DEFAULT){
|
|
methods = {
|
|
keys: IS_SET ? _default : createMethod(KEYS),
|
|
values: DEFAULT == VALUES ? _default : createMethod(VALUES),
|
|
entries: DEFAULT != VALUES ? _default : createMethod('entries')
|
|
};
|
|
if(FORCE)for(key in methods){
|
|
if(!(key in proto))$redef(proto, key, methods[key]);
|
|
} else $def($def.P + $def.F * $iter.BUGGY, NAME, methods);
|
|
}
|
|
};
|
|
},{"./$":36,"./$.cof":23,"./$.def":28,"./$.iter":35,"./$.redef":38,"./$.wks":44}],35:[function(require,module,exports){
|
|
'use strict';
|
|
var $ = require('./$')
|
|
, cof = require('./$.cof')
|
|
, classof = cof.classof
|
|
, assert = require('./$.assert')
|
|
, assertObject = assert.obj
|
|
, SYMBOL_ITERATOR = require('./$.wks')('iterator')
|
|
, FF_ITERATOR = '@@iterator'
|
|
, Iterators = require('./$.shared')('iterators')
|
|
, IteratorPrototype = {};
|
|
// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
|
|
setIterator(IteratorPrototype, $.that);
|
|
function setIterator(O, value){
|
|
$.hide(O, SYMBOL_ITERATOR, value);
|
|
// Add iterator for FF iterator protocol
|
|
if(FF_ITERATOR in [])$.hide(O, FF_ITERATOR, value);
|
|
}
|
|
|
|
module.exports = {
|
|
// Safari has buggy iterators w/o `next`
|
|
BUGGY: 'keys' in [] && !('next' in [].keys()),
|
|
Iterators: Iterators,
|
|
step: function(done, value){
|
|
return {value: value, done: !!done};
|
|
},
|
|
is: function(it){
|
|
var O = Object(it)
|
|
, Symbol = $.g.Symbol;
|
|
return (Symbol && Symbol.iterator || FF_ITERATOR) in O
|
|
|| SYMBOL_ITERATOR in O
|
|
|| $.has(Iterators, classof(O));
|
|
},
|
|
get: function(it){
|
|
var Symbol = $.g.Symbol
|
|
, getIter;
|
|
if(it != undefined){
|
|
getIter = it[Symbol && Symbol.iterator || FF_ITERATOR]
|
|
|| it[SYMBOL_ITERATOR]
|
|
|| Iterators[classof(it)];
|
|
}
|
|
assert($.isFunction(getIter), it, ' is not iterable!');
|
|
return assertObject(getIter.call(it));
|
|
},
|
|
set: setIterator,
|
|
create: function(Constructor, NAME, next, proto){
|
|
Constructor.prototype = $.create(proto || IteratorPrototype, {next: $.desc(1, next)});
|
|
cof.set(Constructor, NAME + ' Iterator');
|
|
}
|
|
};
|
|
},{"./$":36,"./$.assert":21,"./$.cof":23,"./$.shared":39,"./$.wks":44}],36:[function(require,module,exports){
|
|
'use strict';
|
|
var global = typeof self != 'undefined' ? self : Function('return this')()
|
|
, core = {}
|
|
, defineProperty = Object.defineProperty
|
|
, hasOwnProperty = {}.hasOwnProperty
|
|
, ceil = Math.ceil
|
|
, floor = Math.floor
|
|
, max = Math.max
|
|
, min = Math.min;
|
|
// The engine works fine with descriptors? Thank's IE8 for his funny defineProperty.
|
|
var DESC = !!function(){
|
|
try {
|
|
return defineProperty({}, 'a', {get: function(){ return 2; }}).a == 2;
|
|
} catch(e){ /* empty */ }
|
|
}();
|
|
var hide = createDefiner(1);
|
|
// 7.1.4 ToInteger
|
|
function toInteger(it){
|
|
return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
|
|
}
|
|
function desc(bitmap, value){
|
|
return {
|
|
enumerable : !(bitmap & 1),
|
|
configurable: !(bitmap & 2),
|
|
writable : !(bitmap & 4),
|
|
value : value
|
|
};
|
|
}
|
|
function simpleSet(object, key, value){
|
|
object[key] = value;
|
|
return object;
|
|
}
|
|
function createDefiner(bitmap){
|
|
return DESC ? function(object, key, value){
|
|
return $.setDesc(object, key, desc(bitmap, value));
|
|
} : simpleSet;
|
|
}
|
|
|
|
function isObject(it){
|
|
return it !== null && (typeof it == 'object' || typeof it == 'function');
|
|
}
|
|
function isFunction(it){
|
|
return typeof it == 'function';
|
|
}
|
|
function assertDefined(it){
|
|
if(it == undefined)throw TypeError("Can't call method on " + it);
|
|
return it;
|
|
}
|
|
|
|
var $ = module.exports = require('./$.fw')({
|
|
g: global,
|
|
core: core,
|
|
html: global.document && document.documentElement,
|
|
// http://jsperf.com/core-js-isobject
|
|
isObject: isObject,
|
|
isFunction: isFunction,
|
|
that: function(){
|
|
return this;
|
|
},
|
|
// 7.1.4 ToInteger
|
|
toInteger: toInteger,
|
|
// 7.1.15 ToLength
|
|
toLength: function(it){
|
|
return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991
|
|
},
|
|
toIndex: function(index, length){
|
|
index = toInteger(index);
|
|
return index < 0 ? max(index + length, 0) : min(index, length);
|
|
},
|
|
has: function(it, key){
|
|
return hasOwnProperty.call(it, key);
|
|
},
|
|
create: Object.create,
|
|
getProto: Object.getPrototypeOf,
|
|
DESC: DESC,
|
|
desc: desc,
|
|
getDesc: Object.getOwnPropertyDescriptor,
|
|
setDesc: defineProperty,
|
|
setDescs: Object.defineProperties,
|
|
getKeys: Object.keys,
|
|
getNames: Object.getOwnPropertyNames,
|
|
getSymbols: Object.getOwnPropertySymbols,
|
|
assertDefined: assertDefined,
|
|
// Dummy, fix for not array-like ES3 string in es5 module
|
|
ES5Object: Object,
|
|
toObject: function(it){
|
|
return $.ES5Object(assertDefined(it));
|
|
},
|
|
hide: hide,
|
|
def: createDefiner(0),
|
|
set: global.Symbol ? simpleSet : hide,
|
|
each: [].forEach
|
|
});
|
|
/* eslint-disable no-undef */
|
|
if(typeof __e != 'undefined')__e = core;
|
|
if(typeof __g != 'undefined')__g = global;
|
|
},{"./$.fw":31}],37:[function(require,module,exports){
|
|
var $redef = require('./$.redef');
|
|
module.exports = function(target, src){
|
|
for(var key in src)$redef(target, key, src[key]);
|
|
return target;
|
|
};
|
|
},{"./$.redef":38}],38:[function(require,module,exports){
|
|
module.exports = require('./$').hide;
|
|
},{"./$":36}],39:[function(require,module,exports){
|
|
var $ = require('./$')
|
|
, SHARED = '__core-js_shared__'
|
|
, store = $.g[SHARED] || ($.g[SHARED] = {});
|
|
module.exports = function(key){
|
|
return store[key] || (store[key] = {});
|
|
};
|
|
},{"./$":36}],40:[function(require,module,exports){
|
|
var $ = require('./$')
|
|
, SPECIES = require('./$.wks')('species');
|
|
module.exports = function(C){
|
|
if($.DESC && !(SPECIES in C))$.setDesc(C, SPECIES, {
|
|
configurable: true,
|
|
get: $.that
|
|
});
|
|
};
|
|
},{"./$":36,"./$.wks":44}],41:[function(require,module,exports){
|
|
// true -> String#at
|
|
// false -> String#codePointAt
|
|
var $ = require('./$');
|
|
module.exports = function(TO_STRING){
|
|
return function(that, pos){
|
|
var s = String($.assertDefined(that))
|
|
, i = $.toInteger(pos)
|
|
, l = s.length
|
|
, a, b;
|
|
if(i < 0 || i >= l)return TO_STRING ? '' : undefined;
|
|
a = s.charCodeAt(i);
|
|
return a < 0xd800 || a > 0xdbff || i + 1 === l
|
|
|| (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff
|
|
? TO_STRING ? s.charAt(i) : a
|
|
: TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;
|
|
};
|
|
};
|
|
},{"./$":36}],42:[function(require,module,exports){
|
|
var sid = 0;
|
|
function uid(key){
|
|
return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++sid + Math.random()).toString(36));
|
|
}
|
|
uid.safe = require('./$').g.Symbol || uid;
|
|
module.exports = uid;
|
|
},{"./$":36}],43:[function(require,module,exports){
|
|
module.exports = function(){ /* empty */ };
|
|
},{}],44:[function(require,module,exports){
|
|
var global = require('./$').g
|
|
, store = require('./$.shared')('wks');
|
|
module.exports = function(name){
|
|
return store[name] || (store[name] =
|
|
global.Symbol && global.Symbol[name] || require('./$.uid').safe('Symbol.' + name));
|
|
};
|
|
},{"./$":36,"./$.shared":39,"./$.uid":42}],45:[function(require,module,exports){
|
|
var $ = require('./$')
|
|
, setUnscope = require('./$.unscope')
|
|
, ITER = require('./$.uid').safe('iter')
|
|
, $iter = require('./$.iter')
|
|
, step = $iter.step
|
|
, Iterators = $iter.Iterators;
|
|
|
|
// 22.1.3.4 Array.prototype.entries()
|
|
// 22.1.3.13 Array.prototype.keys()
|
|
// 22.1.3.29 Array.prototype.values()
|
|
// 22.1.3.30 Array.prototype[@@iterator]()
|
|
require('./$.iter-define')(Array, 'Array', function(iterated, kind){
|
|
$.set(this, ITER, {o: $.toObject(iterated), i: 0, k: kind});
|
|
// 22.1.5.2.1 %ArrayIteratorPrototype%.next()
|
|
}, function(){
|
|
var iter = this[ITER]
|
|
, O = iter.o
|
|
, kind = iter.k
|
|
, index = iter.i++;
|
|
if(!O || index >= O.length){
|
|
iter.o = undefined;
|
|
return step(1);
|
|
}
|
|
if(kind == 'keys' )return step(0, index);
|
|
if(kind == 'values')return step(0, O[index]);
|
|
return step(0, [index, O[index]]);
|
|
}, 'values');
|
|
|
|
// argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)
|
|
Iterators.Arguments = Iterators.Array;
|
|
|
|
setUnscope('keys');
|
|
setUnscope('values');
|
|
setUnscope('entries');
|
|
},{"./$":36,"./$.iter":35,"./$.iter-define":34,"./$.uid":42,"./$.unscope":43}],46:[function(require,module,exports){
|
|
'use strict';
|
|
var strong = require('./$.collection-strong');
|
|
|
|
// 23.1 Map Objects
|
|
require('./$.collection')('Map', function(get){
|
|
return function Map(){ return get(this, arguments[0]); };
|
|
}, {
|
|
// 23.1.3.6 Map.prototype.get(key)
|
|
get: function get(key){
|
|
var entry = strong.getEntry(this, key);
|
|
return entry && entry.v;
|
|
},
|
|
// 23.1.3.9 Map.prototype.set(key, value)
|
|
set: function set(key, value){
|
|
return strong.def(this, key === 0 ? 0 : key, value);
|
|
}
|
|
}, strong, true);
|
|
},{"./$.collection":26,"./$.collection-strong":24}],47:[function(require,module,exports){
|
|
// 19.1.3.1 Object.assign(target, source)
|
|
var $def = require('./$.def');
|
|
$def($def.S, 'Object', {assign: require('./$.assign')});
|
|
},{"./$.assign":22,"./$.def":28}],48:[function(require,module,exports){
|
|
var $ = require('./$')
|
|
, $def = require('./$.def')
|
|
, isObject = $.isObject
|
|
, toObject = $.toObject;
|
|
$.each.call(('freeze,seal,preventExtensions,isFrozen,isSealed,isExtensible,' +
|
|
'getOwnPropertyDescriptor,getPrototypeOf,keys,getOwnPropertyNames').split(',')
|
|
, function(KEY, ID){
|
|
var fn = ($.core.Object || {})[KEY] || Object[KEY]
|
|
, forced = 0
|
|
, method = {};
|
|
method[KEY] = ID == 0 ? function freeze(it){
|
|
return isObject(it) ? fn(it) : it;
|
|
} : ID == 1 ? function seal(it){
|
|
return isObject(it) ? fn(it) : it;
|
|
} : ID == 2 ? function preventExtensions(it){
|
|
return isObject(it) ? fn(it) : it;
|
|
} : ID == 3 ? function isFrozen(it){
|
|
return isObject(it) ? fn(it) : true;
|
|
} : ID == 4 ? function isSealed(it){
|
|
return isObject(it) ? fn(it) : true;
|
|
} : ID == 5 ? function isExtensible(it){
|
|
return isObject(it) ? fn(it) : false;
|
|
} : ID == 6 ? function getOwnPropertyDescriptor(it, key){
|
|
return fn(toObject(it), key);
|
|
} : ID == 7 ? function getPrototypeOf(it){
|
|
return fn(Object($.assertDefined(it)));
|
|
} : ID == 8 ? function keys(it){
|
|
return fn(toObject(it));
|
|
} : require('./$.get-names').get;
|
|
try {
|
|
fn('z');
|
|
} catch(e){
|
|
forced = 1;
|
|
}
|
|
$def($def.S + $def.F * forced, 'Object', method);
|
|
});
|
|
},{"./$":36,"./$.def":28,"./$.get-names":32}],49:[function(require,module,exports){
|
|
'use strict';
|
|
// 19.1.3.6 Object.prototype.toString()
|
|
var cof = require('./$.cof')
|
|
, tmp = {};
|
|
tmp[require('./$.wks')('toStringTag')] = 'z';
|
|
if(require('./$').FW && cof(tmp) != 'z'){
|
|
require('./$.redef')(Object.prototype, 'toString', function toString(){
|
|
return '[object ' + cof.classof(this) + ']';
|
|
}, true);
|
|
}
|
|
},{"./$":36,"./$.cof":23,"./$.redef":38,"./$.wks":44}],50:[function(require,module,exports){
|
|
var set = require('./$').set
|
|
, $at = require('./$.string-at')(true)
|
|
, ITER = require('./$.uid').safe('iter')
|
|
, $iter = require('./$.iter')
|
|
, step = $iter.step;
|
|
|
|
// 21.1.3.27 String.prototype[@@iterator]()
|
|
require('./$.iter-define')(String, 'String', function(iterated){
|
|
set(this, ITER, {o: String(iterated), i: 0});
|
|
// 21.1.5.2.1 %StringIteratorPrototype%.next()
|
|
}, function(){
|
|
var iter = this[ITER]
|
|
, O = iter.o
|
|
, index = iter.i
|
|
, point;
|
|
if(index >= O.length)return step(1);
|
|
point = $at(O, index);
|
|
iter.i += point.length;
|
|
return step(0, point);
|
|
});
|
|
},{"./$":36,"./$.iter":35,"./$.iter-define":34,"./$.string-at":41,"./$.uid":42}],51:[function(require,module,exports){
|
|
// https://github.com/DavidBruant/Map-Set.prototype.toJSON
|
|
require('./$.collection-to-json')('Map');
|
|
},{"./$.collection-to-json":25}],52:[function(require,module,exports){
|
|
require('./es6.array.iterator');
|
|
var $ = require('./$')
|
|
, Iterators = require('./$.iter').Iterators
|
|
, ITERATOR = require('./$.wks')('iterator')
|
|
, ArrayValues = Iterators.Array
|
|
, NL = $.g.NodeList
|
|
, HTC = $.g.HTMLCollection
|
|
, NLProto = NL && NL.prototype
|
|
, HTCProto = HTC && HTC.prototype;
|
|
if($.FW){
|
|
if(NL && !(ITERATOR in NLProto))$.hide(NLProto, ITERATOR, ArrayValues);
|
|
if(HTC && !(ITERATOR in HTCProto))$.hide(HTCProto, ITERATOR, ArrayValues);
|
|
}
|
|
Iterators.NodeList = Iterators.HTMLCollection = ArrayValues;
|
|
},{"./$":36,"./$.iter":35,"./$.wks":44,"./es6.array.iterator":45}],53:[function(require,module,exports){
|
|
// Copyright Joyent, Inc. and other Node contributors.
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a
|
|
// copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
|
// persons to whom the Software is furnished to do so, subject to the
|
|
// following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included
|
|
// in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
|
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
|
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
|
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
function EventEmitter() {
|
|
this._events = this._events || {};
|
|
this._maxListeners = this._maxListeners || undefined;
|
|
}
|
|
module.exports = EventEmitter;
|
|
|
|
// Backwards-compat with node 0.10.x
|
|
EventEmitter.EventEmitter = EventEmitter;
|
|
|
|
EventEmitter.prototype._events = undefined;
|
|
EventEmitter.prototype._maxListeners = undefined;
|
|
|
|
// By default EventEmitters will print a warning if more than 10 listeners are
|
|
// added to it. This is a useful default which helps finding memory leaks.
|
|
EventEmitter.defaultMaxListeners = 10;
|
|
|
|
// Obviously not all Emitters should be limited to 10. This function allows
|
|
// that to be increased. Set to zero for unlimited.
|
|
EventEmitter.prototype.setMaxListeners = function(n) {
|
|
if (!isNumber(n) || n < 0 || isNaN(n))
|
|
throw TypeError('n must be a positive number');
|
|
this._maxListeners = n;
|
|
return this;
|
|
};
|
|
|
|
EventEmitter.prototype.emit = function(type) {
|
|
var er, handler, len, args, i, listeners;
|
|
|
|
if (!this._events)
|
|
this._events = {};
|
|
|
|
// If there is no 'error' event listener then throw.
|
|
if (type === 'error') {
|
|
if (!this._events.error ||
|
|
(isObject(this._events.error) && !this._events.error.length)) {
|
|
er = arguments[1];
|
|
if (er instanceof Error) {
|
|
throw er; // Unhandled 'error' event
|
|
}
|
|
throw TypeError('Uncaught, unspecified "error" event.');
|
|
}
|
|
}
|
|
|
|
handler = this._events[type];
|
|
|
|
if (isUndefined(handler))
|
|
return false;
|
|
|
|
if (isFunction(handler)) {
|
|
switch (arguments.length) {
|
|
// fast cases
|
|
case 1:
|
|
handler.call(this);
|
|
break;
|
|
case 2:
|
|
handler.call(this, arguments[1]);
|
|
break;
|
|
case 3:
|
|
handler.call(this, arguments[1], arguments[2]);
|
|
break;
|
|
// slower
|
|
default:
|
|
len = arguments.length;
|
|
args = new Array(len - 1);
|
|
for (i = 1; i < len; i++)
|
|
args[i - 1] = arguments[i];
|
|
handler.apply(this, args);
|
|
}
|
|
} else if (isObject(handler)) {
|
|
len = arguments.length;
|
|
args = new Array(len - 1);
|
|
for (i = 1; i < len; i++)
|
|
args[i - 1] = arguments[i];
|
|
|
|
listeners = handler.slice();
|
|
len = listeners.length;
|
|
for (i = 0; i < len; i++)
|
|
listeners[i].apply(this, args);
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
EventEmitter.prototype.addListener = function(type, listener) {
|
|
var m;
|
|
|
|
if (!isFunction(listener))
|
|
throw TypeError('listener must be a function');
|
|
|
|
if (!this._events)
|
|
this._events = {};
|
|
|
|
// To avoid recursion in the case that type === "newListener"! Before
|
|
// adding it to the listeners, first emit "newListener".
|
|
if (this._events.newListener)
|
|
this.emit('newListener', type,
|
|
isFunction(listener.listener) ?
|
|
listener.listener : listener);
|
|
|
|
if (!this._events[type])
|
|
// Optimize the case of one listener. Don't need the extra array object.
|
|
this._events[type] = listener;
|
|
else if (isObject(this._events[type]))
|
|
// If we've already got an array, just append.
|
|
this._events[type].push(listener);
|
|
else
|
|
// Adding the second element, need to change to array.
|
|
this._events[type] = [this._events[type], listener];
|
|
|
|
// Check for listener leak
|
|
if (isObject(this._events[type]) && !this._events[type].warned) {
|
|
var m;
|
|
if (!isUndefined(this._maxListeners)) {
|
|
m = this._maxListeners;
|
|
} else {
|
|
m = EventEmitter.defaultMaxListeners;
|
|
}
|
|
|
|
if (m && m > 0 && this._events[type].length > m) {
|
|
this._events[type].warned = true;
|
|
console.error('(node) warning: possible EventEmitter memory ' +
|
|
'leak detected. %d listeners added. ' +
|
|
'Use emitter.setMaxListeners() to increase limit.',
|
|
this._events[type].length);
|
|
if (typeof console.trace === 'function') {
|
|
// not supported in IE 10
|
|
console.trace();
|
|
}
|
|
}
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
EventEmitter.prototype.on = EventEmitter.prototype.addListener;
|
|
|
|
EventEmitter.prototype.once = function(type, listener) {
|
|
if (!isFunction(listener))
|
|
throw TypeError('listener must be a function');
|
|
|
|
var fired = false;
|
|
|
|
function g() {
|
|
this.removeListener(type, g);
|
|
|
|
if (!fired) {
|
|
fired = true;
|
|
listener.apply(this, arguments);
|
|
}
|
|
}
|
|
|
|
g.listener = listener;
|
|
this.on(type, g);
|
|
|
|
return this;
|
|
};
|
|
|
|
// emits a 'removeListener' event iff the listener was removed
|
|
EventEmitter.prototype.removeListener = function(type, listener) {
|
|
var list, position, length, i;
|
|
|
|
if (!isFunction(listener))
|
|
throw TypeError('listener must be a function');
|
|
|
|
if (!this._events || !this._events[type])
|
|
return this;
|
|
|
|
list = this._events[type];
|
|
length = list.length;
|
|
position = -1;
|
|
|
|
if (list === listener ||
|
|
(isFunction(list.listener) && list.listener === listener)) {
|
|
delete this._events[type];
|
|
if (this._events.removeListener)
|
|
this.emit('removeListener', type, listener);
|
|
|
|
} else if (isObject(list)) {
|
|
for (i = length; i-- > 0;) {
|
|
if (list[i] === listener ||
|
|
(list[i].listener && list[i].listener === listener)) {
|
|
position = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (position < 0)
|
|
return this;
|
|
|
|
if (list.length === 1) {
|
|
list.length = 0;
|
|
delete this._events[type];
|
|
} else {
|
|
list.splice(position, 1);
|
|
}
|
|
|
|
if (this._events.removeListener)
|
|
this.emit('removeListener', type, listener);
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
EventEmitter.prototype.removeAllListeners = function(type) {
|
|
var key, listeners;
|
|
|
|
if (!this._events)
|
|
return this;
|
|
|
|
// not listening for removeListener, no need to emit
|
|
if (!this._events.removeListener) {
|
|
if (arguments.length === 0)
|
|
this._events = {};
|
|
else if (this._events[type])
|
|
delete this._events[type];
|
|
return this;
|
|
}
|
|
|
|
// emit removeListener for all listeners on all events
|
|
if (arguments.length === 0) {
|
|
for (key in this._events) {
|
|
if (key === 'removeListener') continue;
|
|
this.removeAllListeners(key);
|
|
}
|
|
this.removeAllListeners('removeListener');
|
|
this._events = {};
|
|
return this;
|
|
}
|
|
|
|
listeners = this._events[type];
|
|
|
|
if (isFunction(listeners)) {
|
|
this.removeListener(type, listeners);
|
|
} else {
|
|
// LIFO order
|
|
while (listeners.length)
|
|
this.removeListener(type, listeners[listeners.length - 1]);
|
|
}
|
|
delete this._events[type];
|
|
|
|
return this;
|
|
};
|
|
|
|
EventEmitter.prototype.listeners = function(type) {
|
|
var ret;
|
|
if (!this._events || !this._events[type])
|
|
ret = [];
|
|
else if (isFunction(this._events[type]))
|
|
ret = [this._events[type]];
|
|
else
|
|
ret = this._events[type].slice();
|
|
return ret;
|
|
};
|
|
|
|
EventEmitter.listenerCount = function(emitter, type) {
|
|
var ret;
|
|
if (!emitter._events || !emitter._events[type])
|
|
ret = 0;
|
|
else if (isFunction(emitter._events[type]))
|
|
ret = 1;
|
|
else
|
|
ret = emitter._events[type].length;
|
|
return ret;
|
|
};
|
|
|
|
function isFunction(arg) {
|
|
return typeof arg === 'function';
|
|
}
|
|
|
|
function isNumber(arg) {
|
|
return typeof arg === 'number';
|
|
}
|
|
|
|
function isObject(arg) {
|
|
return typeof arg === 'object' && arg !== null;
|
|
}
|
|
|
|
function isUndefined(arg) {
|
|
return arg === void 0;
|
|
}
|
|
|
|
},{}],54:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var _interopRequireWildcard = function (obj) { return obj && obj.__esModule ? obj : { 'default': obj }; };
|
|
|
|
exports.__esModule = true;
|
|
|
|
var _import = require('./handlebars/base');
|
|
|
|
var base = _interopRequireWildcard(_import);
|
|
|
|
// Each of these augment the Handlebars object. No need to setup here.
|
|
// (This is done to easily share code between commonjs and browse envs)
|
|
|
|
var _SafeString = require('./handlebars/safe-string');
|
|
|
|
var _SafeString2 = _interopRequireWildcard(_SafeString);
|
|
|
|
var _Exception = require('./handlebars/exception');
|
|
|
|
var _Exception2 = _interopRequireWildcard(_Exception);
|
|
|
|
var _import2 = require('./handlebars/utils');
|
|
|
|
var Utils = _interopRequireWildcard(_import2);
|
|
|
|
var _import3 = require('./handlebars/runtime');
|
|
|
|
var runtime = _interopRequireWildcard(_import3);
|
|
|
|
var _noConflict = require('./handlebars/no-conflict');
|
|
|
|
var _noConflict2 = _interopRequireWildcard(_noConflict);
|
|
|
|
// For compatibility and usage outside of module systems, make the Handlebars object a namespace
|
|
function create() {
|
|
var hb = new base.HandlebarsEnvironment();
|
|
|
|
Utils.extend(hb, base);
|
|
hb.SafeString = _SafeString2['default'];
|
|
hb.Exception = _Exception2['default'];
|
|
hb.Utils = Utils;
|
|
hb.escapeExpression = Utils.escapeExpression;
|
|
|
|
hb.VM = runtime;
|
|
hb.template = function (spec) {
|
|
return runtime.template(spec, hb);
|
|
};
|
|
|
|
return hb;
|
|
}
|
|
|
|
var inst = create();
|
|
inst.create = create;
|
|
|
|
_noConflict2['default'](inst);
|
|
|
|
inst['default'] = inst;
|
|
|
|
exports['default'] = inst;
|
|
module.exports = exports['default'];
|
|
},{"./handlebars/base":55,"./handlebars/exception":56,"./handlebars/no-conflict":57,"./handlebars/runtime":58,"./handlebars/safe-string":59,"./handlebars/utils":60}],55:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var _interopRequireWildcard = function (obj) { return obj && obj.__esModule ? obj : { 'default': obj }; };
|
|
|
|
exports.__esModule = true;
|
|
exports.HandlebarsEnvironment = HandlebarsEnvironment;
|
|
exports.createFrame = createFrame;
|
|
|
|
var _import = require('./utils');
|
|
|
|
var Utils = _interopRequireWildcard(_import);
|
|
|
|
var _Exception = require('./exception');
|
|
|
|
var _Exception2 = _interopRequireWildcard(_Exception);
|
|
|
|
var VERSION = '3.0.1';
|
|
exports.VERSION = VERSION;
|
|
var COMPILER_REVISION = 6;
|
|
|
|
exports.COMPILER_REVISION = COMPILER_REVISION;
|
|
var REVISION_CHANGES = {
|
|
1: '<= 1.0.rc.2', // 1.0.rc.2 is actually rev2 but doesn't report it
|
|
2: '== 1.0.0-rc.3',
|
|
3: '== 1.0.0-rc.4',
|
|
4: '== 1.x.x',
|
|
5: '== 2.0.0-alpha.x',
|
|
6: '>= 2.0.0-beta.1'
|
|
};
|
|
|
|
exports.REVISION_CHANGES = REVISION_CHANGES;
|
|
var isArray = Utils.isArray,
|
|
isFunction = Utils.isFunction,
|
|
toString = Utils.toString,
|
|
objectType = '[object Object]';
|
|
|
|
function HandlebarsEnvironment(helpers, partials) {
|
|
this.helpers = helpers || {};
|
|
this.partials = partials || {};
|
|
|
|
registerDefaultHelpers(this);
|
|
}
|
|
|
|
HandlebarsEnvironment.prototype = {
|
|
constructor: HandlebarsEnvironment,
|
|
|
|
logger: logger,
|
|
log: log,
|
|
|
|
registerHelper: function registerHelper(name, fn) {
|
|
if (toString.call(name) === objectType) {
|
|
if (fn) {
|
|
throw new _Exception2['default']('Arg not supported with multiple helpers');
|
|
}
|
|
Utils.extend(this.helpers, name);
|
|
} else {
|
|
this.helpers[name] = fn;
|
|
}
|
|
},
|
|
unregisterHelper: function unregisterHelper(name) {
|
|
delete this.helpers[name];
|
|
},
|
|
|
|
registerPartial: function registerPartial(name, partial) {
|
|
if (toString.call(name) === objectType) {
|
|
Utils.extend(this.partials, name);
|
|
} else {
|
|
if (typeof partial === 'undefined') {
|
|
throw new _Exception2['default']('Attempting to register a partial as undefined');
|
|
}
|
|
this.partials[name] = partial;
|
|
}
|
|
},
|
|
unregisterPartial: function unregisterPartial(name) {
|
|
delete this.partials[name];
|
|
}
|
|
};
|
|
|
|
function registerDefaultHelpers(instance) {
|
|
instance.registerHelper('helperMissing', function () {
|
|
if (arguments.length === 1) {
|
|
// A missing field in a {{foo}} constuct.
|
|
return undefined;
|
|
} else {
|
|
// Someone is actually trying to call something, blow up.
|
|
throw new _Exception2['default']('Missing helper: "' + arguments[arguments.length - 1].name + '"');
|
|
}
|
|
});
|
|
|
|
instance.registerHelper('blockHelperMissing', function (context, options) {
|
|
var inverse = options.inverse,
|
|
fn = options.fn;
|
|
|
|
if (context === true) {
|
|
return fn(this);
|
|
} else if (context === false || context == null) {
|
|
return inverse(this);
|
|
} else if (isArray(context)) {
|
|
if (context.length > 0) {
|
|
if (options.ids) {
|
|
options.ids = [options.name];
|
|
}
|
|
|
|
return instance.helpers.each(context, options);
|
|
} else {
|
|
return inverse(this);
|
|
}
|
|
} else {
|
|
if (options.data && options.ids) {
|
|
var data = createFrame(options.data);
|
|
data.contextPath = Utils.appendContextPath(options.data.contextPath, options.name);
|
|
options = { data: data };
|
|
}
|
|
|
|
return fn(context, options);
|
|
}
|
|
});
|
|
|
|
instance.registerHelper('each', function (context, options) {
|
|
if (!options) {
|
|
throw new _Exception2['default']('Must pass iterator to #each');
|
|
}
|
|
|
|
var fn = options.fn,
|
|
inverse = options.inverse,
|
|
i = 0,
|
|
ret = '',
|
|
data = undefined,
|
|
contextPath = undefined;
|
|
|
|
if (options.data && options.ids) {
|
|
contextPath = Utils.appendContextPath(options.data.contextPath, options.ids[0]) + '.';
|
|
}
|
|
|
|
if (isFunction(context)) {
|
|
context = context.call(this);
|
|
}
|
|
|
|
if (options.data) {
|
|
data = createFrame(options.data);
|
|
}
|
|
|
|
function execIteration(field, index, last) {
|
|
if (data) {
|
|
data.key = field;
|
|
data.index = index;
|
|
data.first = index === 0;
|
|
data.last = !!last;
|
|
|
|
if (contextPath) {
|
|
data.contextPath = contextPath + field;
|
|
}
|
|
}
|
|
|
|
ret = ret + fn(context[field], {
|
|
data: data,
|
|
blockParams: Utils.blockParams([context[field], field], [contextPath + field, null])
|
|
});
|
|
}
|
|
|
|
if (context && typeof context === 'object') {
|
|
if (isArray(context)) {
|
|
for (var j = context.length; i < j; i++) {
|
|
execIteration(i, i, i === context.length - 1);
|
|
}
|
|
} else {
|
|
var priorKey = undefined;
|
|
|
|
for (var key in context) {
|
|
if (context.hasOwnProperty(key)) {
|
|
// We're running the iterations one step out of sync so we can detect
|
|
// the last iteration without have to scan the object twice and create
|
|
// an itermediate keys array.
|
|
if (priorKey) {
|
|
execIteration(priorKey, i - 1);
|
|
}
|
|
priorKey = key;
|
|
i++;
|
|
}
|
|
}
|
|
if (priorKey) {
|
|
execIteration(priorKey, i - 1, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (i === 0) {
|
|
ret = inverse(this);
|
|
}
|
|
|
|
return ret;
|
|
});
|
|
|
|
instance.registerHelper('if', function (conditional, options) {
|
|
if (isFunction(conditional)) {
|
|
conditional = conditional.call(this);
|
|
}
|
|
|
|
// Default behavior is to render the positive path if the value is truthy and not empty.
|
|
// The `includeZero` option may be set to treat the condtional as purely not empty based on the
|
|
// behavior of isEmpty. Effectively this determines if 0 is handled by the positive path or negative.
|
|
if (!options.hash.includeZero && !conditional || Utils.isEmpty(conditional)) {
|
|
return options.inverse(this);
|
|
} else {
|
|
return options.fn(this);
|
|
}
|
|
});
|
|
|
|
instance.registerHelper('unless', function (conditional, options) {
|
|
return instance.helpers['if'].call(this, conditional, { fn: options.inverse, inverse: options.fn, hash: options.hash });
|
|
});
|
|
|
|
instance.registerHelper('with', function (context, options) {
|
|
if (isFunction(context)) {
|
|
context = context.call(this);
|
|
}
|
|
|
|
var fn = options.fn;
|
|
|
|
if (!Utils.isEmpty(context)) {
|
|
if (options.data && options.ids) {
|
|
var data = createFrame(options.data);
|
|
data.contextPath = Utils.appendContextPath(options.data.contextPath, options.ids[0]);
|
|
options = { data: data };
|
|
}
|
|
|
|
return fn(context, options);
|
|
} else {
|
|
return options.inverse(this);
|
|
}
|
|
});
|
|
|
|
instance.registerHelper('log', function (message, options) {
|
|
var level = options.data && options.data.level != null ? parseInt(options.data.level, 10) : 1;
|
|
instance.log(level, message);
|
|
});
|
|
|
|
instance.registerHelper('lookup', function (obj, field) {
|
|
return obj && obj[field];
|
|
});
|
|
}
|
|
|
|
var logger = {
|
|
methodMap: { 0: 'debug', 1: 'info', 2: 'warn', 3: 'error' },
|
|
|
|
// State enum
|
|
DEBUG: 0,
|
|
INFO: 1,
|
|
WARN: 2,
|
|
ERROR: 3,
|
|
level: 1,
|
|
|
|
// Can be overridden in the host environment
|
|
log: function log(level, message) {
|
|
if (typeof console !== 'undefined' && logger.level <= level) {
|
|
var method = logger.methodMap[level];
|
|
(console[method] || console.log).call(console, message); // eslint-disable-line no-console
|
|
}
|
|
}
|
|
};
|
|
|
|
exports.logger = logger;
|
|
var log = logger.log;
|
|
|
|
exports.log = log;
|
|
|
|
function createFrame(object) {
|
|
var frame = Utils.extend({}, object);
|
|
frame._parent = object;
|
|
return frame;
|
|
}
|
|
|
|
/* [args, ]options */
|
|
},{"./exception":56,"./utils":60}],56:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
var errorProps = ['description', 'fileName', 'lineNumber', 'message', 'name', 'number', 'stack'];
|
|
|
|
function Exception(message, node) {
|
|
var loc = node && node.loc,
|
|
line = undefined,
|
|
column = undefined;
|
|
if (loc) {
|
|
line = loc.start.line;
|
|
column = loc.start.column;
|
|
|
|
message += ' - ' + line + ':' + column;
|
|
}
|
|
|
|
var tmp = Error.prototype.constructor.call(this, message);
|
|
|
|
// Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work.
|
|
for (var idx = 0; idx < errorProps.length; idx++) {
|
|
this[errorProps[idx]] = tmp[errorProps[idx]];
|
|
}
|
|
|
|
if (Error.captureStackTrace) {
|
|
Error.captureStackTrace(this, Exception);
|
|
}
|
|
|
|
if (loc) {
|
|
this.lineNumber = line;
|
|
this.column = column;
|
|
}
|
|
}
|
|
|
|
Exception.prototype = new Error();
|
|
|
|
exports['default'] = Exception;
|
|
module.exports = exports['default'];
|
|
},{}],57:[function(require,module,exports){
|
|
(function (global){
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
/*global window */
|
|
|
|
exports['default'] = function (Handlebars) {
|
|
/* istanbul ignore next */
|
|
var root = typeof global !== 'undefined' ? global : window,
|
|
$Handlebars = root.Handlebars;
|
|
/* istanbul ignore next */
|
|
Handlebars.noConflict = function () {
|
|
if (root.Handlebars === Handlebars) {
|
|
root.Handlebars = $Handlebars;
|
|
}
|
|
};
|
|
};
|
|
|
|
module.exports = exports['default'];
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
|
|
},{}],58:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var _interopRequireWildcard = function (obj) { return obj && obj.__esModule ? obj : { 'default': obj }; };
|
|
|
|
exports.__esModule = true;
|
|
exports.checkRevision = checkRevision;
|
|
|
|
// TODO: Remove this line and break up compilePartial
|
|
|
|
exports.template = template;
|
|
exports.wrapProgram = wrapProgram;
|
|
exports.resolvePartial = resolvePartial;
|
|
exports.invokePartial = invokePartial;
|
|
exports.noop = noop;
|
|
|
|
var _import = require('./utils');
|
|
|
|
var Utils = _interopRequireWildcard(_import);
|
|
|
|
var _Exception = require('./exception');
|
|
|
|
var _Exception2 = _interopRequireWildcard(_Exception);
|
|
|
|
var _COMPILER_REVISION$REVISION_CHANGES$createFrame = require('./base');
|
|
|
|
function checkRevision(compilerInfo) {
|
|
var compilerRevision = compilerInfo && compilerInfo[0] || 1,
|
|
currentRevision = _COMPILER_REVISION$REVISION_CHANGES$createFrame.COMPILER_REVISION;
|
|
|
|
if (compilerRevision !== currentRevision) {
|
|
if (compilerRevision < currentRevision) {
|
|
var runtimeVersions = _COMPILER_REVISION$REVISION_CHANGES$createFrame.REVISION_CHANGES[currentRevision],
|
|
compilerVersions = _COMPILER_REVISION$REVISION_CHANGES$createFrame.REVISION_CHANGES[compilerRevision];
|
|
throw new _Exception2['default']('Template was precompiled with an older version of Handlebars than the current runtime. ' + 'Please update your precompiler to a newer version (' + runtimeVersions + ') or downgrade your runtime to an older version (' + compilerVersions + ').');
|
|
} else {
|
|
// Use the embedded version info since the runtime doesn't know about this revision yet
|
|
throw new _Exception2['default']('Template was precompiled with a newer version of Handlebars than the current runtime. ' + 'Please update your runtime to a newer version (' + compilerInfo[1] + ').');
|
|
}
|
|
}
|
|
}
|
|
|
|
function template(templateSpec, env) {
|
|
/* istanbul ignore next */
|
|
if (!env) {
|
|
throw new _Exception2['default']('No environment passed to template');
|
|
}
|
|
if (!templateSpec || !templateSpec.main) {
|
|
throw new _Exception2['default']('Unknown template object: ' + typeof templateSpec);
|
|
}
|
|
|
|
// Note: Using env.VM references rather than local var references throughout this section to allow
|
|
// for external users to override these as psuedo-supported APIs.
|
|
env.VM.checkRevision(templateSpec.compiler);
|
|
|
|
function invokePartialWrapper(partial, context, options) {
|
|
if (options.hash) {
|
|
context = Utils.extend({}, context, options.hash);
|
|
}
|
|
|
|
partial = env.VM.resolvePartial.call(this, partial, context, options);
|
|
var result = env.VM.invokePartial.call(this, partial, context, options);
|
|
|
|
if (result == null && env.compile) {
|
|
options.partials[options.name] = env.compile(partial, templateSpec.compilerOptions, env);
|
|
result = options.partials[options.name](context, options);
|
|
}
|
|
if (result != null) {
|
|
if (options.indent) {
|
|
var lines = result.split('\n');
|
|
for (var i = 0, l = lines.length; i < l; i++) {
|
|
if (!lines[i] && i + 1 === l) {
|
|
break;
|
|
}
|
|
|
|
lines[i] = options.indent + lines[i];
|
|
}
|
|
result = lines.join('\n');
|
|
}
|
|
return result;
|
|
} else {
|
|
throw new _Exception2['default']('The partial ' + options.name + ' could not be compiled when running in runtime-only mode');
|
|
}
|
|
}
|
|
|
|
// Just add water
|
|
var container = {
|
|
strict: function strict(obj, name) {
|
|
if (!(name in obj)) {
|
|
throw new _Exception2['default']('"' + name + '" not defined in ' + obj);
|
|
}
|
|
return obj[name];
|
|
},
|
|
lookup: function lookup(depths, name) {
|
|
var len = depths.length;
|
|
for (var i = 0; i < len; i++) {
|
|
if (depths[i] && depths[i][name] != null) {
|
|
return depths[i][name];
|
|
}
|
|
}
|
|
},
|
|
lambda: function lambda(current, context) {
|
|
return typeof current === 'function' ? current.call(context) : current;
|
|
},
|
|
|
|
escapeExpression: Utils.escapeExpression,
|
|
invokePartial: invokePartialWrapper,
|
|
|
|
fn: function fn(i) {
|
|
return templateSpec[i];
|
|
},
|
|
|
|
programs: [],
|
|
program: function program(i, data, declaredBlockParams, blockParams, depths) {
|
|
var programWrapper = this.programs[i],
|
|
fn = this.fn(i);
|
|
if (data || depths || blockParams || declaredBlockParams) {
|
|
programWrapper = wrapProgram(this, i, fn, data, declaredBlockParams, blockParams, depths);
|
|
} else if (!programWrapper) {
|
|
programWrapper = this.programs[i] = wrapProgram(this, i, fn);
|
|
}
|
|
return programWrapper;
|
|
},
|
|
|
|
data: function data(value, depth) {
|
|
while (value && depth--) {
|
|
value = value._parent;
|
|
}
|
|
return value;
|
|
},
|
|
merge: function merge(param, common) {
|
|
var obj = param || common;
|
|
|
|
if (param && common && param !== common) {
|
|
obj = Utils.extend({}, common, param);
|
|
}
|
|
|
|
return obj;
|
|
},
|
|
|
|
noop: env.VM.noop,
|
|
compilerInfo: templateSpec.compiler
|
|
};
|
|
|
|
function ret(context) {
|
|
var options = arguments[1] === undefined ? {} : arguments[1];
|
|
|
|
var data = options.data;
|
|
|
|
ret._setup(options);
|
|
if (!options.partial && templateSpec.useData) {
|
|
data = initData(context, data);
|
|
}
|
|
var depths = undefined,
|
|
blockParams = templateSpec.useBlockParams ? [] : undefined;
|
|
if (templateSpec.useDepths) {
|
|
depths = options.depths ? [context].concat(options.depths) : [context];
|
|
}
|
|
|
|
return templateSpec.main.call(container, context, container.helpers, container.partials, data, blockParams, depths);
|
|
}
|
|
ret.isTop = true;
|
|
|
|
ret._setup = function (options) {
|
|
if (!options.partial) {
|
|
container.helpers = container.merge(options.helpers, env.helpers);
|
|
|
|
if (templateSpec.usePartial) {
|
|
container.partials = container.merge(options.partials, env.partials);
|
|
}
|
|
} else {
|
|
container.helpers = options.helpers;
|
|
container.partials = options.partials;
|
|
}
|
|
};
|
|
|
|
ret._child = function (i, data, blockParams, depths) {
|
|
if (templateSpec.useBlockParams && !blockParams) {
|
|
throw new _Exception2['default']('must pass block params');
|
|
}
|
|
if (templateSpec.useDepths && !depths) {
|
|
throw new _Exception2['default']('must pass parent depths');
|
|
}
|
|
|
|
return wrapProgram(container, i, templateSpec[i], data, 0, blockParams, depths);
|
|
};
|
|
return ret;
|
|
}
|
|
|
|
function wrapProgram(container, i, fn, data, declaredBlockParams, blockParams, depths) {
|
|
function prog(context) {
|
|
var options = arguments[1] === undefined ? {} : arguments[1];
|
|
|
|
return fn.call(container, context, container.helpers, container.partials, options.data || data, blockParams && [options.blockParams].concat(blockParams), depths && [context].concat(depths));
|
|
}
|
|
prog.program = i;
|
|
prog.depth = depths ? depths.length : 0;
|
|
prog.blockParams = declaredBlockParams || 0;
|
|
return prog;
|
|
}
|
|
|
|
function resolvePartial(partial, context, options) {
|
|
if (!partial) {
|
|
partial = options.partials[options.name];
|
|
} else if (!partial.call && !options.name) {
|
|
// This is a dynamic partial that returned a string
|
|
options.name = partial;
|
|
partial = options.partials[partial];
|
|
}
|
|
return partial;
|
|
}
|
|
|
|
function invokePartial(partial, context, options) {
|
|
options.partial = true;
|
|
|
|
if (partial === undefined) {
|
|
throw new _Exception2['default']('The partial ' + options.name + ' could not be found');
|
|
} else if (partial instanceof Function) {
|
|
return partial(context, options);
|
|
}
|
|
}
|
|
|
|
function noop() {
|
|
return '';
|
|
}
|
|
|
|
function initData(context, data) {
|
|
if (!data || !('root' in data)) {
|
|
data = data ? _COMPILER_REVISION$REVISION_CHANGES$createFrame.createFrame(data) : {};
|
|
data.root = context;
|
|
}
|
|
return data;
|
|
}
|
|
},{"./base":55,"./exception":56,"./utils":60}],59:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
// Build out our basic SafeString type
|
|
function SafeString(string) {
|
|
this.string = string;
|
|
}
|
|
|
|
SafeString.prototype.toString = SafeString.prototype.toHTML = function () {
|
|
return '' + this.string;
|
|
};
|
|
|
|
exports['default'] = SafeString;
|
|
module.exports = exports['default'];
|
|
},{}],60:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
exports.extend = extend;
|
|
|
|
// Older IE versions do not directly support indexOf so we must implement our own, sadly.
|
|
exports.indexOf = indexOf;
|
|
exports.escapeExpression = escapeExpression;
|
|
exports.isEmpty = isEmpty;
|
|
exports.blockParams = blockParams;
|
|
exports.appendContextPath = appendContextPath;
|
|
var escape = {
|
|
'&': '&',
|
|
'<': '<',
|
|
'>': '>',
|
|
'"': '"',
|
|
'\'': ''',
|
|
'`': '`'
|
|
};
|
|
|
|
var badChars = /[&<>"'`]/g,
|
|
possible = /[&<>"'`]/;
|
|
|
|
function escapeChar(chr) {
|
|
return escape[chr];
|
|
}
|
|
|
|
function extend(obj /* , ...source */) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
for (var key in arguments[i]) {
|
|
if (Object.prototype.hasOwnProperty.call(arguments[i], key)) {
|
|
obj[key] = arguments[i][key];
|
|
}
|
|
}
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
|
|
var toString = Object.prototype.toString;
|
|
|
|
exports.toString = toString;
|
|
// Sourced from lodash
|
|
// https://github.com/bestiejs/lodash/blob/master/LICENSE.txt
|
|
/*eslint-disable func-style, no-var */
|
|
var isFunction = function isFunction(value) {
|
|
return typeof value === 'function';
|
|
};
|
|
// fallback for older versions of Chrome and Safari
|
|
/* istanbul ignore next */
|
|
if (isFunction(/x/)) {
|
|
exports.isFunction = isFunction = function (value) {
|
|
return typeof value === 'function' && toString.call(value) === '[object Function]';
|
|
};
|
|
}
|
|
var isFunction;
|
|
exports.isFunction = isFunction;
|
|
/*eslint-enable func-style, no-var */
|
|
|
|
/* istanbul ignore next */
|
|
var isArray = Array.isArray || function (value) {
|
|
return value && typeof value === 'object' ? toString.call(value) === '[object Array]' : false;
|
|
};exports.isArray = isArray;
|
|
|
|
function indexOf(array, value) {
|
|
for (var i = 0, len = array.length; i < len; i++) {
|
|
if (array[i] === value) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
function escapeExpression(string) {
|
|
if (typeof string !== 'string') {
|
|
// don't escape SafeStrings, since they're already safe
|
|
if (string && string.toHTML) {
|
|
return string.toHTML();
|
|
} else if (string == null) {
|
|
return '';
|
|
} else if (!string) {
|
|
return string + '';
|
|
}
|
|
|
|
// Force a string conversion as this will be done by the append regardless and
|
|
// the regex test will do this transparently behind the scenes, causing issues if
|
|
// an object's to string has escaped characters in it.
|
|
string = '' + string;
|
|
}
|
|
|
|
if (!possible.test(string)) {
|
|
return string;
|
|
}
|
|
return string.replace(badChars, escapeChar);
|
|
}
|
|
|
|
function isEmpty(value) {
|
|
if (!value && value !== 0) {
|
|
return true;
|
|
} else if (isArray(value) && value.length === 0) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function blockParams(params, ids) {
|
|
params.path = ids;
|
|
return params;
|
|
}
|
|
|
|
function appendContextPath(contextPath, id) {
|
|
return (contextPath ? contextPath + '.' : '') + id;
|
|
}
|
|
},{}],61:[function(require,module,exports){
|
|
// Create a simple path alias to allow browserify to resolve
|
|
// the runtime on a supported path.
|
|
module.exports = require('./dist/cjs/handlebars.runtime')['default'];
|
|
|
|
},{"./dist/cjs/handlebars.runtime":54}],62:[function(require,module,exports){
|
|
/**
|
|
* lodash 3.9.1 (Custom Build) <https://lodash.com/>
|
|
* Build: `lodash modern modularize exports="npm" -o ./`
|
|
* Copyright 2012-2015 The Dojo Foundation <http://dojofoundation.org/>
|
|
* Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
|
|
* Copyright 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
|
|
* Available under MIT license <https://lodash.com/license>
|
|
*/
|
|
|
|
/** `Object#toString` result references. */
|
|
var funcTag = '[object Function]';
|
|
|
|
/** Used to detect host constructors (Safari > 5). */
|
|
var reIsHostCtor = /^\[object .+?Constructor\]$/;
|
|
|
|
/**
|
|
* Checks if `value` is object-like.
|
|
*
|
|
* @private
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if `value` is object-like, else `false`.
|
|
*/
|
|
function isObjectLike(value) {
|
|
return !!value && typeof value == 'object';
|
|
}
|
|
|
|
/** Used for native method references. */
|
|
var objectProto = Object.prototype;
|
|
|
|
/** Used to resolve the decompiled source of functions. */
|
|
var fnToString = Function.prototype.toString;
|
|
|
|
/** Used to check objects for own properties. */
|
|
var hasOwnProperty = objectProto.hasOwnProperty;
|
|
|
|
/**
|
|
* Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
|
|
* of values.
|
|
*/
|
|
var objToString = objectProto.toString;
|
|
|
|
/** Used to detect if a method is native. */
|
|
var reIsNative = RegExp('^' +
|
|
fnToString.call(hasOwnProperty).replace(/[\\^$.*+?()[\]{}|]/g, '\\$&')
|
|
.replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
|
|
);
|
|
|
|
/**
|
|
* Gets the native function at `key` of `object`.
|
|
*
|
|
* @private
|
|
* @param {Object} object The object to query.
|
|
* @param {string} key The key of the method to get.
|
|
* @returns {*} Returns the function if it's native, else `undefined`.
|
|
*/
|
|
function getNative(object, key) {
|
|
var value = object == null ? undefined : object[key];
|
|
return isNative(value) ? value : undefined;
|
|
}
|
|
|
|
/**
|
|
* Checks if `value` is classified as a `Function` object.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Lang
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
|
|
* @example
|
|
*
|
|
* _.isFunction(_);
|
|
* // => true
|
|
*
|
|
* _.isFunction(/abc/);
|
|
* // => false
|
|
*/
|
|
function isFunction(value) {
|
|
// The use of `Object#toString` avoids issues with the `typeof` operator
|
|
// in older versions of Chrome and Safari which return 'function' for regexes
|
|
// and Safari 8 equivalents which return 'object' for typed array constructors.
|
|
return isObject(value) && objToString.call(value) == funcTag;
|
|
}
|
|
|
|
/**
|
|
* Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`.
|
|
* (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Lang
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if `value` is an object, else `false`.
|
|
* @example
|
|
*
|
|
* _.isObject({});
|
|
* // => true
|
|
*
|
|
* _.isObject([1, 2, 3]);
|
|
* // => true
|
|
*
|
|
* _.isObject(1);
|
|
* // => false
|
|
*/
|
|
function isObject(value) {
|
|
// Avoid a V8 JIT bug in Chrome 19-20.
|
|
// See https://code.google.com/p/v8/issues/detail?id=2291 for more details.
|
|
var type = typeof value;
|
|
return !!value && (type == 'object' || type == 'function');
|
|
}
|
|
|
|
/**
|
|
* Checks if `value` is a native function.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Lang
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if `value` is a native function, else `false`.
|
|
* @example
|
|
*
|
|
* _.isNative(Array.prototype.push);
|
|
* // => true
|
|
*
|
|
* _.isNative(_);
|
|
* // => false
|
|
*/
|
|
function isNative(value) {
|
|
if (value == null) {
|
|
return false;
|
|
}
|
|
if (isFunction(value)) {
|
|
return reIsNative.test(fnToString.call(value));
|
|
}
|
|
return isObjectLike(value) && reIsHostCtor.test(value);
|
|
}
|
|
|
|
module.exports = getNative;
|
|
|
|
},{}],63:[function(require,module,exports){
|
|
/**
|
|
* lodash 3.1.1 (Custom Build) <https://lodash.com/>
|
|
* Build: `lodash modern modularize exports="npm" -o ./`
|
|
* Copyright 2012-2015 The Dojo Foundation <http://dojofoundation.org/>
|
|
* Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
|
|
* Copyright 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
|
|
* Available under MIT license <https://lodash.com/license>
|
|
*/
|
|
var getNative = require('lodash._getnative');
|
|
|
|
/** Used as the `TypeError` message for "Functions" methods. */
|
|
var FUNC_ERROR_TEXT = 'Expected a function';
|
|
|
|
/* Native method references for those with the same name as other `lodash` methods. */
|
|
var nativeMax = Math.max,
|
|
nativeNow = getNative(Date, 'now');
|
|
|
|
/**
|
|
* Gets the number of milliseconds that have elapsed since the Unix epoch
|
|
* (1 January 1970 00:00:00 UTC).
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Date
|
|
* @example
|
|
*
|
|
* _.defer(function(stamp) {
|
|
* console.log(_.now() - stamp);
|
|
* }, _.now());
|
|
* // => logs the number of milliseconds it took for the deferred function to be invoked
|
|
*/
|
|
var now = nativeNow || function() {
|
|
return new Date().getTime();
|
|
};
|
|
|
|
/**
|
|
* Creates a debounced function that delays invoking `func` until after `wait`
|
|
* milliseconds have elapsed since the last time the debounced function was
|
|
* invoked. The debounced function comes with a `cancel` method to cancel
|
|
* delayed invocations. Provide an options object to indicate that `func`
|
|
* should be invoked on the leading and/or trailing edge of the `wait` timeout.
|
|
* Subsequent calls to the debounced function return the result of the last
|
|
* `func` invocation.
|
|
*
|
|
* **Note:** If `leading` and `trailing` options are `true`, `func` is invoked
|
|
* on the trailing edge of the timeout only if the the debounced function is
|
|
* invoked more than once during the `wait` timeout.
|
|
*
|
|
* See [David Corbacho's article](http://drupalmotion.com/article/debounce-and-throttle-visual-explanation)
|
|
* for details over the differences between `_.debounce` and `_.throttle`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Function
|
|
* @param {Function} func The function to debounce.
|
|
* @param {number} [wait=0] The number of milliseconds to delay.
|
|
* @param {Object} [options] The options object.
|
|
* @param {boolean} [options.leading=false] Specify invoking on the leading
|
|
* edge of the timeout.
|
|
* @param {number} [options.maxWait] The maximum time `func` is allowed to be
|
|
* delayed before it is invoked.
|
|
* @param {boolean} [options.trailing=true] Specify invoking on the trailing
|
|
* edge of the timeout.
|
|
* @returns {Function} Returns the new debounced function.
|
|
* @example
|
|
*
|
|
* // avoid costly calculations while the window size is in flux
|
|
* jQuery(window).on('resize', _.debounce(calculateLayout, 150));
|
|
*
|
|
* // invoke `sendMail` when the click event is fired, debouncing subsequent calls
|
|
* jQuery('#postbox').on('click', _.debounce(sendMail, 300, {
|
|
* 'leading': true,
|
|
* 'trailing': false
|
|
* }));
|
|
*
|
|
* // ensure `batchLog` is invoked once after 1 second of debounced calls
|
|
* var source = new EventSource('/stream');
|
|
* jQuery(source).on('message', _.debounce(batchLog, 250, {
|
|
* 'maxWait': 1000
|
|
* }));
|
|
*
|
|
* // cancel a debounced call
|
|
* var todoChanges = _.debounce(batchLog, 1000);
|
|
* Object.observe(models.todo, todoChanges);
|
|
*
|
|
* Object.observe(models, function(changes) {
|
|
* if (_.find(changes, { 'user': 'todo', 'type': 'delete'})) {
|
|
* todoChanges.cancel();
|
|
* }
|
|
* }, ['delete']);
|
|
*
|
|
* // ...at some point `models.todo` is changed
|
|
* models.todo.completed = true;
|
|
*
|
|
* // ...before 1 second has passed `models.todo` is deleted
|
|
* // which cancels the debounced `todoChanges` call
|
|
* delete models.todo;
|
|
*/
|
|
function debounce(func, wait, options) {
|
|
var args,
|
|
maxTimeoutId,
|
|
result,
|
|
stamp,
|
|
thisArg,
|
|
timeoutId,
|
|
trailingCall,
|
|
lastCalled = 0,
|
|
maxWait = false,
|
|
trailing = true;
|
|
|
|
if (typeof func != 'function') {
|
|
throw new TypeError(FUNC_ERROR_TEXT);
|
|
}
|
|
wait = wait < 0 ? 0 : (+wait || 0);
|
|
if (options === true) {
|
|
var leading = true;
|
|
trailing = false;
|
|
} else if (isObject(options)) {
|
|
leading = !!options.leading;
|
|
maxWait = 'maxWait' in options && nativeMax(+options.maxWait || 0, wait);
|
|
trailing = 'trailing' in options ? !!options.trailing : trailing;
|
|
}
|
|
|
|
function cancel() {
|
|
if (timeoutId) {
|
|
clearTimeout(timeoutId);
|
|
}
|
|
if (maxTimeoutId) {
|
|
clearTimeout(maxTimeoutId);
|
|
}
|
|
lastCalled = 0;
|
|
maxTimeoutId = timeoutId = trailingCall = undefined;
|
|
}
|
|
|
|
function complete(isCalled, id) {
|
|
if (id) {
|
|
clearTimeout(id);
|
|
}
|
|
maxTimeoutId = timeoutId = trailingCall = undefined;
|
|
if (isCalled) {
|
|
lastCalled = now();
|
|
result = func.apply(thisArg, args);
|
|
if (!timeoutId && !maxTimeoutId) {
|
|
args = thisArg = undefined;
|
|
}
|
|
}
|
|
}
|
|
|
|
function delayed() {
|
|
var remaining = wait - (now() - stamp);
|
|
if (remaining <= 0 || remaining > wait) {
|
|
complete(trailingCall, maxTimeoutId);
|
|
} else {
|
|
timeoutId = setTimeout(delayed, remaining);
|
|
}
|
|
}
|
|
|
|
function maxDelayed() {
|
|
complete(trailing, timeoutId);
|
|
}
|
|
|
|
function debounced() {
|
|
args = arguments;
|
|
stamp = now();
|
|
thisArg = this;
|
|
trailingCall = trailing && (timeoutId || !leading);
|
|
|
|
if (maxWait === false) {
|
|
var leadingCall = leading && !timeoutId;
|
|
} else {
|
|
if (!maxTimeoutId && !leading) {
|
|
lastCalled = stamp;
|
|
}
|
|
var remaining = maxWait - (stamp - lastCalled),
|
|
isCalled = remaining <= 0 || remaining > maxWait;
|
|
|
|
if (isCalled) {
|
|
if (maxTimeoutId) {
|
|
maxTimeoutId = clearTimeout(maxTimeoutId);
|
|
}
|
|
lastCalled = stamp;
|
|
result = func.apply(thisArg, args);
|
|
}
|
|
else if (!maxTimeoutId) {
|
|
maxTimeoutId = setTimeout(maxDelayed, remaining);
|
|
}
|
|
}
|
|
if (isCalled && timeoutId) {
|
|
timeoutId = clearTimeout(timeoutId);
|
|
}
|
|
else if (!timeoutId && wait !== maxWait) {
|
|
timeoutId = setTimeout(delayed, wait);
|
|
}
|
|
if (leadingCall) {
|
|
isCalled = true;
|
|
result = func.apply(thisArg, args);
|
|
}
|
|
if (isCalled && !timeoutId && !maxTimeoutId) {
|
|
args = thisArg = undefined;
|
|
}
|
|
return result;
|
|
}
|
|
debounced.cancel = cancel;
|
|
return debounced;
|
|
}
|
|
|
|
/**
|
|
* Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`.
|
|
* (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Lang
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if `value` is an object, else `false`.
|
|
* @example
|
|
*
|
|
* _.isObject({});
|
|
* // => true
|
|
*
|
|
* _.isObject([1, 2, 3]);
|
|
* // => true
|
|
*
|
|
* _.isObject(1);
|
|
* // => false
|
|
*/
|
|
function isObject(value) {
|
|
// Avoid a V8 JIT bug in Chrome 19-20.
|
|
// See https://code.google.com/p/v8/issues/detail?id=2291 for more details.
|
|
var type = typeof value;
|
|
return !!value && (type == 'object' || type == 'function');
|
|
}
|
|
|
|
module.exports = debounce;
|
|
|
|
},{"lodash._getnative":62}]},{},[2])
|
|
//# sourceMappingURL=comicbook.js.map
|