summaryrefslogtreecommitdiff
path: root/public
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--public/js/extra.js4
-rw-r--r--public/vendor/markdown-it-imsize.js3116
-rw-r--r--public/vendor/markdown-it-mathjax.js126
-rw-r--r--public/vendor/markdown-it-regexp.js117
4 files changed, 2 insertions, 3361 deletions
diff --git a/public/js/extra.js b/public/js/extra.js
index a4eed879..61433528 100644
--- a/public/js/extra.js
+++ b/public/js/extra.js
@@ -903,7 +903,7 @@ md.use(require('markdown-it-mark'));
md.use(require('markdown-it-ins'));
md.use(require('markdown-it-sub'));
md.use(require('markdown-it-sup'));
-md.use(require('../vendor/markdown-it-mathjax'));
+md.use(require('markdown-it-mathjax'));
md.use(require('markdown-it-imsize'));
md.use(require('markdown-it-emoji'), {
@@ -980,7 +980,7 @@ md.renderer.rules.fence = function (tokens, idx, options, env, self) {
};
/* Defined regex markdown it plugins */
-require('script!../vendor/markdown-it-regexp');
+var Plugin = require('markdown-it-regexp');
//youtube
var youtubePlugin = new Plugin(
diff --git a/public/vendor/markdown-it-imsize.js b/public/vendor/markdown-it-imsize.js
deleted file mode 100644
index c0f3ca08..00000000
--- a/public/vendor/markdown-it-imsize.js
+++ /dev/null
@@ -1,3116 +0,0 @@
-//from https://github.com/tatsy/markdown-it-imsize
-var markdownitImsize =
-/******/ (function(modules) { // webpackBootstrap
-/******/ // The module cache
-/******/ var installedModules = {};
-
-/******/ // The require function
-/******/ function __webpack_require__(moduleId) {
-
-/******/ // Check if module is in cache
-/******/ if(installedModules[moduleId])
-/******/ return installedModules[moduleId].exports;
-
-/******/ // Create a new module (and put it into the cache)
-/******/ var module = installedModules[moduleId] = {
-/******/ exports: {},
-/******/ id: moduleId,
-/******/ loaded: false
-/******/ };
-
-/******/ // Execute the module function
-/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
-
-/******/ // Flag the module as loaded
-/******/ module.loaded = true;
-
-/******/ // Return the exports of the module
-/******/ return module.exports;
-/******/ }
-
-
-/******/ // expose the modules object (__webpack_modules__)
-/******/ __webpack_require__.m = modules;
-
-/******/ // expose the module cache
-/******/ __webpack_require__.c = installedModules;
-
-/******/ // __webpack_public_path__
-/******/ __webpack_require__.p = "";
-
-/******/ // Load entry module and return exports
-/******/ return __webpack_require__(0);
-/******/ })
-/************************************************************************/
-/******/ ([
-/* 0 */
-/***/ function(module, exports, __webpack_require__) {
-
- // Process ![test]( x =100x200)
- // ^^^^^^^^ this size specification
-
- 'use strict';
-
- var sizeOf = __webpack_require__(1);
-
- var parseImageSize = __webpack_require__(21);
-
- function image_with_size(md, options) {
- return function(state, silent) {
- var attrs,
- code,
- label,
- labelEnd,
- labelStart,
- pos,
- ref,
- res,
- title,
- width = '',
- height = '',
- token,
- tokens,
- start,
- href = '',
- oldPos = state.pos,
- max = state.posMax;
-
- if (state.src.charCodeAt(state.pos) !== 0x21/* ! */) { return false; }
- if (state.src.charCodeAt(state.pos + 1) !== 0x5B/* [ */) { return false; }
-
- labelStart = state.pos + 2;
- labelEnd = md.helpers.parseLinkLabel(state, state.pos + 1, false);
-
- // parser failed to find ']', so it's not a valid link
- if (labelEnd < 0) { return false; }
-
- pos = labelEnd + 1;
- if (pos < max && state.src.charCodeAt(pos) === 0x28/* ( */) {
-
- //
- // Inline link
- //
-
- // [link]( <href> "title" )
- // ^^ skipping these spaces
- pos++;
- for (; pos < max; pos++) {
- code = state.src.charCodeAt(pos);
- if (code !== 0x20 && code !== 0x0A) { break; }
- }
- if (pos >= max) { return false; }
-
- // [link]( <href> "title" )
- // ^^^^^^ parsing link destination
- start = pos;
- res = md.helpers.parseLinkDestination(state.src, pos, state.posMax);
- if (res.ok) {
- href = state.md.normalizeLink(res.str);
- if (state.md.validateLink(href)) {
- pos = res.pos;
- } else {
- href = '';
- }
- }
-
- // [link]( <href> "title" )
- // ^^ skipping these spaces
- start = pos;
- for (; pos < max; pos++) {
- code = state.src.charCodeAt(pos);
- if (code !== 0x20 && code !== 0x0A) { break; }
- }
-
- // [link]( <href> "title" )
- // ^^^^^^^ parsing link title
- res = md.helpers.parseLinkTitle(state.src, pos, state.posMax);
- if (pos < max && start !== pos && res.ok) {
- title = res.str;
- pos = res.pos;
-
- // [link]( <href> "title" )
- // ^^ skipping these spaces
- for (; pos < max; pos++) {
- code = state.src.charCodeAt(pos);
- if (code !== 0x20 && code !== 0x0A) { break; }
- }
- } else {
- title = '';
- }
-
- // [link]( <href> "title" =WxH )
- // ^^^^ parsing image size
- if (pos - 1 >= 0) {
- code = state.src.charCodeAt(pos - 1);
-
- // there must be at least one white spaces
- // between previous field and the size
- if (code === 0x20) {
- res = parseImageSize(state.src, pos, state.posMax);
- if (res.ok) {
- width = res.width;
- height = res.height;
- pos = res.pos;
-
- // [link]( <href> "title" =WxH )
- // ^^ skipping these spaces
- for (; pos < max; pos++) {
- code = state.src.charCodeAt(pos);
- if (code !== 0x20 && code !== 0x0A) { break; }
- }
- }
- }
- }
-
- if (pos >= max || state.src.charCodeAt(pos) !== 0x29/* ) */) {
- state.pos = oldPos;
- return false;
- }
- pos++;
-
- } else {
- //
- // Link reference
- //
- if (typeof state.env.references === 'undefined') { return false; }
-
- // [foo] [bar]
- // ^^ optional whitespace (can include newlines)
- for (; pos < max; pos++) {
- code = state.src.charCodeAt(pos);
- if (code !== 0x20 && code !== 0x0A) { break; }
- }
-
- if (pos < max && state.src.charCodeAt(pos) === 0x5B/* [ */) {
- start = pos + 1;
- pos = md.helpers.parseLinkLabel(state, pos);
- if (pos >= 0) {
- label = state.src.slice(start, pos++);
- } else {
- pos = labelEnd + 1;
- }
- } else {
- pos = labelEnd + 1;
- }
-
- // covers label === '' and label === undefined
- // (collapsed reference link and shortcut reference link respectively)
- if (!label) { label = state.src.slice(labelStart, labelEnd); }
-
- ref = state.env.references[md.utils.normalizeReference(label)];
- if (!ref) {
- state.pos = oldPos;
- return false;
- }
- href = ref.href;
- title = ref.title;
- }
-
- //
- // We found the end of the link, and know for a fact it's a valid link;
- // so all that's left to do is to call tokenizer.
- //
- if (!silent) {
- state.pos = labelStart;
- state.posMax = labelEnd;
-
- var newState = new state.md.inline.State(
- state.src.slice(labelStart, labelEnd),
- state.md,
- state.env,
- tokens = []
- );
- newState.md.inline.tokenize(newState);
-
- // if 'autofill' option is specified
- // and width/height are both blank,
- // they are filled automatically
- if (options) {
- if (options.autofill && width === '' && height === '') {
- try {
- var dimensions = sizeOf(href);
- width = dimensions.width;
- height = dimensions.height;
- } catch (e) { }
- }
- }
-
- token = state.push('image', 'img', 0);
- token.attrs = attrs = [ [ 'src', href ],
- [ 'alt', '' ] ];
- token.children = tokens;
- if (title) {
- attrs.push([ 'title', title ]);
- }
-
- if (width !== '') {
- attrs.push([ 'width', width ]);
- }
-
- if (height !== '') {
- attrs.push([ 'height', height ]);
- }
- }
-
- state.pos = pos;
- state.posMax = max;
- return true;
- };
- }
-
- module.exports = function imsize_plugin(md, options) {
- md.inline.ruler.before('emphasis', 'image', image_with_size(md, options));
- };
-
-
-/***/ },
-/* 1 */
-/***/ function(module, exports, __webpack_require__) {
-
- /* WEBPACK VAR INJECTION */(function(Buffer) {'use strict';
-
- var fs = __webpack_require__(6);
- var path = __webpack_require__(7);
-
- var detector = __webpack_require__(9);
- var handlers = {};
- var types = __webpack_require__(10);
-
- types.forEach(function(type) {
- handlers[type] = __webpack_require__(11)("./" + type);
- });
-
- var MaxBufferSize = 128 * 1024;
-
- function lookup(buffer, filepath) {
- var type = detector(buffer, filepath);
-
- if (type in handlers) {
- var size = handlers[type].calculate(buffer, filepath);
- if (size !== false) {
- size.type = type;
- return size;
- }
- }
-
- throw new TypeError('Unsupported file type');
- }
-
- function asyncFileToBuffer(filepath, callback) {
- fs.open(filepath, 'r', function(err0, descriptor) {
- if (err0) {
- return callback(err0);
- }
-
- var size = fs.fstatSync(descriptor).size;
- var bufferSize = Math.min(size, MaxBufferSize);
- var buffer = new Buffer(bufferSize);
- fs.read(descriptor, buffer, 0, bufferSize, 0, function(err1) {
- if (err1) {
- return callback(err1);
- }
-
- fs.close(descriptor, function(err2) {
- callback(err2, buffer);
- });
- });
- });
- }
-
- function syncFileToBuffer(filepath) {
- var descriptor = fs.openSync(filepath, 'r');
- var size = fs.fstatSync(descriptor).size;
- var bufferSize = Math.min(size, MaxBufferSize);
- var buffer = new Buffer(bufferSize);
- fs.readSync(descriptor, buffer, 0, bufferSize, 0);
- fs.closeSync(descriptor);
- return buffer;
- }
-
- /**
- * Returns the dimensions of the image file
- * @param[in] input: input image path
- * @param[in] callback(option): if specified, gets size async.
- */
- module.exports = function(input, callback) {
- if (typeof input !== 'string') {
- throw new TypeError('Input must be file name');
- }
-
- var filepath = path.resolve(input);
-
- if (typeof callback === 'function') {
- asyncFileToBuffer(filepath, function(err, buffer) {
- if (err) {
- return callback(err);
- }
-
- var dimensions;
- try {
- dimensions = lookup(buffer, filepath);
- } catch (e) {
- err = e;
- }
- callback(err, dimensions);
- });
- } else {
- var buffer = syncFileToBuffer(filepath);
- return lookup(buffer, filepath);
- }
- };
-
- /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(2).Buffer))
-
-/***/ },
-/* 2 */
-/***/ function(module, exports, __webpack_require__) {
-
- /* WEBPACK VAR INJECTION */(function(Buffer, global) {/*!
- * The buffer module from node.js, for the browser.
- *
- * @author Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
- * @license MIT
- */
- /* eslint-disable no-proto */
-
- 'use strict'
-
- var base64 = __webpack_require__(3)
- var ieee754 = __webpack_require__(4)
- var isArray = __webpack_require__(5)
-
- exports.Buffer = Buffer
- exports.SlowBuffer = SlowBuffer
- exports.INSPECT_MAX_BYTES = 50
- Buffer.poolSize = 8192 // not used by this implementation
-
- var rootParent = {}
-
- /**
- * If `Buffer.TYPED_ARRAY_SUPPORT`:
- * === true Use Uint8Array implementation (fastest)
- * === false Use Object implementation (most compatible, even IE6)
- *
- * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
- * Opera 11.6+, iOS 4.2+.
- *
- * Due to various browser bugs, sometimes the Object implementation will be used even
- * when the browser supports typed arrays.
- *
- * Note:
- *
- * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
- * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
- *
- * - Safari 5-7 lacks support for changing the `Object.prototype.constructor` property
- * on objects.
- *
- * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
- *
- * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
- * incorrect length in some situations.
-
- * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
- * get the Object implementation, which is slower but behaves correctly.
- */
- Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined
- ? global.TYPED_ARRAY_SUPPORT
- : typedArraySupport()
-
- function typedArraySupport () {
- function Bar () {}
- try {
- var arr = new Uint8Array(1)
- arr.foo = function () { return 42 }
- arr.constructor = Bar
- return arr.foo() === 42 && // typed array instances can be augmented
- arr.constructor === Bar && // constructor can be set
- typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
- arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`
- } catch (e) {
- return false
- }
- }
-
- function kMaxLength () {
- return Buffer.TYPED_ARRAY_SUPPORT
- ? 0x7fffffff
- : 0x3fffffff
- }
-
- /**
- * Class: Buffer
- * =============
- *
- * The Buffer constructor returns instances of `Uint8Array` that are augmented
- * with function properties for all the node `Buffer` API functions. We use
- * `Uint8Array` so that square bracket notation works as expected -- it returns
- * a single octet.
- *
- * By augmenting the instances, we can avoid modifying the `Uint8Array`
- * prototype.
- */
- function Buffer (arg) {
- if (!(this instanceof Buffer)) {
- // Avoid going through an ArgumentsAdaptorTrampoline in the common case.
- if (arguments.length > 1) return new Buffer(arg, arguments[1])
- return new Buffer(arg)
- }
-
- if (!Buffer.TYPED_ARRAY_SUPPORT) {
- this.length = 0
- this.parent = undefined
- }
-
- // Common case.
- if (typeof arg === 'number') {
- return fromNumber(this, arg)
- }
-
- // Slightly less common case.
- if (typeof arg === 'string') {
- return fromString(this, arg, arguments.length > 1 ? arguments[1] : 'utf8')
- }
-
- // Unusual.
- return fromObject(this, arg)
- }
-
- function fromNumber (that, length) {
- that = allocate(that, length < 0 ? 0 : checked(length) | 0)
- if (!Buffer.TYPED_ARRAY_SUPPORT) {
- for (var i = 0; i < length; i++) {
- that[i] = 0
- }
- }
- return that
- }
-
- function fromString (that, string, encoding) {
- if (typeof encoding !== 'string' || encoding === '') encoding = 'utf8'
-
- // Assumption: byteLength() return value is always < kMaxLength.
- var length = byteLength(string, encoding) | 0
- that = allocate(that, length)
-
- that.write(string, encoding)
- return that
- }
-
- function fromObject (that, object) {
- if (Buffer.isBuffer(object)) return fromBuffer(that, object)
-
- if (isArray(object)) return fromArray(that, object)
-
- if (object == null) {
- throw new TypeError('must start with number, buffer, array or string')
- }
-
- if (typeof ArrayBuffer !== 'undefined') {
- if (object.buffer instanceof ArrayBuffer) {
- return fromTypedArray(that, object)
- }
- if (object instanceof ArrayBuffer) {
- return fromArrayBuffer(that, object)
- }
- }
-
- if (object.length) return fromArrayLike(that, object)
-
- return fromJsonObject(that, object)
- }
-
- function fromBuffer (that, buffer) {
- var length = checked(buffer.length) | 0
- that = allocate(that, length)
- buffer.copy(that, 0, 0, length)
- return that
- }
-
- function fromArray (that, array) {
- var length = checked(array.length) | 0
- that = allocate(that, length)
- for (var i = 0; i < length; i += 1) {
- that[i] = array[i] & 255
- }
- return that
- }
-
- // Duplicate of fromArray() to keep fromArray() monomorphic.
- function fromTypedArray (that, array) {
- var length = checked(array.length) | 0
- that = allocate(that, length)
- // Truncating the elements is probably not what people expect from typed
- // arrays with BYTES_PER_ELEMENT > 1 but it's compatible with the behavior
- // of the old Buffer constructor.
- for (var i = 0; i < length; i += 1) {
- that[i] = array[i] & 255
- }
- return that
- }
-
- function fromArrayBuffer (that, array) {
- if (Buffer.TYPED_ARRAY_SUPPORT) {
- // Return an augmented `Uint8Array` instance, for best performance
- array.byteLength
- that = Buffer._augment(new Uint8Array(array))
- } else {
- // Fallback: Return an object instance of the Buffer class
- that = fromTypedArray(that, new Uint8Array(array))
- }
- return that
- }
-
- function fromArrayLike (that, array) {
- var length = checked(array.length) | 0
- that = allocate(that, length)
- for (var i = 0; i < length; i += 1) {
- that[i] = array[i] & 255
- }
- return that
- }
-
- // Deserialize { type: 'Buffer', data: [1,2,3,...] } into a Buffer object.
- // Returns a zero-length buffer for inputs that don't conform to the spec.
- function fromJsonObject (that, object) {
- var array
- var length = 0
-
- if (object.type === 'Buffer' && isArray(object.data)) {
- array = object.data
- length = checked(array.length) | 0
- }
- that = allocate(that, length)
-
- for (var i = 0; i < length; i += 1) {
- that[i] = array[i] & 255
- }
- return that
- }
-
- if (Buffer.TYPED_ARRAY_SUPPORT) {
- Buffer.prototype.__proto__ = Uint8Array.prototype
- Buffer.__proto__ = Uint8Array
- } else {
- // pre-set for values that may exist in the future
- Buffer.prototype.length = undefined
- Buffer.prototype.parent = undefined
- }
-
- function allocate (that, length) {
- if (Buffer.TYPED_ARRAY_SUPPORT) {
- // Return an augmented `Uint8Array` instance, for best performance
- that = Buffer._augment(new Uint8Array(length))
- that.__proto__ = Buffer.prototype
- } else {
- // Fallback: Return an object instance of the Buffer class
- that.length = length
- that._isBuffer = true
- }
-
- var fromPool = length !== 0 && length <= Buffer.poolSize >>> 1
- if (fromPool) that.parent = rootParent
-
- return that
- }
-
- function checked (length) {
- // Note: cannot use `length < kMaxLength` here because that fails when
- // length is NaN (which is otherwise coerced to zero.)
- if (length >= kMaxLength()) {
- throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
- 'size: 0x' + kMaxLength().toString(16) + ' bytes')
- }
- return length | 0
- }
-
- function SlowBuffer (subject, encoding) {
- if (!(this instanceof SlowBuffer)) return new SlowBuffer(subject, encoding)
-
- var buf = new Buffer(subject, encoding)
- delete buf.parent
- return buf
- }
-
- Buffer.isBuffer = function isBuffer (b) {
- return !!(b != null && b._isBuffer)
- }
-
- Buffer.compare = function compare (a, b) {
- if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
- throw new TypeError('Arguments must be Buffers')
- }
-
- if (a === b) return 0
-
- var x = a.length
- var y = b.length
-
- var i = 0
- var len = Math.min(x, y)
- while (i < len) {
- if (a[i] !== b[i]) break
-
- ++i
- }
-
- if (i !== len) {
- x = a[i]
- y = b[i]
- }
-
- if (x < y) return -1
- if (y < x) return 1
- return 0
- }
-
- Buffer.isEncoding = function isEncoding (encoding) {
- switch (String(encoding).toLowerCase()) {
- case 'hex':
- case 'utf8':
- case 'utf-8':
- case 'ascii':
- case 'binary':
- case 'base64':
- case 'raw':
- case 'ucs2':
- case 'ucs-2':
- case 'utf16le':
- case 'utf-16le':
- return true
- default:
- return false
- }
- }
-
- Buffer.concat = function concat (list, length) {
- if (!isArray(list)) throw new TypeError('list argument must be an Array of Buffers.')
-
- if (list.length === 0) {
- return new Buffer(0)
- }
-
- var i
- if (length === undefined) {
- length = 0
- for (i = 0; i < list.length; i++) {
- length += list[i].length
- }
- }
-
- var buf = new Buffer(length)
- var pos = 0
- for (i = 0; i < list.length; i++) {
- var item = list[i]
- item.copy(buf, pos)
- pos += item.length
- }
- return buf
- }
-
- function byteLength (string, encoding) {
- if (typeof string !== 'string') string = '' + string
-
- var len = string.length
- if (len === 0) return 0
-
- // Use a for loop to avoid recursion
- var loweredCase = false
- for (;;) {
- switch (encoding) {
- case 'ascii':
- case 'binary':
- // Deprecated
- case 'raw':
- case 'raws':
- return len
- case 'utf8':
- case 'utf-8':
- return utf8ToBytes(string).length
- case 'ucs2':
- case 'ucs-2':
- case 'utf16le':
- case 'utf-16le':
- return len * 2
- case 'hex':
- return len >>> 1
- case 'base64':
- return base64ToBytes(string).length
- default:
- if (loweredCase) return utf8ToBytes(string).length // assume utf8
- encoding = ('' + encoding).toLowerCase()
- loweredCase = true
- }
- }
- }
- Buffer.byteLength = byteLength
-
- function slowToString (encoding, start, end) {
- var loweredCase = false
-
- start = start | 0
- end = end === undefined || end === Infinity ? this.length : end | 0
-
- if (!encoding) encoding = 'utf8'
- if (start < 0) start = 0
- if (end > this.length) end = this.length
- if (end <= start) return ''
-
- while (true) {
- switch (encoding) {
- case 'hex':
- return hexSlice(this, start, end)
-
- case 'utf8':
- case 'utf-8':
- return utf8Slice(this, start, end)
-
- case 'ascii':
- return asciiSlice(this, start, end)
-
- case 'binary':
- return binarySlice(this, start, end)
-
- case 'base64':
- return base64Slice(this, start, end)
-
- case 'ucs2':
- case 'ucs-2':
- case 'utf16le':
- case 'utf-16le':
- return utf16leSlice(this, start, end)
-
- default:
- if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
- encoding = (encoding + '').toLowerCase()
- loweredCase = true
- }
- }
- }
-
- Buffer.prototype.toString = function toString () {
- var length = this.length | 0
- if (length === 0) return ''
- if (arguments.length === 0) return utf8Slice(this, 0, length)
- return slowToString.apply(this, arguments)
- }
-
- Buffer.prototype.equals = function equals (b) {
- if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
- if (this === b) return true
- return Buffer.compare(this, b) === 0
- }
-
- Buffer.prototype.inspect = function inspect () {
- var str = ''
- var max = exports.INSPECT_MAX_BYTES
- if (this.length > 0) {
- str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')
- if (this.length > max) str += ' ... '
- }
- return '<Buffer ' + str + '>'
- }
-
- Buffer.prototype.compare = function compare (b) {
- if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
- if (this === b) return 0
- return Buffer.compare(this, b)
- }
-
- Buffer.prototype.indexOf = function indexOf (val, byteOffset) {
- if (byteOffset > 0x7fffffff) byteOffset = 0x7fffffff
- else if (byteOffset < -0x80000000) byteOffset = -0x80000000
- byteOffset >>= 0
-
- if (this.length === 0) return -1
- if (byteOffset >= this.length) return -1
-
- // Negative offsets start from the end of the buffer
- if (byteOffset < 0) byteOffset = Math.max(this.length + byteOffset, 0)
-
- if (typeof val === 'string') {
- if (val.length === 0) return -1 // special case: looking for empty string always fails
- return String.prototype.indexOf.call(this, val, byteOffset)
- }
- if (Buffer.isBuffer(val)) {
- return arrayIndexOf(this, val, byteOffset)
- }
- if (typeof val === 'number') {
- if (Buffer.TYPED_ARRAY_SUPPORT && Uint8Array.prototype.indexOf === 'function') {
- return Uint8Array.prototype.indexOf.call(this, val, byteOffset)
- }
- return arrayIndexOf(this, [ val ], byteOffset)
- }
-
- function arrayIndexOf (arr, val, byteOffset) {
- var foundIndex = -1
- for (var i = 0; byteOffset + i < arr.length; i++) {
- if (arr[byteOffset + i] === val[foundIndex === -1 ? 0 : i - foundIndex]) {
- if (foundIndex === -1) foundIndex = i
- if (i - foundIndex + 1 === val.length) return byteOffset + foundIndex
- } else {
- foundIndex = -1
- }
- }
- return -1
- }
-
- throw new TypeError('val must be string, number or Buffer')
- }
-
- // `get` is deprecated
- Buffer.prototype.get = function get (offset) {
- console.log('.get() is deprecated. Access using array indexes instead.')
- return this.readUInt8(offset)
- }
-
- // `set` is deprecated
- Buffer.prototype.set = function set (v, offset) {
- console.log('.set() is deprecated. Access using array indexes instead.')
- return this.writeUInt8(v, offset)
- }
-
- function hexWrite (buf, string, offset, length) {
- offset = Number(offset) || 0
- var remaining = buf.length - offset
- if (!length) {
- length = remaining
- } else {
- length = Number(length)
- if (length > remaining) {
- length = remaining
- }
- }
-
- // must be an even number of digits
- var strLen = string.length
- if (strLen % 2 !== 0) throw new Error('Invalid hex string')
-
- if (length > strLen / 2) {
- length = strLen / 2
- }
- for (var i = 0; i < length; i++) {
- var parsed = parseInt(string.substr(i * 2, 2), 16)
- if (isNaN(parsed)) throw new Error('Invalid hex string')
- buf[offset + i] = parsed
- }
- return i
- }
-
- function utf8Write (buf, string, offset, length) {
- return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
- }
-
- function asciiWrite (buf, string, offset, length) {
- return blitBuffer(asciiToBytes(string), buf, offset, length)
- }
-
- function binaryWrite (buf, string, offset, length) {
- return asciiWrite(buf, string, offset, length)
- }
-
- function base64Write (buf, string, offset, length) {
- return blitBuffer(base64ToBytes(string), buf, offset, length)
- }
-
- function ucs2Write (buf, string, offset, length) {
- return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
- }
-
- Buffer.prototype.write = function write (string, offset, length, encoding) {
- // Buffer#write(string)
- if (offset === undefined) {
- encoding = 'utf8'
- length = this.length
- offset = 0
- // Buffer#write(string, encoding)
- } else if (length === undefined && typeof offset === 'string') {
- encoding = offset
- length = this.length
- offset = 0
- // Buffer#write(string, offset[, length][, encoding])
- } else if (isFinite(offset)) {
- offset = offset | 0
- if (isFinite(length)) {
- length = length | 0
- if (encoding === undefined) encoding = 'utf8'
- } else {
- encoding = length
- length = undefined
- }
- // legacy write(string, encoding, offset, length) - remove in v0.13
- } else {
- var swap = encoding
- encoding = offset
- offset = length | 0
- length = swap
- }
-
- var remaining = this.length - offset
- if (length === undefined || length > remaining) length = remaining
-
- if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
- throw new RangeError('attempt to write outside buffer bounds')
- }
-
- if (!encoding) encoding = 'utf8'
-
- var loweredCase = false
- for (;;) {
- switch (encoding) {
- case 'hex':
- return hexWrite(this, string, offset, length)
-
- case 'utf8':
- case 'utf-8':
- return utf8Write(this, string, offset, length)
-
- case 'ascii':
- return asciiWrite(this, string, offset, length)
-
- case 'binary':
- return binaryWrite(this, string, offset, length)
-
- case 'base64':
- // Warning: maxLength not taken into account in base64Write
- return base64Write(this, string, offset, length)
-
- case 'ucs2':
- case 'ucs-2':
- case 'utf16le':
- case 'utf-16le':
- return ucs2Write(this, string, offset, length)
-
- default:
- if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
- encoding = ('' + encoding).toLowerCase()
- loweredCase = true
- }
- }
- }
-
- Buffer.prototype.toJSON = function toJSON () {
- return {
- type: 'Buffer',
- data: Array.prototype.slice.call(this._arr || this, 0)
- }
- }
-
- function base64Slice (buf, start, end) {
- if (start === 0 && end === buf.length) {
- return base64.fromByteArray(buf)
- } else {
- return base64.fromByteArray(buf.slice(start, end))
- }
- }
-
- function utf8Slice (buf, start, end) {
- end = Math.min(buf.length, end)
- var res = []
-
- var i = start
- while (i < end) {
- var firstByte = buf[i]
- var codePoint = null
- var bytesPerSequence = (firstByte > 0xEF) ? 4
- : (firstByte > 0xDF) ? 3
- : (firstByte > 0xBF) ? 2
- : 1
-
- if (i + bytesPerSequence <= end) {
- var secondByte, thirdByte, fourthByte, tempCodePoint
-
- switch (bytesPerSequence) {
- case 1:
- if (firstByte < 0x80) {
- codePoint = firstByte
- }
- break
- case 2:
- secondByte = buf[i + 1]
- if ((secondByte & 0xC0) === 0x80) {
- tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
- if (tempCodePoint > 0x7F) {
- codePoint = tempCodePoint
- }
- }
- break
- case 3:
- secondByte = buf[i + 1]
- thirdByte = buf[i + 2]
- if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
- tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
- if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
- codePoint = tempCodePoint
- }
- }
- break
- case 4:
- secondByte = buf[i + 1]
- thirdByte = buf[i + 2]
- fourthByte = buf[i + 3]
- if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
- tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
- if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
- codePoint = tempCodePoint
- }
- }
- }
- }
-
- if (codePoint === null) {
- // we did not generate a valid codePoint so insert a
- // replacement char (U+FFFD) and advance only 1 byte
- codePoint = 0xFFFD
- bytesPerSequence = 1
- } else if (codePoint > 0xFFFF) {
- // encode to utf16 (surrogate pair dance)
- codePoint -= 0x10000
- res.push(codePoint >>> 10 & 0x3FF | 0xD800)
- codePoint = 0xDC00 | codePoint & 0x3FF
- }
-
- res.push(codePoint)
- i += bytesPerSequence
- }
-
- return decodeCodePointsArray(res)
- }
-
- // Based on http://stackoverflow.com/a/22747272/680742, the browser with
- // the lowest limit is Chrome, with 0x10000 args.
- // We go 1 magnitude less, for safety
- var MAX_ARGUMENTS_LENGTH = 0x1000
-
- function decodeCodePointsArray (codePoints) {
- var len = codePoints.length
- if (len <= MAX_ARGUMENTS_LENGTH) {
- return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
- }
-
- // Decode in chunks to avoid "call stack size exceeded".
- var res = ''
- var i = 0
- while (i < len) {
- res += String.fromCharCode.apply(
- String,
- codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
- )
- }
- return res
- }
-
- function asciiSlice (buf, start, end) {
- var ret = ''
- end = Math.min(buf.length, end)
-
- for (var i = start; i < end; i++) {
- ret += String.fromCharCode(buf[i] & 0x7F)
- }
- return ret
- }
-
- function binarySlice (buf, start, end) {
- var ret = ''
- end = Math.min(buf.length, end)
-
- for (var i = start; i < end; i++) {
- ret += String.fromCharCode(buf[i])
- }
- return ret
- }
-
- function hexSlice (buf, start, end) {
- var len = buf.length
-
- if (!start || start < 0) start = 0
- if (!end || end < 0 || end > len) end = len
-
- var out = ''
- for (var i = start; i < end; i++) {
- out += toHex(buf[i])
- }
- return out
- }
-
- function utf16leSlice (buf, start, end) {
- var bytes = buf.slice(start, end)
- var res = ''
- for (var i = 0; i < bytes.length; i += 2) {
- res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)
- }
- return res
- }
-
- Buffer.prototype.slice = function slice (start, end) {
- var len = this.length
- start = ~~start
- end = end === undefined ? len : ~~end
-
- if (start < 0) {
- start += len
- if (start < 0) start = 0
- } else if (start > len) {
- start = len
- }
-
- if (end < 0) {
- end += len
- if (end < 0) end = 0
- } else if (end > len) {
- end = len
- }
-
- if (end < start) end = start
-
- var newBuf
- if (Buffer.TYPED_ARRAY_SUPPORT) {
- newBuf = Buffer._augment(this.subarray(start, end))
- } else {
- var sliceLen = end - start
- newBuf = new Buffer(sliceLen, undefined)
- for (var i = 0; i < sliceLen; i++) {
- newBuf[i] = this[i + start]
- }
- }
-
- if (newBuf.length) newBuf.parent = this.parent || this
-
- return newBuf
- }
-
- /*
- * Need to make sure that buffer isn't trying to write out of bounds.
- */
- function checkOffset (offset, ext, length) {
- if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
- if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
- }
-
- Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
- offset = offset | 0
- byteLength = byteLength | 0
- if (!noAssert) checkOffset(offset, byteLength, this.length)
-
- var val = this[offset]
- var mul = 1
- var i = 0
- while (++i < byteLength && (mul *= 0x100)) {
- val += this[offset + i] * mul
- }
-
- return val
- }
-
- Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
- offset = offset | 0
- byteLength = byteLength | 0
- if (!noAssert) {
- checkOffset(offset, byteLength, this.length)
- }
-
- var val = this[offset + --byteLength]
- var mul = 1
- while (byteLength > 0 && (mul *= 0x100)) {
- val += this[offset + --byteLength] * mul
- }
-
- return val
- }
-
- Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
- if (!noAssert) checkOffset(offset, 1, this.length)
- return this[offset]
- }
-
- Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
- if (!noAssert) checkOffset(offset, 2, this.length)
- return this[offset] | (this[offset + 1] << 8)
- }
-
- Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
- if (!noAssert) checkOffset(offset, 2, this.length)
- return (this[offset] << 8) | this[offset + 1]
- }
-
- Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
- if (!noAssert) checkOffset(offset, 4, this.length)
-
- return ((this[offset]) |
- (this[offset + 1] << 8) |
- (this[offset + 2] << 16)) +
- (this[offset + 3] * 0x1000000)
- }
-
- Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
- if (!noAssert) checkOffset(offset, 4, this.length)
-
- return (this[offset] * 0x1000000) +
- ((this[offset + 1] << 16) |
- (this[offset + 2] << 8) |
- this[offset + 3])
- }
-
- Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
- offset = offset | 0
- byteLength = byteLength | 0
- if (!noAssert) checkOffset(offset, byteLength, this.length)
-
- var val = this[offset]
- var mul = 1
- var i = 0
- while (++i < byteLength && (mul *= 0x100)) {
- val += this[offset + i] * mul
- }
- mul *= 0x80
-
- if (val >= mul) val -= Math.pow(2, 8 * byteLength)
-
- return val
- }
-
- Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
- offset = offset | 0
- byteLength = byteLength | 0
- if (!noAssert) checkOffset(offset, byteLength, this.length)
-
- var i = byteLength
- var mul = 1
- var val = this[offset + --i]
- while (i > 0 && (mul *= 0x100)) {
- val += this[offset + --i] * mul
- }
- mul *= 0x80
-
- if (val >= mul) val -= Math.pow(2, 8 * byteLength)
-
- return val
- }
-
- Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
- if (!noAssert) checkOffset(offset, 1, this.length)
- if (!(this[offset] & 0x80)) return (this[offset])
- return ((0xff - this[offset] + 1) * -1)
- }
-
- Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
- if (!noAssert) checkOffset(offset, 2, this.length)
- var val = this[offset] | (this[offset + 1] << 8)
- return (val & 0x8000) ? val | 0xFFFF0000 : val
- }
-
- Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
- if (!noAssert) checkOffset(offset, 2, this.length)
- var val = this[offset + 1] | (this[offset] << 8)
- return (val & 0x8000) ? val | 0xFFFF0000 : val
- }
-
- Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
- if (!noAssert) checkOffset(offset, 4, this.length)
-
- return (this[offset]) |
- (this[offset + 1] << 8) |
- (this[offset + 2] << 16) |
- (this[offset + 3] << 24)
- }
-
- Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
- if (!noAssert) checkOffset(offset, 4, this.length)
-
- return (this[offset] << 24) |
- (this[offset + 1] << 16) |
- (this[offset + 2] << 8) |
- (this[offset + 3])
- }
-
- Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
- if (!noAssert) checkOffset(offset, 4, this.length)
- return ieee754.read(this, offset, true, 23, 4)
- }
-
- Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
- if (!noAssert) checkOffset(offset, 4, this.length)
- return ieee754.read(this, offset, false, 23, 4)
- }
-
- Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
- if (!noAssert) checkOffset(offset, 8, this.length)
- return ieee754.read(this, offset, true, 52, 8)
- }
-
- Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
- if (!noAssert) checkOffset(offset, 8, this.length)
- return ieee754.read(this, offset, false, 52, 8)
- }
-
- function checkInt (buf, value, offset, ext, max, min) {
- if (!Buffer.isBuffer(buf)) throw new TypeError('buffer must be a Buffer instance')
- if (value > max || value < min) throw new RangeError('value is out of bounds')
- if (offset + ext > buf.length) throw new RangeError('index out of range')
- }
-
- Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
- value = +value
- offset = offset | 0
- byteLength = byteLength | 0
- if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0)
-
- var mul = 1
- var i = 0
- this[offset] = value & 0xFF
- while (++i < byteLength && (mul *= 0x100)) {
- this[offset + i] = (value / mul) & 0xFF
- }
-
- return offset + byteLength
- }
-
- Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
- value = +value
- offset = offset | 0
- byteLength = byteLength | 0
- if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0)
-
- var i = byteLength - 1
- var mul = 1
- this[offset + i] = value & 0xFF
- while (--i >= 0 && (mul *= 0x100)) {
- this[offset + i] = (value / mul) & 0xFF
- }
-
- return offset + byteLength
- }
-
- Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
- value = +value
- offset = offset | 0
- if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
- if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
- this[offset] = (value & 0xff)
- return offset + 1
- }
-
- function objectWriteUInt16 (buf, value, offset, littleEndian) {
- if (value < 0) value = 0xffff + value + 1
- for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; i++) {
- buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
- (littleEndian ? i : 1 - i) * 8
- }
- }
-
- Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
- value = +value
- offset = offset | 0
- if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
- if (Buffer.TYPED_ARRAY_SUPPORT) {
- this[offset] = (value & 0xff)
- this[offset + 1] = (value >>> 8)
- } else {
- objectWriteUInt16(this, value, offset, true)
- }
- return offset + 2
- }
-
- Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
- value = +value
- offset = offset | 0
- if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
- if (Buffer.TYPED_ARRAY_SUPPORT) {
- this[offset] = (value >>> 8)
- this[offset + 1] = (value & 0xff)
- } else {
- objectWriteUInt16(this, value, offset, false)
- }
- return offset + 2
- }
-
- function objectWriteUInt32 (buf, value, offset, littleEndian) {
- if (value < 0) value = 0xffffffff + value + 1
- for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; i++) {
- buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
- }
- }
-
- Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
- value = +value
- offset = offset | 0
- if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
- if (Buffer.TYPED_ARRAY_SUPPORT) {
- this[offset + 3] = (value >>> 24)
- this[offset + 2] = (value >>> 16)
- this[offset + 1] = (value >>> 8)
- this[offset] = (value & 0xff)
- } else {
- objectWriteUInt32(this, value, offset, true)
- }
- return offset + 4
- }
-
- Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
- value = +value
- offset = offset | 0
- if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
- if (Buffer.TYPED_ARRAY_SUPPORT) {
- this[offset] = (value >>> 24)
- this[offset + 1] = (value >>> 16)
- this[offset + 2] = (value >>> 8)
- this[offset + 3] = (value & 0xff)
- } else {
- objectWriteUInt32(this, value, offset, false)
- }
- return offset + 4
- }
-
- Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
- value = +value
- offset = offset | 0
- if (!noAssert) {
- var limit = Math.pow(2, 8 * byteLength - 1)
-
- checkInt(this, value, offset, byteLength, limit - 1, -limit)
- }
-
- var i = 0
- var mul = 1
- var sub = value < 0 ? 1 : 0
- this[offset] = value & 0xFF
- while (++i < byteLength && (mul *= 0x100)) {
- this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
- }
-
- return offset + byteLength
- }
-
- Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
- value = +value
- offset = offset | 0
- if (!noAssert) {
- var limit = Math.pow(2, 8 * byteLength - 1)
-
- checkInt(this, value, offset, byteLength, limit - 1, -limit)
- }
-
- var i = byteLength - 1
- var mul = 1
- var sub = value < 0 ? 1 : 0
- this[offset + i] = value & 0xFF
- while (--i >= 0 && (mul *= 0x100)) {
- this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
- }
-
- return offset + byteLength
- }
-
- Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
- value = +value
- offset = offset | 0
- if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
- if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
- if (value < 0) value = 0xff + value + 1
- this[offset] = (value & 0xff)
- return offset + 1
- }
-
- Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
- value = +value
- offset = offset | 0
- if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
- if (Buffer.TYPED_ARRAY_SUPPORT) {
- this[offset] = (value & 0xff)
- this[offset + 1] = (value >>> 8)
- } else {
- objectWriteUInt16(this, value, offset, true)
- }
- return offset + 2
- }
-
- Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
- value = +value
- offset = offset | 0
- if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
- if (Buffer.TYPED_ARRAY_SUPPORT) {
- this[offset] = (value >>> 8)
- this[offset + 1] = (value & 0xff)
- } else {
- objectWriteUInt16(this, value, offset, false)
- }
- return offset + 2
- }
-
- Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
- value = +value
- offset = offset | 0
- if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
- if (Buffer.TYPED_ARRAY_SUPPORT) {
- this[offset] = (value & 0xff)
- this[offset + 1] = (value >>> 8)
- this[offset + 2] = (value >>> 16)
- this[offset + 3] = (value >>> 24)
- } else {
- objectWriteUInt32(this, value, offset, true)
- }
- return offset + 4
- }
-
- Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
- value = +value
- offset = offset | 0
- if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
- if (value < 0) value = 0xffffffff + value + 1
- if (Buffer.TYPED_ARRAY_SUPPORT) {
- this[offset] = (value >>> 24)
- this[offset + 1] = (value >>> 16)
- this[offset + 2] = (value >>> 8)
- this[offset + 3] = (value & 0xff)
- } else {
- objectWriteUInt32(this, value, offset, false)
- }
- return offset + 4
- }
-
- function checkIEEE754 (buf, value, offset, ext, max, min) {
- if (value > max || value < min) throw new RangeError('value is out of bounds')
- if (offset + ext > buf.length) throw new RangeError('index out of range')
- if (offset < 0) throw new RangeError('index out of range')
- }
-
- function writeFloat (buf, value, offset, littleEndian, noAssert) {
- if (!noAssert) {
- checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
- }
- ieee754.write(buf, value, offset, littleEndian, 23, 4)
- return offset + 4
- }
-
- Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
- return writeFloat(this, value, offset, true, noAssert)
- }
-
- Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
- return writeFloat(this, value, offset, false, noAssert)
- }
-
- function writeDouble (buf, value, offset, littleEndian, noAssert) {
- if (!noAssert) {
- checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
- }
- ieee754.write(buf, value, offset, littleEndian, 52, 8)
- return offset + 8
- }
-
- Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
- return writeDouble(this, value, offset, true, noAssert)
- }
-
- Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
- return writeDouble(this, value, offset, false, noAssert)
- }
-
- // copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
- Buffer.prototype.copy = function copy (target, targetStart, start, end) {
- if (!start) start = 0
- if (!end && end !== 0) end = this.length
- if (targetStart >= target.length) targetStart = target.length
- if (!targetStart) targetStart = 0
- if (end > 0 && end < start) end = start
-
- // Copy 0 bytes; we're done
- if (end === start) return 0
- if (target.length === 0 || this.length === 0) return 0
-
- // Fatal error conditions
- if (targetStart < 0) {
- throw new RangeError('targetStart out of bounds')
- }
- if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
- if (end < 0) throw new RangeError('sourceEnd out of bounds')
-
- // Are we oob?
- if (end > this.length) end = this.length
- if (target.length - targetStart < end - start) {
- end = target.length - targetStart + start
- }
-
- var len = end - start
- var i
-
- if (this === target && start < targetStart && targetStart < end) {
- // descending copy from end
- for (i = len - 1; i >= 0; i--) {
- target[i + targetStart] = this[i + start]
- }
- } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
- // ascending copy from start
- for (i = 0; i < len; i++) {
- target[i + targetStart] = this[i + start]
- }
- } else {
- target._set(this.subarray(start, start + len), targetStart)
- }
-
- return len
- }
-
- // fill(value, start=0, end=buffer.length)
- Buffer.prototype.fill = function fill (value, start, end) {
- if (!value) value = 0
- if (!start) start = 0
- if (!end) end = this.length
-
- if (end < start) throw new RangeError('end < start')
-
- // Fill 0 bytes; we're done
- if (end === start) return
- if (this.length === 0) return
-
- if (start < 0 || start >= this.length) throw new RangeError('start out of bounds')
- if (end < 0 || end > this.length) throw new RangeError('end out of bounds')
-
- var i
- if (typeof value === 'number') {
- for (i = start; i < end; i++) {
- this[i] = value
- }
- } else {
- var bytes = utf8ToBytes(value.toString())
- var len = bytes.length
- for (i = start; i < end; i++) {
- this[i] = bytes[i % len]
- }
- }
-
- return this
- }
-
- /**
- * Creates a new `ArrayBuffer` with the *copied* memory of the buffer instance.
- * Added in Node 0.12. Only available in browsers that support ArrayBuffer.
- */
- Buffer.prototype.toArrayBuffer = function toArrayBuffer () {
- if (typeof Uint8Array !== 'undefined') {
- if (Buffer.TYPED_ARRAY_SUPPORT) {
- return (new Buffer(this)).buffer
- } else {
- var buf = new Uint8Array(this.length)
- for (var i = 0, len = buf.length; i < len; i += 1) {
- buf[i] = this[i]
- }
- return buf.buffer
- }
- } else {
- throw new TypeError('Buffer.toArrayBuffer not supported in this browser')
- }
- }
-
- // HELPER FUNCTIONS
- // ================
-
- var BP = Buffer.prototype
-
- /**
- * Augment a Uint8Array *instance* (not the Uint8Array class!) with Buffer methods
- */
- Buffer._augment = function _augment (arr) {
- arr.constructor = Buffer
- arr._isBuffer = true
-
- // save reference to original Uint8Array set method before overwriting
- arr._set = arr.set
-
- // deprecated
- arr.get = BP.get
- arr.set = BP.set
-
- arr.write = BP.write
- arr.toString = BP.toString
- arr.toLocaleString = BP.toString
- arr.toJSON = BP.toJSON
- arr.equals = BP.equals
- arr.compare = BP.compare
- arr.indexOf = BP.indexOf
- arr.copy = BP.copy
- arr.slice = BP.slice
- arr.readUIntLE = BP.readUIntLE
- arr.readUIntBE = BP.readUIntBE
- arr.readUInt8 = BP.readUInt8
- arr.readUInt16LE = BP.readUInt16LE
- arr.readUInt16BE = BP.readUInt16BE
- arr.readUInt32LE = BP.readUInt32LE
- arr.readUInt32BE = BP.readUInt32BE
- arr.readIntLE = BP.readIntLE
- arr.readIntBE = BP.readIntBE
- arr.readInt8 = BP.readInt8
- arr.readInt16LE = BP.readInt16LE
- arr.readInt16BE = BP.readInt16BE
- arr.readInt32LE = BP.readInt32LE
- arr.readInt32BE = BP.readInt32BE
- arr.readFloatLE = BP.readFloatLE
- arr.readFloatBE = BP.readFloatBE
- arr.readDoubleLE = BP.readDoubleLE
- arr.readDoubleBE = BP.readDoubleBE
- arr.writeUInt8 = BP.writeUInt8
- arr.writeUIntLE = BP.writeUIntLE
- arr.writeUIntBE = BP.writeUIntBE
- arr.writeUInt16LE = BP.writeUInt16LE
- arr.writeUInt16BE = BP.writeUInt16BE
- arr.writeUInt32LE = BP.writeUInt32LE
- arr.writeUInt32BE = BP.writeUInt32BE
- arr.writeIntLE = BP.writeIntLE
- arr.writeIntBE = BP.writeIntBE
- arr.writeInt8 = BP.writeInt8
- arr.writeInt16LE = BP.writeInt16LE
- arr.writeInt16BE = BP.writeInt16BE
- arr.writeInt32LE = BP.writeInt32LE
- arr.writeInt32BE = BP.writeInt32BE
- arr.writeFloatLE = BP.writeFloatLE
- arr.writeFloatBE = BP.writeFloatBE
- arr.writeDoubleLE = BP.writeDoubleLE
- arr.writeDoubleBE = BP.writeDoubleBE
- arr.fill = BP.fill
- arr.inspect = BP.inspect
- arr.toArrayBuffer = BP.toArrayBuffer
-
- return arr
- }
-
- var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g
-
- function base64clean (str) {
- // Node strips out invalid characters like \n and \t from the string, base64-js does not
- str = stringtrim(str).replace(INVALID_BASE64_RE, '')
- // Node converts strings with length < 2 to ''
- if (str.length < 2) return ''
- // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
- while (str.length % 4 !== 0) {
- str = str + '='
- }
- return str
- }
-
- function stringtrim (str) {
- if (str.trim) return str.trim()
- return str.replace(/^\s+|\s+$/g, '')
- }
-
- function toHex (n) {
- if (n < 16) return '0' + n.toString(16)
- return n.toString(16)
- }
-
- function utf8ToBytes (string, units) {
- units = units || Infinity
- var codePoint
- var length = string.length
- var leadSurrogate = null
- var bytes = []
-
- for (var i = 0; i < length; i++) {
- codePoint = string.charCodeAt(i)
-
- // is surrogate component
- if (codePoint > 0xD7FF && codePoint < 0xE000) {
- // last char was a lead
- if (!leadSurrogate) {
- // no lead yet
- if (codePoint > 0xDBFF) {
- // unexpected trail
- if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
- continue
- } else if (i + 1 === length) {
- // unpaired lead
- if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
- continue
- }
-
- // valid lead
- leadSurrogate = codePoint
-
- continue
- }
-
- // 2 leads in a row
- if (codePoint < 0xDC00) {
- if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
- leadSurrogate = codePoint
- continue
- }
-
- // valid surrogate pair
- codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
- } else if (leadSurrogate) {
- // valid bmp char, but last char was a lead
- if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
- }
-
- leadSurrogate = null
-
- // encode utf8
- if (codePoint < 0x80) {
- if ((units -= 1) < 0) break
- bytes.push(codePoint)
- } else if (codePoint < 0x800) {
- if ((units -= 2) < 0) break
- bytes.push(
- codePoint >> 0x6 | 0xC0,
- codePoint & 0x3F | 0x80
- )
- } else if (codePoint < 0x10000) {
- if ((units -= 3) < 0) break
- bytes.push(
- codePoint >> 0xC | 0xE0,
- codePoint >> 0x6 & 0x3F | 0x80,
- codePoint & 0x3F | 0x80
- )
- } else if (codePoint < 0x110000) {
- if ((units -= 4) < 0) break
- bytes.push(
- codePoint >> 0x12 | 0xF0,
- codePoint >> 0xC & 0x3F | 0x80,
- codePoint >> 0x6 & 0x3F | 0x80,
- codePoint & 0x3F | 0x80
- )
- } else {
- throw new Error('Invalid code point')
- }
- }
-
- return bytes
- }
-
- function asciiToBytes (str) {
- var byteArray = []
- for (var i = 0; i < str.length; i++) {
- // Node's code seems to be doing this and not & 0x7F..
- byteArray.push(str.charCodeAt(i) & 0xFF)
- }
- return byteArray
- }
-
- function utf16leToBytes (str, units) {
- var c, hi, lo
- var byteArray = []
- for (var i = 0; i < str.length; i++) {
- if ((units -= 2) < 0) break
-
- c = str.charCodeAt(i)
- hi = c >> 8
- lo = c % 256
- byteArray.push(lo)
- byteArray.push(hi)
- }
-
- return byteArray
- }
-
- function base64ToBytes (str) {
- return base64.toByteArray(base64clean(str))
- }
-
- function blitBuffer (src, dst, offset, length) {
- for (var i = 0; i < length; i++) {
- if ((i + offset >= dst.length) || (i >= src.length)) break
- dst[i + offset] = src[i]
- }
- return i
- }
-
- /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(2).Buffer, (function() { return this; }())))
-
-/***/ },
-/* 3 */
-/***/ function(module, exports, __webpack_require__) {
-
- var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-
- ;(function (exports) {
- 'use strict';
-
- var Arr = (typeof Uint8Array !== 'undefined')
- ? Uint8Array
- : Array
-
- var PLUS = '+'.charCodeAt(0)
- var SLASH = '/'.charCodeAt(0)
- var NUMBER = '0'.charCodeAt(0)
- var LOWER = 'a'.charCodeAt(0)
- var UPPER = 'A'.charCodeAt(0)
- var PLUS_URL_SAFE = '-'.charCodeAt(0)
- var SLASH_URL_SAFE = '_'.charCodeAt(0)
-
- function decode (elt) {
- var code = elt.charCodeAt(0)
- if (code === PLUS ||
- code === PLUS_URL_SAFE)
- return 62 // '+'
- if (code === SLASH ||
- code === SLASH_URL_SAFE)
- return 63 // '/'
- if (code < NUMBER)
- return -1 //no match
- if (code < NUMBER + 10)
- return code - NUMBER + 26 + 26
- if (code < UPPER + 26)
- return code - UPPER
- if (code < LOWER + 26)
- return code - LOWER + 26
- }
-
- function b64ToByteArray (b64) {
- var i, j, l, tmp, placeHolders, arr
-
- if (b64.length % 4 > 0) {
- throw new Error('Invalid string. Length must be a multiple of 4')
- }
-
- // the number of equal signs (place holders)
- // if there are two placeholders, than the two characters before it
- // represent one byte
- // if there is only one, then the three characters before it represent 2 bytes
- // this is just a cheap hack to not do indexOf twice
- var len = b64.length
- placeHolders = '=' === b64.charAt(len - 2) ? 2 : '=' === b64.charAt(len - 1) ? 1 : 0
-
- // base64 is 4/3 + up to two characters of the original data
- arr = new Arr(b64.length * 3 / 4 - placeHolders)
-
- // if there are placeholders, only get up to the last complete 4 chars
- l = placeHolders > 0 ? b64.length - 4 : b64.length
-
- var L = 0
-
- function push (v) {
- arr[L++] = v
- }
-
- for (i = 0, j = 0; i < l; i += 4, j += 3) {
- tmp = (decode(b64.charAt(i)) << 18) | (decode(b64.charAt(i + 1)) << 12) | (decode(b64.charAt(i + 2)) << 6) | decode(b64.charAt(i + 3))
- push((tmp & 0xFF0000) >> 16)
- push((tmp & 0xFF00) >> 8)
- push(tmp & 0xFF)
- }
-
- if (placeHolders === 2) {
- tmp = (decode(b64.charAt(i)) << 2) | (decode(b64.charAt(i + 1)) >> 4)
- push(tmp & 0xFF)
- } else if (placeHolders === 1) {
- tmp = (decode(b64.charAt(i)) << 10) | (decode(b64.charAt(i + 1)) << 4) | (decode(b64.charAt(i + 2)) >> 2)
- push((tmp >> 8) & 0xFF)
- push(tmp & 0xFF)
- }
-
- return arr
- }
-
- function uint8ToBase64 (uint8) {
- var i,
- extraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes
- output = "",
- temp, length
-
- function encode (num) {
- return lookup.charAt(num)
- }
-
- function tripletToBase64 (num) {
- return encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) + encode(num >> 6 & 0x3F) + encode(num & 0x3F)
- }
-
- // go through the array every three bytes, we'll deal with trailing stuff later
- for (i = 0, length = uint8.length - extraBytes; i < length; i += 3) {
- temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])
- output += tripletToBase64(temp)
- }
-
- // pad the end with zeros, but make sure to not forget the extra bytes
- switch (extraBytes) {
- case 1:
- temp = uint8[uint8.length - 1]
- output += encode(temp >> 2)
- output += encode((temp << 4) & 0x3F)
- output += '=='
- break
- case 2:
- temp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1])
- output += encode(temp >> 10)
- output += encode((temp >> 4) & 0x3F)
- output += encode((temp << 2) & 0x3F)
- output += '='
- break
- }
-
- return output
- }
-
- exports.toByteArray = b64ToByteArray
- exports.fromByteArray = uint8ToBase64
- }( false ? (this.base64js = {}) : exports))
-
-
-/***/ },
-/* 4 */
-/***/ function(module, exports) {
-
- exports.read = function (buffer, offset, isLE, mLen, nBytes) {
- var e, m
- var eLen = nBytes * 8 - mLen - 1
- var eMax = (1 << eLen) - 1
- var eBias = eMax >> 1
- var nBits = -7
- var i = isLE ? (nBytes - 1) : 0
- var d = isLE ? -1 : 1
- var s = buffer[offset + i]
-
- i += d
-
- e = s & ((1 << (-nBits)) - 1)
- s >>= (-nBits)
- nBits += eLen
- for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}
-
- m = e & ((1 << (-nBits)) - 1)
- e >>= (-nBits)
- nBits += mLen
- for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}
-
- if (e === 0) {
- e = 1 - eBias
- } else if (e === eMax) {
- return m ? NaN : ((s ? -1 : 1) * Infinity)
- } else {
- m = m + Math.pow(2, mLen)
- e = e - eBias
- }
- return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
- }
-
- exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
- var e, m, c
- var eLen = nBytes * 8 - mLen - 1
- var eMax = (1 << eLen) - 1
- var eBias = eMax >> 1
- var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
- var i = isLE ? 0 : (nBytes - 1)
- var d = isLE ? 1 : -1
- var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0
-
- value = Math.abs(value)
-
- if (isNaN(value) || value === Infinity) {
- m = isNaN(value) ? 1 : 0
- e = eMax
- } else {
- e = Math.floor(Math.log(value) / Math.LN2)
- if (value * (c = Math.pow(2, -e)) < 1) {
- e--
- c *= 2
- }
- if (e + eBias >= 1) {
- value += rt / c
- } else {
- value += rt * Math.pow(2, 1 - eBias)
- }
- if (value * c >= 2) {
- e++
- c /= 2
- }
-
- if (e + eBias >= eMax) {
- m = 0
- e = eMax
- } else if (e + eBias >= 1) {
- m = (value * c - 1) * Math.pow(2, mLen)
- e = e + eBias
- } else {
- m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
- e = 0
- }
- }
-
- for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
-
- e = (e << mLen) | m
- eLen += mLen
- for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
-
- buffer[offset + i - d] |= s * 128
- }
-
-
-/***/ },
-/* 5 */
-/***/ function(module, exports) {
-
- var toString = {}.toString;
-
- module.exports = Array.isArray || function (arr) {
- return toString.call(arr) == '[object Array]';
- };
-
-
-/***/ },
-/* 6 */
-/***/ function(module, exports) {
-
-
-
-/***/ },
-/* 7 */
-/***/ function(module, exports, __webpack_require__) {
-
- /* WEBPACK VAR INJECTION */(function(process) {// 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.
-
- // resolves . and .. elements in a path array with directory names there
- // must be no slashes, empty elements, or device names (c:\) in the array
- // (so also no leading and trailing slashes - it does not distinguish
- // relative and absolute paths)
- function normalizeArray(parts, allowAboveRoot) {
- // if the path tries to go above the root, `up` ends up > 0
- var up = 0;
- for (var i = parts.length - 1; i >= 0; i--) {
- var last = parts[i];
- if (last === '.') {
- parts.splice(i, 1);
- } else if (last === '..') {
- parts.splice(i, 1);
- up++;
- } else if (up) {
- parts.splice(i, 1);
- up--;
- }
- }
-
- // if the path is allowed to go above the root, restore leading ..s
- if (allowAboveRoot) {
- for (; up--; up) {
- parts.unshift('..');
- }
- }
-
- return parts;
- }
-
- // Split a filename into [root, dir, basename, ext], unix version
- // 'root' is just a slash, or nothing.
- var splitPathRe =
- /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
- var splitPath = function(filename) {
- return splitPathRe.exec(filename).slice(1);
- };
-
- // path.resolve([from ...], to)
- // posix version
- exports.resolve = function() {
- var resolvedPath = '',
- resolvedAbsolute = false;
-
- for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
- var path = (i >= 0) ? arguments[i] : process.cwd();
-
- // Skip empty and invalid entries
- if (typeof path !== 'string') {
- throw new TypeError('Arguments to path.resolve must be strings');
- } else if (!path) {
- continue;
- }
-
- resolvedPath = path + '/' + resolvedPath;
- resolvedAbsolute = path.charAt(0) === '/';
- }
-
- // At this point the path should be resolved to a full absolute path, but
- // handle relative paths to be safe (might happen when process.cwd() fails)
-
- // Normalize the path
- resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {
- return !!p;
- }), !resolvedAbsolute).join('/');
-
- return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
- };
-
- // path.normalize(path)
- // posix version
- exports.normalize = function(path) {
- var isAbsolute = exports.isAbsolute(path),
- trailingSlash = substr(path, -1) === '/';
-
- // Normalize the path
- path = normalizeArray(filter(path.split('/'), function(p) {
- return !!p;
- }), !isAbsolute).join('/');
-
- if (!path && !isAbsolute) {
- path = '.';
- }
- if (path && trailingSlash) {
- path += '/';
- }
-
- return (isAbsolute ? '/' : '') + path;
- };
-
- // posix version
- exports.isAbsolute = function(path) {
- return path.charAt(0) === '/';
- };
-
- // posix version
- exports.join = function() {
- var paths = Array.prototype.slice.call(arguments, 0);
- return exports.normalize(filter(paths, function(p, index) {
- if (typeof p !== 'string') {
- throw new TypeError('Arguments to path.join must be strings');
- }
- return p;
- }).join('/'));
- };
-
-
- // path.relative(from, to)
- // posix version
- exports.relative = function(from, to) {
- from = exports.resolve(from).substr(1);
- to = exports.resolve(to).substr(1);
-
- function trim(arr) {
- var start = 0;
- for (; start < arr.length; start++) {
- if (arr[start] !== '') break;
- }
-
- var end = arr.length - 1;
- for (; end >= 0; end--) {
- if (arr[end] !== '') break;
- }
-
- if (start > end) return [];
- return arr.slice(start, end - start + 1);
- }
-
- var fromParts = trim(from.split('/'));
- var toParts = trim(to.split('/'));
-
- var length = Math.min(fromParts.length, toParts.length);
- var samePartsLength = length;
- for (var i = 0; i < length; i++) {
- if (fromParts[i] !== toParts[i]) {
- samePartsLength = i;
- break;
- }
- }
-
- var outputParts = [];
- for (var i = samePartsLength; i < fromParts.length; i++) {
- outputParts.push('..');
- }
-
- outputParts = outputParts.concat(toParts.slice(samePartsLength));
-
- return outputParts.join('/');
- };
-
- exports.sep = '/';
- exports.delimiter = ':';
-
- exports.dirname = function(path) {
- var result = splitPath(path),
- root = result[0],
- dir = result[1];
-
- if (!root && !dir) {
- // No dirname whatsoever
- return '.';
- }
-
- if (dir) {
- // It has a dirname, strip trailing slash
- dir = dir.substr(0, dir.length - 1);
- }
-
- return root + dir;
- };
-
-
- exports.basename = function(path, ext) {
- var f = splitPath(path)[2];
- // TODO: make this comparison case-insensitive on windows?
- if (ext && f.substr(-1 * ext.length) === ext) {
- f = f.substr(0, f.length - ext.length);
- }
- return f;
- };
-
-
- exports.extname = function(path) {
- return splitPath(path)[3];
- };
-
- function filter (xs, f) {
- if (xs.filter) return xs.filter(f);
- var res = [];
- for (var i = 0; i < xs.length; i++) {
- if (f(xs[i], i, xs)) res.push(xs[i]);
- }
- return res;
- }
-
- // String.prototype.substr - negative index don't work in IE8
- var substr = 'ab'.substr(-1) === 'b'
- ? function (str, start, len) { return str.substr(start, len) }
- : function (str, start, len) {
- if (start < 0) start = str.length + start;
- return str.substr(start, len);
- }
- ;
-
- /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(8)))
-
-/***/ },
-/* 8 */
-/***/ function(module, exports) {
-
- // shim for using process in browser
-
- var process = module.exports = {};
- var queue = [];
- var draining = false;
- var currentQueue;
- var queueIndex = -1;
-
- function cleanUpNextTick() {
- if (!draining || !currentQueue) {
- return;
- }
- draining = false;
- if (currentQueue.length) {
- queue = currentQueue.concat(queue);
- } else {
- queueIndex = -1;
- }
- if (queue.length) {
- drainQueue();
- }
- }
-
- function drainQueue() {
- if (draining) {
- return;
- }
- var timeout = setTimeout(cleanUpNextTick);
- draining = true;
-
- var len = queue.length;
- while(len) {
- currentQueue = queue;
- queue = [];
- while (++queueIndex < len) {
- if (currentQueue) {
- currentQueue[queueIndex].run();
- }
- }
- queueIndex = -1;
- len = queue.length;
- }
- currentQueue = null;
- draining = false;
- clearTimeout(timeout);
- }
-
- process.nextTick = function (fun) {
- var args = new Array(arguments.length - 1);
- if (arguments.length > 1) {
- for (var i = 1; i < arguments.length; i++) {
- args[i - 1] = arguments[i];
- }
- }
- queue.push(new Item(fun, args));
- if (queue.length === 1 && !draining) {
- setTimeout(drainQueue, 0);
- }
- };
-
- // v8 likes predictible objects
- function Item(fun, array) {
- this.fun = fun;
- this.array = array;
- }
- Item.prototype.run = function () {
- this.fun.apply(null, this.array);
- };
- process.title = 'browser';
- process.browser = true;
- process.env = {};
- process.argv = [];
- process.version = ''; // empty string to avoid regexp issues
- process.versions = {};
-
- function noop() {}
-
- process.on = noop;
- process.addListener = noop;
- process.once = noop;
- process.off = noop;
- process.removeListener = noop;
- process.removeAllListeners = noop;
- process.emit = noop;
-
- process.binding = function (name) {
- throw new Error('process.binding is not supported');
- };
-
- process.cwd = function () { return '/' };
- process.chdir = function (dir) {
- throw new Error('process.chdir is not supported');
- };
- process.umask = function() { return 0; };
-
-
-/***/ },
-/* 9 */
-/***/ function(module, exports, __webpack_require__) {
-
- 'use strict';
-
- var typeMap = {};
- var types = __webpack_require__(10);
-
- types.forEach(function(type) {
- typeMap[type] = __webpack_require__(11)("./" + type).detect;
- });
-
- module.exports = function(buffer, filepath) {
- var type, result;
- for (type in typeMap) {
- if (type in typeMap) {
- result = typeMap[type](buffer, filepath);
- if (result) {
- return type;
- }
- }
- }
- throw new TypeError('Unsupported type');
- };
-
-
-/***/ },
-/* 10 */
-/***/ function(module, exports) {
-
- 'use strict';
-
- module.exports = [
- 'bmp',
- 'gif',
- 'jpg',
- 'png',
- 'tiff',
- ];
-
-
-/***/ },
-/* 11 */
-/***/ function(module, exports, __webpack_require__) {
-
- var map = {
- "./bmp": 12,
- "./bmp.js": 12,
- "./gif": 13,
- "./gif.js": 13,
- "./jpg": 14,
- "./jpg.js": 14,
- "./png": 15,
- "./png.js": 15,
- "./psd": 16,
- "./psd.js": 16,
- "./svg": 17,
- "./svg.js": 17,
- "./tiff": 18,
- "./tiff.js": 18,
- "./webp": 20,
- "./webp.js": 20
- };
- function webpackContext(req) {
- return __webpack_require__(webpackContextResolve(req));
- };
- function webpackContextResolve(req) {
- return map[req] || (function() { throw new Error("Cannot find module '" + req + "'.") }());
- };
- webpackContext.keys = function webpackContextKeys() {
- return Object.keys(map);
- };
- webpackContext.resolve = webpackContextResolve;
- module.exports = webpackContext;
- webpackContext.id = 11;
-
-
-/***/ },
-/* 12 */
-/***/ function(module, exports) {
-
- 'use strict';
-
- function isBMP (buffer) {
- return ('BM' === buffer.toString('ascii', 0, 2));
- }
-
- function calculate (buffer) {
- return {
- 'width': buffer.readUInt32LE(18),
- 'height': buffer.readUInt32LE(22)
- };
- }
-
- module.exports = {
- 'detect': isBMP,
- 'calculate': calculate
- };
-
-
-/***/ },
-/* 13 */
-/***/ function(module, exports) {
-
- 'use strict';
-
- var gifRegexp = /^GIF8[7,9]a/;
- function isGIF (buffer) {
- var signature = buffer.toString('ascii', 0, 6);
- return (gifRegexp.test(signature));
- }
-
- function calculate(buffer) {
- return {
- 'width': buffer.readUInt16LE(6),
- 'height': buffer.readUInt16LE(8)
- };
- }
-
- module.exports = {
- 'detect': isGIF,
- 'calculate': calculate
- };
-
-/***/ },
-/* 14 */
-/***/ function(module, exports) {
-
- 'use strict';
-
- // NOTE: we only support baseline and progressive JPGs here
- // due to the structure of the loader class, we only get a buffer
- // with a maximum size of 4096 bytes. so if the SOF marker is outside
- // if this range we can't detect the file size correctly.
-
- // TO-DO: handle all JFIFs
- var validJFIFMarkers = {
- 'ffdb': '0001010101', // Samsung D807 JPEG
- 'ffe0': '4a46494600', // Standard JPEG
- 'ffe1': '4578696600', // Camera JPEG, with EXIF data
- 'ffe2': '4943435f50', // Canon EOS-1D JPEG
- 'ffe3': '', // Samsung D500 JPEG
- 'ffe8': '5350494646', // SPIFF JPEG
- 'ffec': '4475636b79', // Photoshop JPEG
- 'ffed': '50686f746f', // Adobe JPEG, Photoshop CMYK buffer
- 'ffee': '41646f6265' // Adobe JPEG, Unrecognised (Lightroom??)
- };
-
- var red = ['\x1B[31m', '\x1B[39m'];
- function isJPG (buffer) { //, filepath
- var SOIMarker = buffer.toString('hex', 0, 2);
- var JFIFMarker = buffer.toString('hex', 2, 4);
-
- // not a valid jpeg
- if ('ffd8' !== SOIMarker) {
- return false;
- }
-
- // TO-DO: validate the end-bytes of a jpeg file
- // use filepath, get the last bytes, check for ffd9
- var got = buffer.toString('hex', 6, 11);
- var expected = JFIFMarker && validJFIFMarkers[JFIFMarker];
- if (expected === '') {
- console.warn(
- red[0] +
- 'this looks like a unrecognised jpeg\n' +
- 'please report the issue here\n' +
- red[1],
- '\thttps://github.com/netroy/image-size/issues/new\n'
- );
- return false;
- }
- return (got === expected) || (JFIFMarker === 'ffdb');
- }
-
- function extractSize (buffer, i) {
- return {
- 'height' : buffer.readUInt16BE(i),
- 'width' : buffer.readUInt16BE(i + 2)
- };
- }
-
- function validateBuffer (buffer, i) {
- // index should be within buffer limits
- if (i > buffer.length) {
- throw new TypeError('Corrupt JPG, exceeded buffer limits');
- }
- // Every JPEG block must begin with a 0xFF
- if (buffer[i] !== 0xFF) {
- throw new TypeError('Invalid JPG, marker table corrupted');
- }
- }
-
- function calculate (buffer) {
-
- // Skip 5 chars, they are for signature
- buffer = buffer.slice(4);
-
- var i, next;
- while (buffer.length) {
- // read length of the next block
- i = buffer.readUInt16BE(0);
-
- // ensure correct format
- validateBuffer(buffer, i);
-
- // 0xFFC0 is baseline(SOF)
- // 0xFFC2 is progressive(SOF2)
- next = buffer[i + 1];
- if (next === 0xC0 || next === 0xC2) {
- return extractSize(buffer, i + 5);
- }
-
- // move to the next block
- buffer = buffer.slice(i + 2);
- }
-
- throw new TypeError('Invalid JPG, no size found');
- }
-
- module.exports = {
- 'detect': isJPG,
- 'calculate': calculate
- };
-
-
-/***/ },
-/* 15 */
-/***/ function(module, exports) {
-
- 'use strict';
-
- var pngSignature = 'PNG\r\n\x1a\n';
- function isPNG (buffer) {
- if (pngSignature === buffer.toString('ascii', 1, 8)) {
- if ('IHDR' !== buffer.toString('ascii', 12, 16)) {
- throw new TypeError('invalid png');
- }
- return true;
- }
- }
-
- function calculate (buffer) {
- return {
- 'width': buffer.readUInt32BE(16),
- 'height': buffer.readUInt32BE(20)
- };
- }
-
- module.exports = {
- 'detect': isPNG,
- 'calculate': calculate
- };
-
-
-/***/ },
-/* 16 */
-/***/ function(module, exports) {
-
- 'use strict';
-
- function isPSD (buffer) {
- return ('8BPS' === buffer.toString('ascii', 0, 4));
- }
-
- function calculate (buffer) {
- return {
- 'width': buffer.readUInt32BE(18),
- 'height': buffer.readUInt32BE(14)
- };
- }
-
- module.exports = {
- 'detect': isPSD,
- 'calculate': calculate
- };
-
-
-/***/ },
-/* 17 */
-/***/ function(module, exports) {
-
- 'use strict';
-
- var svgReg = /<svg[^>]+[^>]*>/;
- function isSVG (buffer) {
- return svgReg.test(buffer);
- }
-
- var extractorRegExps = {
- 'root': /<svg [^>]+>/,
- 'width': /(^|\s)width\s*=\s*"(.+?)"/i,
- 'height': /(^|\s)height\s*=\s*"(.+?)"/i,
- 'viewbox': /(^|\s)viewbox\s*=\s*"(.+?)"/i
- };
-
- function getRatio (viewbox) {
- var ratio = 1;
- if (viewbox && viewbox[2]) {
- var dim = viewbox[2].split(/\s/g);
- if (dim.length === 4) {
- dim = dim.map(function (i) {
- return parseInt(i, 10);
- });
- ratio = (dim[2] - dim[0]) / (dim[3] - dim[1]);
- }
- }
- return ratio;
- }
-
- function parse (buffer) {
- var body = buffer.toString().replace(/[\r\n\s]+/g, ' ');
- var section = body.match(extractorRegExps.root);
- var root = section && section[0];
- if (root) {
- var width = root.match(extractorRegExps.width);
- var height = root.match(extractorRegExps.height);
- var viewbox = root.match(extractorRegExps.viewbox);
- var ratio = getRatio(viewbox);
- return {
- 'width': parseInt(width && width[2], 10) || 0,
- 'height': parseInt(height && height[2], 10) || 0,
- 'ratio': ratio
- };
- }
- }
-
- function calculate (buffer) {
-
- var parsed = parse(buffer);
- var width = parsed.width;
- var height = parsed.height;
- var ratio = parsed.ratio;
-
- if (width && height) {
- return { 'width': width, 'height': height };
- } else {
- if (width) {
- return { 'width': width, 'height': Math.floor(width / ratio) };
- } else if (height) {
- return { 'width': Math.floor(height * ratio), 'height': height };
- } else {
- throw new TypeError('invalid svg');
- }
- }
- }
-
- module.exports = {
- 'detect': isSVG,
- 'calculate': calculate
- };
-
-
-/***/ },
-/* 18 */
-/***/ function(module, exports, __webpack_require__) {
-
- /* WEBPACK VAR INJECTION */(function(Buffer) {'use strict';
-
- // based on http://www.compix.com/fileformattif.htm
- // TO-DO: support big-endian as well
-
- var fs = __webpack_require__(6);
- var readUInt = __webpack_require__(19);
-
- function isTIFF (buffer) {
- var hex4 = buffer.toString('hex', 0, 4);
- return ('49492a00' === hex4 || '4d4d002a' === hex4);
- }
-
- // Read IFD (image-file-directory) into a buffer
- function readIFD (buffer, filepath, isBigEndian) {
-
- var ifdOffset = readUInt(buffer, 32, 4, isBigEndian);
-
- // read only till the end of the file
- var bufferSize = 1024;
- var fileSize = fs.statSync(filepath).size;
- if (ifdOffset + bufferSize > fileSize) {
- bufferSize = fileSize - ifdOffset - 10;
- }
-
- // populate the buffer
- var endBuffer = new Buffer(bufferSize);
- var descriptor = fs.openSync(filepath, 'r');
- fs.readSync(descriptor, endBuffer, 0, bufferSize, ifdOffset);
-
- // var ifdLength = readUInt(endBuffer, 16, 0, isBigEndian);
- var ifdBuffer = endBuffer.slice(2); //, 2 + 12 * ifdLength);
- return ifdBuffer;
- }
-
- // TIFF values seem to be messed up on Big-Endian, this helps
- function readValue (buffer, isBigEndian) {
- var low = readUInt(buffer, 16, 8, isBigEndian);
- var high = readUInt(buffer, 16, 10, isBigEndian);
- return (high << 16) + low;
- }
-
- // move to the next tag
- function nextTag (buffer) {
- if (buffer.length > 24) {
- return buffer.slice(12);
- }
- }
-
- // Extract IFD tags from TIFF metadata
- function extractTags (buffer, isBigEndian) {
- var tags = {};
- var code, type, length;
-
- while (buffer && buffer.length) {
- code = readUInt(buffer, 16, 0, isBigEndian);
- type = readUInt(buffer, 16, 2, isBigEndian);
- length = readUInt(buffer, 32, 4, isBigEndian);
-
- // 0 means end of IFD
- if (code === 0) {
- break;
- } else {
- // 256 is width, 257 is height
- // if (code === 256 || code === 257) {
- if (length === 1 && type === 3) {
- tags[code] = readValue(buffer, isBigEndian);
- }
-
- // move to the next tag
- buffer = nextTag(buffer);
- }
- }
- return tags;
- }
-
- // Test if the TIFF is Big Endian or Little Endian
- function determineEndianness (buffer) {
- var signature = buffer.toString('ascii', 0, 2);
- if ('II' === signature) {
- return 'LE';
- } else if ('MM' === signature) {
- return 'BE';
- }
- }
-
- function calculate (buffer, filepath) {
-
- if (!filepath) {
- throw new TypeError('Tiff doesn\'t support buffer');
- }
-
- // Determine BE/LE
- var isBigEndian = determineEndianness(buffer) === 'BE';
-
- // read the IFD
- var ifdBuffer = readIFD(buffer, filepath, isBigEndian);
-
- // extract the tags from the IFD
- var tags = extractTags(ifdBuffer, isBigEndian);
-
- var width = tags[256];
- var height = tags[257];
-
- if (!width || !height) {
- throw new TypeError('Invalid Tiff, missing tags');
- }
-
- return {
- 'width': width,
- 'height': height
- };
- }
-
- module.exports = {
- 'detect': isTIFF,
- 'calculate': calculate
- };
-
- /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(2).Buffer))
-
-/***/ },
-/* 19 */
-/***/ function(module, exports) {
-
- 'use strict';
-
- module.exports = function(buffer, bits, offset, isBigEndian) {
- offset = offset || 0;
- var endian = !!isBigEndian ? 'BE' : 'LE';
- var method = buffer['readUInt' + bits + endian];
- return method.call(buffer, offset);
- }
-
-
-/***/ },
-/* 20 */
-/***/ function(module, exports) {
-
- 'use strict';
-
- // based on https://developers.google.com/speed/webp/docs/riff_container
-
- function isWebP (buffer) {
- var riffHeader = 'RIFF' === buffer.toString('ascii', 0, 4);
- var webpHeader = 'WEBP' === buffer.toString('ascii', 8, 12);
- var vp8Header = 'VP8' === buffer.toString('ascii', 12, 15);
- return (riffHeader && webpHeader && vp8Header);
- }
-
- function calculate (buffer) {
-
- var chunkHeader = buffer.toString('ascii', 12, 16);
- buffer = buffer.slice(20, 30);
-
- // Lossless webp stream signature
- if (chunkHeader === 'VP8 ' && buffer[0] !== 0x2f) {
- return calculateLossy(buffer);
- }
-
- // Lossy webp stream signature
- var signature = buffer.toString('hex', 3, 6);
- if (chunkHeader === 'VP8L' && signature !== '9d012a') {
- return calculateLossless(buffer);
- }
-
- return false;
- }
-
- function calculateLossless (buffer) {
- return {
- 'width': 1 + (((buffer[2] & 0x3F) << 8) | buffer[1]),
- 'height': 1 + (((buffer[4] & 0xF) << 10) | (buffer[3] << 2) |
- ((buffer[2] & 0xC0) >> 6))
- };
- }
-
- function calculateLossy (buffer) {
- // `& 0x3fff` returns the last 14 bits
- // TO-DO: include webp scaling in the calculations
- return {
- 'width': buffer.readInt16LE(6) & 0x3fff,
- 'height': buffer.readInt16LE(8) & 0x3fff
- };
- }
-
- module.exports = {
- 'detect': isWebP,
- 'calculate': calculate
- };
-
-
-/***/ },
-/* 21 */
-/***/ function(module, exports) {
-
- // Parse image size
- //
- 'use strict';
-
- function parseNextNumber(str, pos, max) {
- var code,
- start = pos,
- result = {
- ok: false,
- pos: pos,
- value: ''
- };
-
- code = str.charCodeAt(pos);
-
- while (pos < max && (code >= 0x30 /* 0 */ && code <= 0x39 /* 9 */) || code === 0x25 /* % */) {
- code = str.charCodeAt(++pos);
- }
-
- result.ok = true;
- result.pos = pos;
- result.value = str.slice(start, pos);
-
- return result;
- }
-
- module.exports = function parseImageSize(str, pos, max) {
- var code,
- result = {
- ok: false,
- pos: 0,
- width: '',
- height: ''
- };
-
- if (pos >= max) { return result; }
-
- code = str.charCodeAt(pos);
-
- if (code !== 0x3d /* = */) { return result; }
-
- pos++;
-
- // size must follow = without any white spaces as follows
- // (1) =300x200
- // (2) =300x
- // (3) =x200
- code = str.charCodeAt(pos);
- if (code !== 0x78 /* x */ && (code < 0x30 || code > 0x39) /* [0-9] */) {
- return result;
- }
-
- // parse width
- var resultW = parseNextNumber(str, pos, max);
- pos = resultW.pos;
-
- // next charactor must be 'x'
- code = str.charCodeAt(pos);
- if (code !== 0x78 /* x */) { return result; }
-
- pos++;
-
- // parse height
- var resultH = parseNextNumber(str, pos, max);
- pos = resultH.pos;
-
- result.width = resultW.value;
- result.height = resultH.value;
- result.pos = pos;
- result.ok = true;
- return result;
- };
-
-
-/***/ }
-/******/ ]); \ No newline at end of file
diff --git a/public/vendor/markdown-it-mathjax.js b/public/vendor/markdown-it-mathjax.js
deleted file mode 100644
index 299e483b..00000000
--- a/public/vendor/markdown-it-mathjax.js
+++ /dev/null
@@ -1,126 +0,0 @@
-// modified from https://github.com/classeur/markdown-it-mathjax
-
-(function(root, factory) {
- if (typeof exports === 'object') {
- module.exports = factory()
- } else {
- root.markdownitMathjax = factory()
- }
-})(this, function() {
- function math(state, silent) {
- if (state.md.meta.mathjax === false) {
- return false
- }
- var startMathPos = state.pos
- if (state.src.charCodeAt(startMathPos) !== 0x5C /* \ */) {
- return false
- }
- var match = state.src.slice(++startMathPos).match(/^(?:\\\[|\\\(|begin\{([^}]*)\})/)
- if (!match) {
- return false
- }
- startMathPos += match[0].length
- var type, endMarker, includeMarkers
- if (match[0] === '\\[') {
- type = 'display_math'
- endMarker = '\\\\]'
- } else if (match[0] === '\\(') {
- type = 'inline_math'
- endMarker = '\\\\)'
- } else if (match[1]) {
- type = 'math'
- endMarker = '\\end{' + match[1] + '}'
- includeMarkers = true
- }
- var endMarkerPos = state.src.indexOf(endMarker, startMathPos)
- if (endMarkerPos === -1) {
- return false
- }
- var nextPos = endMarkerPos + endMarker.length
- if (!silent) {
- var token = state.push(type + '_open', 'span', 1);
- token.attrs = [ ['class', 'mathjax raw'] ];
- token = state.push(type, '', 0);
- token.content = includeMarkers ?
- state.src.slice(state.pos, nextPos) : state.src.slice(startMathPos, endMarkerPos)
- token = state.push(type + '_close', 'span', -1);
- }
- state.pos = nextPos
- return true
- }
-
- function texMath(state, silent) {
- if (state.md.meta.mathjax === false) {
- return false
- }
- var startMathPos = state.pos
- if (state.src.charCodeAt(startMathPos) !== 0x24 /* $ */) {
- return false
- }
-
- // Parse tex math according to http://pandoc.org/README.html#math
- var endMarker = '$'
- var afterStartMarker = state.src.charCodeAt(++startMathPos)
- if (afterStartMarker === 0x24 /* $ */) {
- endMarker = '$$'
- if (state.src.charCodeAt(++startMathPos) === 0x24 /* $ */) {
- // 3 markers are too much
- return false
- }
- } else {
- // Skip if opening $ is succeeded by a space character
- if (afterStartMarker === 0x20 /* space */ || afterStartMarker === 0x09 /* \t */ || afterStartMarker === 0x0a /* \n */) {
- return false
- }
- }
- var endMarkerPos = state.src.indexOf(endMarker, startMathPos)
- if (endMarkerPos === -1) {
- return false
- }
- if (state.src.charCodeAt(endMarkerPos - 1) === 0x5C /* \ */) {
- return false
- }
- var nextPos = endMarkerPos + endMarker.length
- if (endMarker.length === 1) {
- // Skip if $ is preceded by a space character
- var beforeEndMarker = state.src.charCodeAt(endMarkerPos - 1)
- if (beforeEndMarker === 0x20 /* space */ || beforeEndMarker === 0x09 /* \t */ || beforeEndMarker === 0x0a /* \n */) {
- return false
- }
- // Skip if closing $ is succeeded by a digit (eg $5 $10 ...)
- var suffix = state.src.charCodeAt(nextPos)
- if (suffix >= 0x30 && suffix < 0x3A) {
- return false
- }
- }
-
- if (!silent) {
- var type = endMarker.length === 1 ? 'inline_math' : 'display_math';
- var token = state.push(type + '_open', 'span', 1)
- token.attrs = [ ['class', 'mathjax raw'] ]
- token = state.push(type, '', 0);
- token.content = state.src.slice(startMathPos, endMarkerPos);
- token = state.push(type + '_close', 'span', -1);
- }
- state.pos = nextPos
- return true
- }
-
- function escapeHtml(html) {
- return html.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/\u00a0/g, ' ')
- }
-
- return function(md) {
- md.inline.ruler.before('escape', 'math', math)
- md.inline.ruler.push('texMath', texMath)
- md.renderer.rules.math = function(tokens, idx) {
- return escapeHtml(tokens[idx].content)
- }
- md.renderer.rules.inline_math = function(tokens, idx) {
- return '\\(' + escapeHtml(tokens[idx].content) + '\\)'
- }
- md.renderer.rules.display_math = function(tokens, idx) {
- return '\\[' + escapeHtml(tokens[idx].content) + '\\]'
- }
- }
-})
diff --git a/public/vendor/markdown-it-regexp.js b/public/vendor/markdown-it-regexp.js
deleted file mode 100644
index 04dbdbce..00000000
--- a/public/vendor/markdown-it-regexp.js
+++ /dev/null
@@ -1,117 +0,0 @@
-/*!
- * markdown-it-regexp
- * Copyright (c) 2014 Alex Kocharin
- * MIT Licensed
- */
-
-var inherits = function(ctor, superCtor) {
- ctor.super_ = superCtor;
- ctor.prototype = Object.create(superCtor.prototype, {
- constructor: {
- value: ctor,
- enumerable: false,
- writable: true,
- configurable: true
- }
- });
-};
-
-/**
- * Escape special characters in the given string of html.
- *
- * Borrowed from escape-html component, MIT-licensed
- */
-var stuff = {};
-stuff.escape = function(html) {
- return String(html)
- .replace(/&/g, '&amp;')
- .replace(/"/g, '&quot;')
- .replace(/'/g, '&#39;')
- .replace(/</g, '&lt;')
- .replace(/>/g, '&gt;')
-}
-
-Object.setPrototypeOf = Object.setPrototypeOf || function (obj, proto) {
- if (!isIE9()) {
- obj.__proto__ = proto;
- } else {
- /** IE9 fix - copy object methods from the protype to the new object **/
- for (var prop in proto) {
- obj[prop] = proto[prop];
- }
- }
-
- return obj;
-};
-
-var isIE9 = function() {
- return navigator.appVersion.indexOf("MSIE") > 0;
-};
-
-/**
- * Counter for multi usage.
- */
-var counter = 0
-
-/**
- * Constructor function
- */
-
-function Plugin(regexp, replacer) {
- // return value should be a callable function
- // with strictly defined options passed by markdown-it
- var self = function (md, options) {
- self.options = options
- self.init(md)
- }
-
- // initialize plugin object
- Object.setPrototypeOf(self, Plugin.prototype)
-
- // clone regexp with all the flags
- var flags = (regexp.global ? 'g' : '')
- + (regexp.multiline ? 'm' : '')
- + (regexp.ignoreCase ? 'i' : '')
-
- self.regexp = RegExp('^' + regexp.source, flags)
-
- // copy init options
- self.replacer = replacer
-
- // this plugin can be inserted multiple times,
- // so we're generating unique name for it
- self.id = 'regexp-' + counter
- counter++
-
- return self
-}
-
-inherits(Plugin, Function)
-
-// function that registers plugin with markdown-it
-Plugin.prototype.init = function (md) {
- md.inline.ruler.push(this.id, this.parse.bind(this))
-
- md.renderer.rules[this.id] = this.render.bind(this)
-}
-
-Plugin.prototype.parse = function (state, silent) {
- // slowwww... maybe use an advanced regexp engine for this
- var match = this.regexp.exec(state.src.slice(state.pos))
- if (!match) return false
-
- // valid match found, now we need to advance cursor
- state.pos += match[0].length
-
- // don't insert any tokens in silent mode
- if (silent) return true
-
- var token = state.push(this.id, '', 0)
- token.meta = { match: match }
-
- return true
-}
-
-Plugin.prototype.render = function (tokens, id, options, env) {
- return this.replacer(tokens[id].meta.match, stuff)
-}
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-27 11:36:53 +0000