module.exports = /******/ (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] = { /******/ i: moduleId, /******/ l: false, /******/ exports: {} /******/ }; /******/ /******/ // Execute the module function /******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); /******/ /******/ // Flag the module as loaded /******/ module.l = 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; /******/ /******/ // define getter function for harmony exports /******/ __webpack_require__.d = function(exports, name, getter) { /******/ if(!__webpack_require__.o(exports, name)) { /******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); /******/ } /******/ }; /******/ /******/ // define __esModule on exports /******/ __webpack_require__.r = function(exports) { /******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { /******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); /******/ } /******/ Object.defineProperty(exports, '__esModule', { value: true }); /******/ }; /******/ /******/ // create a fake namespace object /******/ // mode & 1: value is a module id, require it /******/ // mode & 2: merge all properties of value into the ns /******/ // mode & 4: return value when already ns object /******/ // mode & 8|1: behave like require /******/ __webpack_require__.t = function(value, mode) { /******/ if(mode & 1) value = __webpack_require__(value); /******/ if(mode & 8) return value; /******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; /******/ var ns = Object.create(null); /******/ __webpack_require__.r(ns); /******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); /******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); /******/ return ns; /******/ }; /******/ /******/ // getDefaultExport function for compatibility with non-harmony modules /******/ __webpack_require__.n = function(module) { /******/ var getter = module && module.__esModule ? /******/ function getDefault() { return module['default']; } : /******/ function getModuleExports() { return module; }; /******/ __webpack_require__.d(getter, 'a', getter); /******/ return getter; /******/ }; /******/ /******/ // Object.prototype.hasOwnProperty.call /******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; /******/ /******/ // __webpack_public_path__ /******/ __webpack_require__.p = ""; /******/ /******/ /******/ // Load entry module and return exports /******/ return __webpack_require__(__webpack_require__.s = 95); /******/ }) /************************************************************************/ /******/ ([ /* 0 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var wrapped = __webpack_require__(310) module.exports = factory function factory(id, rule) { var parts = id.split(':') var source = parts[0] var ruleId = parts[1] var fn = wrapped(rule) /* istanbul ignore if - possibly useful if externalised later. */ if (!ruleId) { ruleId = source source = null } attacher.displayName = id return attacher function attacher(raw) { var config = coerce(ruleId, raw) var severity = config[0] var options = config[1] var fatal = severity === 2 return severity ? transformer : undefined function transformer(tree, file, next) { var index = file.messages.length fn(tree, file, options, done) function done(err) { var messages = file.messages var message /* Add the error, if not already properly added. */ /* istanbul ignore if - only happens for incorrect plugins */ if (err && messages.indexOf(err) === -1) { try { file.fail(err) } catch (err) {} } while (index < messages.length) { message = messages[index] message.ruleId = ruleId message.source = source message.fatal = fatal index++ } next() } } } } /* Coerce a value to a severity--options tuple. */ function coerce(name, value) { var def = 1 var result var level /* istanbul ignore if - Handled by unified in v6.0.0 */ if (typeof value === 'boolean') { result = [value] } else if (value == null) { result = [def] } else if ( typeof value === 'object' && (typeof value[0] === 'number' || typeof value[0] === 'boolean' || typeof value[0] === 'string') ) { result = value.concat() } else { result = [1, value] } level = result[0] if (typeof level === 'boolean') { level = level ? 1 : 0 } else if (typeof level === 'string') { if (level === 'off') { level = 0 } else if (level === 'on' || level === 'warn') { level = 1 } else if (level === 'error') { level = 2 } else { level = 1 result = [level, result] } } if (level < 0 || level > 2) { throw new Error( 'Invalid severity `' + level + '` for `' + name + '`, ' + 'expected 0, 1, or 2' ) } result[0] = level return result } /***/ }), /* 1 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = visit var visitParents = __webpack_require__(221) var CONTINUE = visitParents.CONTINUE var SKIP = visitParents.SKIP var EXIT = visitParents.EXIT visit.CONTINUE = CONTINUE visit.SKIP = SKIP visit.EXIT = EXIT function visit(tree, test, visitor, reverse) { if (typeof test === 'function' && typeof visitor !== 'function') { reverse = visitor visitor = test test = null } visitParents(tree, test, overload, reverse) function overload(node, parents) { var parent = parents[parents.length - 1] var index = parent ? parent.children.indexOf(node) : null return visitor(node, index, parent) } } /***/ }), /* 2 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /* Expose. */ module.exports = generated /* Detect if a node was available in the original document. */ function generated(node) { var position = optional(optional(node).position) var start = optional(position.start) var end = optional(position.end) return !start.line || !start.column || !end.line || !end.column } /* Return `value` if it’s an object, an empty object * otherwise. */ function optional(value) { return value && typeof value === 'object' ? value : {} } /***/ }), /* 3 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /* Expose. */ var position = exports position.start = factory('start') position.end = factory('end') /* Factory to get a `type` point in the positional info of a node. */ function factory(type) { point.displayName = type return point /* Get a point in `node.position` at a bound `type`. */ function point(node) { var point = (node && node.position && node.position[type]) || {} return { line: point.line || null, column: point.column || null, offset: isNaN(point.offset) ? null : point.offset } } } /***/ }), /* 4 */ /***/ (function(module, exports) { module.exports = require("path"); /***/ }), /* 5 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var YAMLException = __webpack_require__(20); var TYPE_CONSTRUCTOR_OPTIONS = [ 'kind', 'resolve', 'construct', 'instanceOf', 'predicate', 'represent', 'defaultStyle', 'styleAliases' ]; var YAML_NODE_KINDS = [ 'scalar', 'sequence', 'mapping' ]; function compileStyleAliases(map) { var result = {}; if (map !== null) { Object.keys(map).forEach(function (style) { map[style].forEach(function (alias) { result[String(alias)] = style; }); }); } return result; } function Type(tag, options) { options = options || {}; Object.keys(options).forEach(function (name) { if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) { throw new YAMLException('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.'); } }); // TODO: Add tag format check. this.tag = tag; this.kind = options['kind'] || null; this.resolve = options['resolve'] || function () { return true; }; this.construct = options['construct'] || function (data) { return data; }; this.instanceOf = options['instanceOf'] || null; this.predicate = options['predicate'] || null; this.represent = options['represent'] || null; this.defaultStyle = options['defaultStyle'] || null; this.styleAliases = compileStyleAliases(options['styleAliases'] || null); if (YAML_NODE_KINDS.indexOf(this.kind) === -1) { throw new YAMLException('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.'); } } module.exports = Type; /***/ }), /* 6 */ /***/ (function(module, exports) { module.exports = require("fs"); /***/ }), /* 7 */ /***/ (function(module, exports) { module.exports = extend var hasOwnProperty = Object.prototype.hasOwnProperty; function extend() { var target = {} for (var i = 0; i < arguments.length; i++) { var source = arguments[i] for (var key in source) { if (hasOwnProperty.call(source, key)) { target[key] = source[key] } } } return target } /***/ }), /* 8 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = whitespace var fromCode = String.fromCharCode var re = /\s/ /* Check if the given character code, or the character * code at the first character, is a whitespace character. */ function whitespace(character) { return re.test( typeof character === 'number' ? fromCode(character) : character.charAt(0) ) } /***/ }), /* 9 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * Detect Electron renderer / nwjs process, which is node, but we should * treat as a browser. */ if (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) { module.exports = __webpack_require__(126); } else { module.exports = __webpack_require__(128); } /***/ }), /* 10 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /*! * repeat-string * * Copyright (c) 2014-2015, Jon Schlinkert. * Licensed under the MIT License. */ /** * Results cache */ var res = ''; var cache; /** * Expose `repeat` */ module.exports = repeat; /** * Repeat the given `string` the specified `number` * of times. * * **Example:** * * ```js * var repeat = require('repeat-string'); * repeat('A', 5); * //=> AAAAA * ``` * * @param {String} `string` The string to repeat * @param {Number} `number` The number of times to repeat the string * @return {String} Repeated string * @api public */ function repeat(str, num) { if (typeof str !== 'string') { throw new TypeError('expected a string'); } // cover common, quick use cases if (num === 1) return str; if (num === 2) return str + str; var max = str.length * num; if (cache !== str || typeof cache === 'undefined') { cache = str; res = ''; } else if (res.length >= max) { return res.substr(0, max); } while (max > res.length && num > 1) { if (num & 1) { res += str; } num >>= 1; str += str; } res += str; res = res.substr(0, max); return res; } /***/ }), /* 11 */ /***/ (function(module, exports) { module.exports = require("util"); /***/ }), /* 12 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = statistics /* Get stats for a file, list of files, or list of messages. */ function statistics(files) { var result = {true: 0, false: 0, null: 0} count(files) return { fatal: result.true, nonfatal: result.false + result.null, warn: result.false, info: result.null, total: result.true + result.false + result.null } function count(value) { if (value) { if (value[0] && value[0].messages) { /* Multiple vfiles */ countInAll(value) } else { /* One vfile / messages */ countAll(value.messages || value) } } } function countInAll(files) { var length = files.length var index = -1 while (++index < length) { count(files[index].messages) } } function countAll(messages) { var length = messages.length var index = -1 var fatal while (++index < length) { fatal = messages[index].fatal result[fatal === null || fatal === undefined ? null : Boolean(fatal)]++ } } } /***/ }), /* 13 */ /***/ (function(module, exports, __webpack_require__) { try { var util = __webpack_require__(11); if (typeof util.inherits !== 'function') throw ''; module.exports = util.inherits; } catch (e) { module.exports = __webpack_require__(152); } /***/ }), /* 14 */ /***/ (function(module, exports) { exports = module.exports = trim; function trim(str){ return str.replace(/^\s*|\s*$/g, ''); } exports.left = function(str){ return str.replace(/^\s*/, ''); }; exports.right = function(str){ return str.replace(/\s*$/, ''); }; /***/ }), /* 15 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; function isNothing(subject) { return (typeof subject === 'undefined') || (subject === null); } function isObject(subject) { return (typeof subject === 'object') && (subject !== null); } function toArray(sequence) { if (Array.isArray(sequence)) return sequence; else if (isNothing(sequence)) return []; return [ sequence ]; } function extend(target, source) { var index, length, key, sourceKeys; if (source) { sourceKeys = Object.keys(source); for (index = 0, length = sourceKeys.length; index < length; index += 1) { key = sourceKeys[index]; target[key] = source[key]; } } return target; } function repeat(string, count) { var result = '', cycle; for (cycle = 0; cycle < count; cycle += 1) { result += string; } return result; } function isNegativeZero(number) { return (number === 0) && (Number.NEGATIVE_INFINITY === 1 / number); } module.exports.isNothing = isNothing; module.exports.isObject = isObject; module.exports.toArray = toArray; module.exports.repeat = repeat; module.exports.isNegativeZero = isNegativeZero; module.exports.extend = extend; /***/ }), /* 16 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /*eslint-disable max-len*/ var common = __webpack_require__(15); var YAMLException = __webpack_require__(20); var Type = __webpack_require__(5); function compileList(schema, name, result) { var exclude = []; schema.include.forEach(function (includedSchema) { result = compileList(includedSchema, name, result); }); schema[name].forEach(function (currentType) { result.forEach(function (previousType, previousIndex) { if (previousType.tag === currentType.tag && previousType.kind === currentType.kind) { exclude.push(previousIndex); } }); result.push(currentType); }); return result.filter(function (type, index) { return exclude.indexOf(index) === -1; }); } function compileMap(/* lists... */) { var result = { scalar: {}, sequence: {}, mapping: {}, fallback: {} }, index, length; function collectType(type) { result[type.kind][type.tag] = result['fallback'][type.tag] = type; } for (index = 0, length = arguments.length; index < length; index += 1) { arguments[index].forEach(collectType); } return result; } function Schema(definition) { this.include = definition.include || []; this.implicit = definition.implicit || []; this.explicit = definition.explicit || []; this.implicit.forEach(function (type) { if (type.loadKind && type.loadKind !== 'scalar') { throw new YAMLException('There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.'); } }); this.compiledImplicit = compileList(this, 'implicit', []); this.compiledExplicit = compileList(this, 'explicit', []); this.compiledTypeMap = compileMap(this.compiledImplicit, this.compiledExplicit); } Schema.DEFAULT = null; Schema.create = function createSchema() { var schemas, types; switch (arguments.length) { case 1: schemas = Schema.DEFAULT; types = arguments[0]; break; case 2: schemas = arguments[0]; types = arguments[1]; break; default: throw new YAMLException('Wrong number of arguments for Schema.create function'); } schemas = common.toArray(schemas); types = common.toArray(types); if (!schemas.every(function (schema) { return schema instanceof Schema; })) { throw new YAMLException('Specified list of super schemas (or a single Schema object) contains a non-Schema object.'); } if (!types.every(function (type) { return type instanceof Type; })) { throw new YAMLException('Specified list of YAML types (or a single Type object) contains a non-Type object.'); } return new Schema({ include: schemas, explicit: types }); }; module.exports = Schema; /***/ }), /* 17 */ /***/ (function(module, exports) { var toString = Object.prototype.toString module.exports = isString function isString(obj) { return toString.call(obj) === "[object String]" } /***/ }), /* 18 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; // 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. // a duplex stream is just a stream that is both readable and writable. // Since JS doesn't have multiple prototypal inheritance, this class // prototypally inherits from Readable, and then parasitically from // Writable. /**/ var pna = __webpack_require__(28); /**/ /**/ var objectKeys = Object.keys || function (obj) { var keys = []; for (var key in obj) { keys.push(key); }return keys; }; /**/ module.exports = Duplex; /**/ var util = __webpack_require__(22); util.inherits = __webpack_require__(13); /**/ var Readable = __webpack_require__(67); var Writable = __webpack_require__(70); util.inherits(Duplex, Readable); { // avoid scope creep, the keys array can then be collected var keys = objectKeys(Writable.prototype); for (var v = 0; v < keys.length; v++) { var method = keys[v]; if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method]; } } function Duplex(options) { if (!(this instanceof Duplex)) return new Duplex(options); Readable.call(this, options); Writable.call(this, options); if (options && options.readable === false) this.readable = false; if (options && options.writable === false) this.writable = false; this.allowHalfOpen = true; if (options && options.allowHalfOpen === false) this.allowHalfOpen = false; this.once('end', onend); } Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', { // making it explicit this property is not enumerable // because otherwise some prototype manipulation in // userland will fail enumerable: false, get: function () { return this._writableState.highWaterMark; } }); // the no-half-open enforcer function onend() { // if we allow half-open state, or if the writable side ended, // then we're ok. if (this.allowHalfOpen || this._writableState.ended) return; // no more data can be written. // But allow more writes to happen in this tick. pna.nextTick(onEndNT, this); } function onEndNT(self) { self.end(); } Object.defineProperty(Duplex.prototype, 'destroyed', { get: function () { if (this._readableState === undefined || this._writableState === undefined) { return false; } return this._readableState.destroyed && this._writableState.destroyed; }, set: function (value) { // we ignore the value if the stream // has not been initialized yet if (this._readableState === undefined || this._writableState === undefined) { return; } // backward compatibility, the user is explicitly // managing destroyed this._readableState.destroyed = value; this._writableState.destroyed = value; } }); Duplex.prototype._destroy = function (err, cb) { this.push(null); this.end(); pna.nextTick(cb, err); }; /***/ }), /* 19 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /* Expose. */ module.exports = factory /* Factory. */ function factory(file) { var contents = indices(String(file)) return { toPosition: offsetToPositionFactory(contents), toOffset: positionToOffsetFactory(contents) } } /* Factory to get the line and column-based `position` for * `offset` in the bound indices. */ function offsetToPositionFactory(indices) { return offsetToPosition /* Get the line and column-based `position` for * `offset` in the bound indices. */ function offsetToPosition(offset) { var index = -1 var length = indices.length if (offset < 0) { return {} } while (++index < length) { if (indices[index] > offset) { return { line: index + 1, column: offset - (indices[index - 1] || 0) + 1, offset: offset } } } return {} } } /* Factory to get the `offset` for a line and column-based * `position` in the bound indices. */ function positionToOffsetFactory(indices) { return positionToOffset /* Get the `offset` for a line and column-based * `position` in the bound indices. */ function positionToOffset(position) { var line = position && position.line var column = position && position.column if (!isNaN(line) && !isNaN(column) && line - 1 in indices) { return (indices[line - 2] || 0) + column - 1 || 0 } return -1 } } /* Get indices of line-breaks in `value`. */ function indices(value) { var result = [] var index = value.indexOf('\n') while (index !== -1) { result.push(index + 1) index = value.indexOf('\n', index + 1) } result.push(value.length + 1) return result } /***/ }), /* 20 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; // YAML error class. http://stackoverflow.com/questions/8458984 // function YAMLException(reason, mark) { // Super constructor Error.call(this); this.name = 'YAMLException'; this.reason = reason; this.mark = mark; this.message = (this.reason || '(unknown reason)') + (this.mark ? ' ' + this.mark.toString() : ''); // Include stack trace in error object if (Error.captureStackTrace) { // Chrome and NodeJS Error.captureStackTrace(this, this.constructor); } else { // FF, IE 10+ and Safari 6+. Fallback for others this.stack = (new Error()).stack || ''; } } // Inherit from Error YAMLException.prototype = Object.create(Error.prototype); YAMLException.prototype.constructor = YAMLException; YAMLException.prototype.toString = function toString(compact) { var result = this.name + ': '; result += this.reason || '(unknown reason)'; if (!compact && this.mark) { result += ' ' + this.mark.toString(); } return result; }; module.exports = YAMLException; /***/ }), /* 21 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; // JS-YAML's default schema for `safeLoad` function. // It is not described in the YAML specification. // // This schema is based on standard YAML's Core schema and includes most of // extra types described at YAML tag repository. (http://yaml.org/type/) var Schema = __webpack_require__(16); module.exports = new Schema({ include: [ __webpack_require__(48) ], implicit: [ __webpack_require__(112), __webpack_require__(113) ], explicit: [ __webpack_require__(114), __webpack_require__(115), __webpack_require__(116), __webpack_require__(117) ] }); /***/ }), /* 22 */ /***/ (function(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. // NOTE: These type checking functions intentionally don't use `instanceof` // because it is fragile and can be easily faked with `Object.create()`. function isArray(arg) { if (Array.isArray) { return Array.isArray(arg); } return objectToString(arg) === '[object Array]'; } exports.isArray = isArray; function isBoolean(arg) { return typeof arg === 'boolean'; } exports.isBoolean = isBoolean; function isNull(arg) { return arg === null; } exports.isNull = isNull; function isNullOrUndefined(arg) { return arg == null; } exports.isNullOrUndefined = isNullOrUndefined; function isNumber(arg) { return typeof arg === 'number'; } exports.isNumber = isNumber; function isString(arg) { return typeof arg === 'string'; } exports.isString = isString; function isSymbol(arg) { return typeof arg === 'symbol'; } exports.isSymbol = isSymbol; function isUndefined(arg) { return arg === void 0; } exports.isUndefined = isUndefined; function isRegExp(re) { return objectToString(re) === '[object RegExp]'; } exports.isRegExp = isRegExp; function isObject(arg) { return typeof arg === 'object' && arg !== null; } exports.isObject = isObject; function isDate(d) { return objectToString(d) === '[object Date]'; } exports.isDate = isDate; function isError(e) { return (objectToString(e) === '[object Error]' || e instanceof Error); } exports.isError = isError; function isFunction(arg) { return typeof arg === 'function'; } exports.isFunction = isFunction; function isPrimitive(arg) { return arg === null || typeof arg === 'boolean' || typeof arg === 'number' || typeof arg === 'string' || typeof arg === 'symbol' || // ES6 symbol typeof arg === 'undefined'; } exports.isPrimitive = isPrimitive; exports.isBuffer = Buffer.isBuffer; function objectToString(o) { return Object.prototype.toString.call(o); } /***/ }), /* 23 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = decimal /* Check if the given character code, or the character * code at the first character, is decimal. */ function decimal(character) { var code = typeof character === 'string' ? character.charCodeAt(0) : character return code >= 48 && code <= 57 /* 0-9 */ } /***/ }), /* 24 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var wrap = __webpack_require__(98) module.exports = trough trough.wrap = wrap var slice = [].slice /* Create new middleware. */ function trough() { var fns = [] var middleware = {} middleware.run = run middleware.use = use return middleware /* Run `fns`. Last argument must be * a completion handler. */ function run() { var index = -1 var input = slice.call(arguments, 0, -1) var done = arguments[arguments.length - 1] if (typeof done !== 'function') { throw new Error('Expected function as last argument, not ' + done) } next.apply(null, [null].concat(input)) /* Run the next `fn`, if any. */ function next(err) { var fn = fns[++index] var params = slice.call(arguments, 0) var values = params.slice(1) var length = input.length var pos = -1 if (err) { done(err) return } /* Copy non-nully input into values. */ while (++pos < length) { if (values[pos] === null || values[pos] === undefined) { values[pos] = input[pos] } } input = values /* Next or done. */ if (fn) { wrap(fn, next).apply(null, input) } else { done.apply(null, [null].concat(input)) } } } /* Add `fn` to the list. */ function use(fn) { if (typeof fn !== 'function') { throw new Error('Expected `fn` to be a function, not ' + fn) } fns.push(fn) return middleware } } /***/ }), /* 25 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; // JS-YAML's default schema for `load` function. // It is not described in the YAML specification. // // This schema is based on JS-YAML's default safe schema and includes // JavaScript-specific types: !!js/undefined, !!js/regexp and !!js/function. // // Also this schema is used as default base schema at `Schema.create` function. var Schema = __webpack_require__(16); module.exports = Schema.DEFAULT = new Schema({ include: [ __webpack_require__(21) ], explicit: [ __webpack_require__(118), __webpack_require__(119), __webpack_require__(120) ] }); /***/ }), /* 26 */ /***/ (function(module, exports) { module.exports = function isFunction (fn) { return Object.prototype.toString.call(fn) === '[object Function]' } /***/ }), /* 27 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var own = {}.hasOwnProperty module.exports = stringify function stringify(value) { /* Nothing. */ if (!value || typeof value !== 'object') { return null } /* Node. */ if (own.call(value, 'position') || own.call(value, 'type')) { return position(value.position) } /* Position. */ if (own.call(value, 'start') || own.call(value, 'end')) { return position(value) } /* Point. */ if (own.call(value, 'line') || own.call(value, 'column')) { return point(value) } /* ? */ return null } function point(point) { if (!point || typeof point !== 'object') { point = {} } return index(point.line) + ':' + index(point.column) } function position(pos) { if (!pos || typeof pos !== 'object') { pos = {} } return point(pos.start) + '-' + point(pos.end) } function index(value) { return value && typeof value === 'number' ? value : 1 } /***/ }), /* 28 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; if (!process.version || process.version.indexOf('v0.') === 0 || process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) { module.exports = { nextTick: nextTick }; } else { module.exports = process } function nextTick(fn, arg1, arg2, arg3) { if (typeof fn !== 'function') { throw new TypeError('"callback" argument must be a function'); } var len = arguments.length; var args, i; switch (len) { case 0: case 1: return process.nextTick(fn); case 2: return process.nextTick(function afterTickOne() { fn.call(null, arg1); }); case 3: return process.nextTick(function afterTickTwo() { fn.call(null, arg1, arg2); }); case 4: return process.nextTick(function afterTickThree() { fn.call(null, arg1, arg2, arg3); }); default: args = new Array(len - 1); i = 0; while (i < args.length) { args[i++] = arguments[i]; } return process.nextTick(function afterTick() { fn.apply(null, args); }); } } /***/ }), /* 29 */ /***/ (function(module, exports, __webpack_require__) { /* eslint-disable node/no-deprecated-api */ var buffer = __webpack_require__(50) var Buffer = buffer.Buffer // alternative to using Object.keys for old browsers function copyProps (src, dst) { for (var key in src) { dst[key] = src[key] } } if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) { module.exports = buffer } else { // Copy properties from require('buffer') copyProps(buffer, exports) exports.Buffer = SafeBuffer } function SafeBuffer (arg, encodingOrOffset, length) { return Buffer(arg, encodingOrOffset, length) } // Copy static methods from Buffer copyProps(Buffer, SafeBuffer) SafeBuffer.from = function (arg, encodingOrOffset, length) { if (typeof arg === 'number') { throw new TypeError('Argument must not be a number') } return Buffer(arg, encodingOrOffset, length) } SafeBuffer.alloc = function (size, fill, encoding) { if (typeof size !== 'number') { throw new TypeError('Argument must be a number') } var buf = Buffer(size) if (fill !== undefined) { if (typeof encoding === 'string') { buf.fill(fill, encoding) } else { buf.fill(fill) } } else { buf.fill(0) } return buf } SafeBuffer.allocUnsafe = function (size) { if (typeof size !== 'number') { throw new TypeError('Argument must be a number') } return Buffer(size) } SafeBuffer.allocUnsafeSlow = function (size) { if (typeof size !== 'number') { throw new TypeError('Argument must be a number') } return buffer.SlowBuffer(size) } /***/ }), /* 30 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var legacy = __webpack_require__(77) var invalid = __webpack_require__(213) var decimal = __webpack_require__(23) var hexadecimal = __webpack_require__(78) var alphanumerical = __webpack_require__(79) var decodeEntity = __webpack_require__(214) module.exports = parseEntities var own = {}.hasOwnProperty var fromCharCode = String.fromCharCode var noop = Function.prototype /* Default settings. */ var defaults = { warning: null, reference: null, text: null, warningContext: null, referenceContext: null, textContext: null, position: {}, additional: null, attribute: false, nonTerminated: true } /* Reference types. */ var NAMED = 'named' var HEXADECIMAL = 'hexadecimal' var DECIMAL = 'decimal' /* Map of bases. */ var BASE = {} BASE[HEXADECIMAL] = 16 BASE[DECIMAL] = 10 /* Map of types to tests. Each type of character reference * accepts different characters. This test is used to * detect whether a reference has ended (as the semicolon * is not strictly needed). */ var TESTS = {} TESTS[NAMED] = alphanumerical TESTS[DECIMAL] = decimal TESTS[HEXADECIMAL] = hexadecimal /* Warning messages. */ var NAMED_NOT_TERMINATED = 1 var NUMERIC_NOT_TERMINATED = 2 var NAMED_EMPTY = 3 var NUMERIC_EMPTY = 4 var NAMED_UNKNOWN = 5 var NUMERIC_DISALLOWED = 6 var NUMERIC_PROHIBITED = 7 var MESSAGES = {} MESSAGES[NAMED_NOT_TERMINATED] = 'Named character references must be terminated by a semicolon' MESSAGES[NUMERIC_NOT_TERMINATED] = 'Numeric character references must be terminated by a semicolon' MESSAGES[NAMED_EMPTY] = 'Named character references cannot be empty' MESSAGES[NUMERIC_EMPTY] = 'Numeric character references cannot be empty' MESSAGES[NAMED_UNKNOWN] = 'Named character references must be known' MESSAGES[NUMERIC_DISALLOWED] = 'Numeric character references cannot be disallowed' MESSAGES[NUMERIC_PROHIBITED] = 'Numeric character references cannot be outside the permissible Unicode range' /* Wrap to ensure clean parameters are given to `parse`. */ function parseEntities(value, options) { var settings = {} var option var key if (!options) { options = {} } for (key in defaults) { option = options[key] settings[key] = option === null || option === undefined ? defaults[key] : option } if (settings.position.indent || settings.position.start) { settings.indent = settings.position.indent || [] settings.position = settings.position.start } return parse(value, settings) } /* Parse entities. */ function parse(value, settings) { var additional = settings.additional var nonTerminated = settings.nonTerminated var handleText = settings.text var handleReference = settings.reference var handleWarning = settings.warning var textContext = settings.textContext var referenceContext = settings.referenceContext var warningContext = settings.warningContext var pos = settings.position var indent = settings.indent || [] var length = value.length var index = 0 var lines = -1 var column = pos.column || 1 var line = pos.line || 1 var queue = '' var result = [] var entityCharacters var namedEntity var terminated var characters var character var reference var following var warning var reason var output var entity var begin var start var type var test var prev var next var diff var end /* Cache the current point. */ prev = now() /* Wrap `handleWarning`. */ warning = handleWarning ? parseError : noop /* Ensure the algorithm walks over the first character * and the end (inclusive). */ index-- length++ while (++index < length) { /* If the previous character was a newline. */ if (character === '\n') { column = indent[lines] || 1 } character = at(index) /* Handle anything other than an ampersand, * including newlines and EOF. */ if (character !== '&') { if (character === '\n') { line++ lines++ column = 0 } if (character) { queue += character column++ } else { flush() } } else { following = at(index + 1) /* The behaviour depends on the identity of the next * character. */ if ( following === '\t' /* Tab */ || following === '\n' /* Newline */ || following === '\f' /* Form feed */ || following === ' ' /* Space */ || following === '<' /* Less-than */ || following === '&' /* Ampersand */ || following === '' || (additional && following === additional) ) { /* Not a character reference. No characters * are consumed, and nothing is returned. * This is not an error, either. */ queue += character column++ continue } start = index + 1 begin = start end = start /* Numerical entity. */ if (following !== '#') { type = NAMED } else { end = ++begin /* The behaviour further depends on the * character after the U+0023 NUMBER SIGN. */ following = at(end) if (following === 'x' || following === 'X') { /* ASCII hex digits. */ type = HEXADECIMAL end = ++begin } else { /* ASCII digits. */ type = DECIMAL } } entityCharacters = '' entity = '' characters = '' test = TESTS[type] end-- while (++end < length) { following = at(end) if (!test(following)) { break } characters += following /* Check if we can match a legacy named * reference. If so, we cache that as the * last viable named reference. This * ensures we do not need to walk backwards * later. */ if (type === NAMED && own.call(legacy, characters)) { entityCharacters = characters entity = legacy[characters] } } terminated = at(end) === ';' if (terminated) { end++ namedEntity = type === NAMED ? decodeEntity(characters) : false if (namedEntity) { entityCharacters = characters entity = namedEntity } } diff = 1 + end - start if (!terminated && !nonTerminated) { /* Empty. */ } else if (!characters) { /* An empty (possible) entity is valid, unless * its numeric (thus an ampersand followed by * an octothorp). */ if (type !== NAMED) { warning(NUMERIC_EMPTY, diff) } } else if (type === NAMED) { /* An ampersand followed by anything * unknown, and not terminated, is invalid. */ if (terminated && !entity) { warning(NAMED_UNKNOWN, 1) } else { /* If theres something after an entity * name which is not known, cap the * reference. */ if (entityCharacters !== characters) { end = begin + entityCharacters.length diff = 1 + end - begin terminated = false } /* If the reference is not terminated, * warn. */ if (!terminated) { reason = entityCharacters ? NAMED_NOT_TERMINATED : NAMED_EMPTY if (!settings.attribute) { warning(reason, diff) } else { following = at(end) if (following === '=') { warning(reason, diff) entity = null } else if (alphanumerical(following)) { entity = null } else { warning(reason, diff) } } } } reference = entity } else { if (!terminated) { /* All non-terminated numeric entities are * not rendered, and trigger a warning. */ warning(NUMERIC_NOT_TERMINATED, diff) } /* When terminated and number, parse as * either hexadecimal or decimal. */ reference = parseInt(characters, BASE[type]) /* Trigger a warning when the parsed number * is prohibited, and replace with * replacement character. */ if (prohibited(reference)) { warning(NUMERIC_PROHIBITED, diff) reference = '\uFFFD' } else if (reference in invalid) { /* Trigger a warning when the parsed number * is disallowed, and replace by an * alternative. */ warning(NUMERIC_DISALLOWED, diff) reference = invalid[reference] } else { /* Parse the number. */ output = '' /* Trigger a warning when the parsed * number should not be used. */ if (disallowed(reference)) { warning(NUMERIC_DISALLOWED, diff) } /* Stringify the number. */ if (reference > 0xffff) { reference -= 0x10000 output += fromCharCode((reference >>> (10 & 0x3ff)) | 0xd800) reference = 0xdc00 | (reference & 0x3ff) } reference = output + fromCharCode(reference) } } /* If we could not find a reference, queue the * checked characters (as normal characters), * and move the pointer to their end. This is * possible because we can be certain neither * newlines nor ampersands are included. */ if (!reference) { characters = value.slice(start - 1, end) queue += characters column += characters.length index = end - 1 } else { /* Found it! First eat the queued * characters as normal text, then eat * an entity. */ flush() prev = now() index = end - 1 column += end - start + 1 result.push(reference) next = now() next.offset++ if (handleReference) { handleReference.call( referenceContext, reference, {start: prev, end: next}, value.slice(start - 1, end) ) } prev = next } } } /* Return the reduced nodes, and any possible warnings. */ return result.join('') /* Get current position. */ function now() { return { line: line, column: column, offset: index + (pos.offset || 0) } } /* “Throw” a parse-error: a warning. */ function parseError(code, offset) { var position = now() position.column += offset position.offset += offset handleWarning.call(warningContext, MESSAGES[code], position, code) } /* Get character at position. */ function at(position) { return value.charAt(position) } /* Flush `queue` (normal text). Macro invoked before * each entity and at the end of `value`. * Does nothing when `queue` is empty. */ function flush() { if (queue) { result.push(queue) if (handleText) { handleText.call(textContext, queue, {start: prev, end: now()}) } queue = '' } } } /* Check if `character` is outside the permissible unicode range. */ function prohibited(code) { return (code >= 0xd800 && code <= 0xdfff) || code > 0x10ffff } /* Check if `character` is disallowed. */ function disallowed(code) { return ( (code >= 0x0001 && code <= 0x0008) || code === 0x000b || (code >= 0x000d && code <= 0x001f) || (code >= 0x007f && code <= 0x009f) || (code >= 0xfdd0 && code <= 0xfdef) || (code & 0xffff) === 0xffff || (code & 0xffff) === 0xfffe ) } /***/ }), /* 31 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; const irregularPlurals = __webpack_require__(318); module.exports = (word, plural, count) => { if (typeof plural === 'number') { count = plural; } if (irregularPlurals.has(word.toLowerCase())) { plural = irregularPlurals.get(word.toLowerCase()); const firstLetter = word.charAt(0); const isFirstLetterUpperCase = firstLetter === firstLetter.toUpperCase(); if (isFirstLetterUpperCase) { plural = firstLetter.toUpperCase() + plural.slice(1); } const isWholeWordUpperCase = word === word.toUpperCase(); if (isWholeWordUpperCase) { plural = plural.toUpperCase(); } } else if (typeof plural !== 'string') { plural = (word.replace(/(?:s|x|z|ch|sh)$/i, '$&e').replace(/([^aeiou])y$/i, '$1ie') + 's') .replace(/i?e?s$/i, m => { const isTailLowerCase = word.slice(-1) === word.slice(-1).toLowerCase(); return isTailLowerCase ? m.toLowerCase() : m.toUpperCase(); }); } return Math.abs(count) === 1 ? word : plural; }; /***/ }), /* 32 */ /***/ (function(module, exports) { module.exports = require("stream"); /***/ }), /* 33 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; // Standard YAML's Failsafe schema. // http://www.yaml.org/spec/1.2/spec.html#id2802346 var Schema = __webpack_require__(16); module.exports = new Schema({ explicit: [ __webpack_require__(105), __webpack_require__(106), __webpack_require__(107) ] }); /***/ }), /* 34 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var formatter = __webpack_require__(142) var fault = create(Error) module.exports = fault fault.eval = create(EvalError) fault.range = create(RangeError) fault.reference = create(ReferenceError) fault.syntax = create(SyntaxError) fault.type = create(TypeError) fault.uri = create(URIError) fault.create = create /* Create a new `EConstructor`, with the formatted * `format` as a first argument. */ function create(EConstructor) { FormattedError.displayName = EConstructor.displayName || EConstructor.name return FormattedError function FormattedError(format) { if (format) { format = formatter.apply(null, arguments) } return new EConstructor(format) } } /***/ }), /* 35 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = function isObject(x) { return typeof x === "object" && x !== null; }; /***/ }), /* 36 */ /***/ (function(module, exports, __webpack_require__) { module.exports = minimatch minimatch.Minimatch = Minimatch var path = { sep: '/' } try { path = __webpack_require__(4) } catch (er) {} var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {} var expand = __webpack_require__(149) var plTypes = { '!': { open: '(?:(?!(?:', close: '))[^/]*?)'}, '?': { open: '(?:', close: ')?' }, '+': { open: '(?:', close: ')+' }, '*': { open: '(?:', close: ')*' }, '@': { open: '(?:', close: ')' } } // any single thing other than / // don't need to escape / when using new RegExp() var qmark = '[^/]' // * => any number of characters var star = qmark + '*?' // ** when dots are allowed. Anything goes, except .. and . // not (^ or / followed by one or two dots followed by $ or /), // followed by anything, any number of times. var twoStarDot = '(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?' // not a ^ or / followed by a dot, // followed by anything, any number of times. var twoStarNoDot = '(?:(?!(?:\\\/|^)\\.).)*?' // characters that need to be escaped in RegExp. var reSpecials = charSet('().*{}+?[]^$\\!') // "abc" -> { a:true, b:true, c:true } function charSet (s) { return s.split('').reduce(function (set, c) { set[c] = true return set }, {}) } // normalizes slashes. var slashSplit = /\/+/ minimatch.filter = filter function filter (pattern, options) { options = options || {} return function (p, i, list) { return minimatch(p, pattern, options) } } function ext (a, b) { a = a || {} b = b || {} var t = {} Object.keys(b).forEach(function (k) { t[k] = b[k] }) Object.keys(a).forEach(function (k) { t[k] = a[k] }) return t } minimatch.defaults = function (def) { if (!def || !Object.keys(def).length) return minimatch var orig = minimatch var m = function minimatch (p, pattern, options) { return orig.minimatch(p, pattern, ext(def, options)) } m.Minimatch = function Minimatch (pattern, options) { return new orig.Minimatch(pattern, ext(def, options)) } return m } Minimatch.defaults = function (def) { if (!def || !Object.keys(def).length) return Minimatch return minimatch.defaults(def).Minimatch } function minimatch (p, pattern, options) { if (typeof pattern !== 'string') { throw new TypeError('glob pattern string required') } if (!options) options = {} // shortcut: comments match nothing. if (!options.nocomment && pattern.charAt(0) === '#') { return false } // "" only matches "" if (pattern.trim() === '') return p === '' return new Minimatch(pattern, options).match(p) } function Minimatch (pattern, options) { if (!(this instanceof Minimatch)) { return new Minimatch(pattern, options) } if (typeof pattern !== 'string') { throw new TypeError('glob pattern string required') } if (!options) options = {} pattern = pattern.trim() // windows support: need to use /, not \ if (path.sep !== '/') { pattern = pattern.split(path.sep).join('/') } this.options = options this.set = [] this.pattern = pattern this.regexp = null this.negate = false this.comment = false this.empty = false // make the set of regexps etc. this.make() } Minimatch.prototype.debug = function () {} Minimatch.prototype.make = make function make () { // don't do it more than once. if (this._made) return var pattern = this.pattern var options = this.options // empty patterns and comments match nothing. if (!options.nocomment && pattern.charAt(0) === '#') { this.comment = true return } if (!pattern) { this.empty = true return } // step 1: figure out negation, etc. this.parseNegate() // step 2: expand braces var set = this.globSet = this.braceExpand() if (options.debug) this.debug = console.error this.debug(this.pattern, set) // step 3: now we have a set, so turn each one into a series of path-portion // matching patterns. // These will be regexps, except in the case of "**", which is // set to the GLOBSTAR object for globstar behavior, // and will not contain any / characters set = this.globParts = set.map(function (s) { return s.split(slashSplit) }) this.debug(this.pattern, set) // glob --> regexps set = set.map(function (s, si, set) { return s.map(this.parse, this) }, this) this.debug(this.pattern, set) // filter out everything that didn't compile properly. set = set.filter(function (s) { return s.indexOf(false) === -1 }) this.debug(this.pattern, set) this.set = set } Minimatch.prototype.parseNegate = parseNegate function parseNegate () { var pattern = this.pattern var negate = false var options = this.options var negateOffset = 0 if (options.nonegate) return for (var i = 0, l = pattern.length ; i < l && pattern.charAt(i) === '!' ; i++) { negate = !negate negateOffset++ } if (negateOffset) this.pattern = pattern.substr(negateOffset) this.negate = negate } // Brace expansion: // a{b,c}d -> abd acd // a{b,}c -> abc ac // a{0..3}d -> a0d a1d a2d a3d // a{b,c{d,e}f}g -> abg acdfg acefg // a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg // // Invalid sets are not expanded. // a{2..}b -> a{2..}b // a{b}c -> a{b}c minimatch.braceExpand = function (pattern, options) { return braceExpand(pattern, options) } Minimatch.prototype.braceExpand = braceExpand function braceExpand (pattern, options) { if (!options) { if (this instanceof Minimatch) { options = this.options } else { options = {} } } pattern = typeof pattern === 'undefined' ? this.pattern : pattern if (typeof pattern === 'undefined') { throw new TypeError('undefined pattern') } if (options.nobrace || !pattern.match(/\{.*\}/)) { // shortcut. no need to expand. return [pattern] } return expand(pattern) } // parse a component of the expanded set. // At this point, no pattern may contain "/" in it // so we're going to return a 2d array, where each entry is the full // pattern, split on '/', and then turned into a regular expression. // A regexp is made at the end which joins each array with an // escaped /, and another full one which joins each regexp with |. // // Following the lead of Bash 4.1, note that "**" only has special meaning // when it is the *only* thing in a path portion. Otherwise, any series // of * is equivalent to a single *. Globstar behavior is enabled by // default, and can be disabled by setting options.noglobstar. Minimatch.prototype.parse = parse var SUBPARSE = {} function parse (pattern, isSub) { if (pattern.length > 1024 * 64) { throw new TypeError('pattern is too long') } var options = this.options // shortcuts if (!options.noglobstar && pattern === '**') return GLOBSTAR if (pattern === '') return '' var re = '' var hasMagic = !!options.nocase var escaping = false // ? => one single character var patternListStack = [] var negativeLists = [] var stateChar var inClass = false var reClassStart = -1 var classStart = -1 // . and .. never match anything that doesn't start with ., // even when options.dot is set. var patternStart = pattern.charAt(0) === '.' ? '' // anything // not (start or / followed by . or .. followed by / or end) : options.dot ? '(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))' : '(?!\\.)' var self = this function clearStateChar () { if (stateChar) { // we had some state-tracking character // that wasn't consumed by this pass. switch (stateChar) { case '*': re += star hasMagic = true break case '?': re += qmark hasMagic = true break default: re += '\\' + stateChar break } self.debug('clearStateChar %j %j', stateChar, re) stateChar = false } } for (var i = 0, len = pattern.length, c ; (i < len) && (c = pattern.charAt(i)) ; i++) { this.debug('%s\t%s %s %j', pattern, i, re, c) // skip over any that are escaped. if (escaping && reSpecials[c]) { re += '\\' + c escaping = false continue } switch (c) { case '/': // completely not allowed, even escaped. // Should already be path-split by now. return false case '\\': clearStateChar() escaping = true continue // the various stateChar values // for the "extglob" stuff. case '?': case '*': case '+': case '@': case '!': this.debug('%s\t%s %s %j <-- stateChar', pattern, i, re, c) // all of those are literals inside a class, except that // the glob [!a] means [^a] in regexp if (inClass) { this.debug(' in class') if (c === '!' && i === classStart + 1) c = '^' re += c continue } // if we already have a stateChar, then it means // that there was something like ** or +? in there. // Handle the stateChar, then proceed with this one. self.debug('call clearStateChar %j', stateChar) clearStateChar() stateChar = c // if extglob is disabled, then +(asdf|foo) isn't a thing. // just clear the statechar *now*, rather than even diving into // the patternList stuff. if (options.noext) clearStateChar() continue case '(': if (inClass) { re += '(' continue } if (!stateChar) { re += '\\(' continue } patternListStack.push({ type: stateChar, start: i - 1, reStart: re.length, open: plTypes[stateChar].open, close: plTypes[stateChar].close }) // negation is (?:(?!js)[^/]*) re += stateChar === '!' ? '(?:(?!(?:' : '(?:' this.debug('plType %j %j', stateChar, re) stateChar = false continue case ')': if (inClass || !patternListStack.length) { re += '\\)' continue } clearStateChar() hasMagic = true var pl = patternListStack.pop() // negation is (?:(?!js)[^/]*) // The others are (?:) re += pl.close if (pl.type === '!') { negativeLists.push(pl) } pl.reEnd = re.length continue case '|': if (inClass || !patternListStack.length || escaping) { re += '\\|' escaping = false continue } clearStateChar() re += '|' continue // these are mostly the same in regexp and glob case '[': // swallow any state-tracking char before the [ clearStateChar() if (inClass) { re += '\\' + c continue } inClass = true classStart = i reClassStart = re.length re += c continue case ']': // a right bracket shall lose its special // meaning and represent itself in // a bracket expression if it occurs // first in the list. -- POSIX.2 2.8.3.2 if (i === classStart + 1 || !inClass) { re += '\\' + c escaping = false continue } // handle the case where we left a class open. // "[z-a]" is valid, equivalent to "\[z-a\]" if (inClass) { // split where the last [ was, make sure we don't have // an invalid re. if so, re-walk the contents of the // would-be class to re-translate any characters that // were passed through as-is // TODO: It would probably be faster to determine this // without a try/catch and a new RegExp, but it's tricky // to do safely. For now, this is safe and works. var cs = pattern.substring(classStart + 1, i) try { RegExp('[' + cs + ']') } catch (er) { // not a valid class! var sp = this.parse(cs, SUBPARSE) re = re.substr(0, reClassStart) + '\\[' + sp[0] + '\\]' hasMagic = hasMagic || sp[1] inClass = false continue } } // finish up the class. hasMagic = true inClass = false re += c continue default: // swallow any state char that wasn't consumed clearStateChar() if (escaping) { // no need escaping = false } else if (reSpecials[c] && !(c === '^' && inClass)) { re += '\\' } re += c } // switch } // for // handle the case where we left a class open. // "[abc" is valid, equivalent to "\[abc" if (inClass) { // split where the last [ was, and escape it // this is a huge pita. We now have to re-walk // the contents of the would-be class to re-translate // any characters that were passed through as-is cs = pattern.substr(classStart + 1) sp = this.parse(cs, SUBPARSE) re = re.substr(0, reClassStart) + '\\[' + sp[0] hasMagic = hasMagic || sp[1] } // handle the case where we had a +( thing at the *end* // of the pattern. // each pattern list stack adds 3 chars, and we need to go through // and escape any | chars that were passed through as-is for the regexp. // Go through and escape them, taking care not to double-escape any // | chars that were already escaped. for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) { var tail = re.slice(pl.reStart + pl.open.length) this.debug('setting tail', re, pl) // maybe some even number of \, then maybe 1 \, followed by a | tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function (_, $1, $2) { if (!$2) { // the | isn't already escaped, so escape it. $2 = '\\' } // need to escape all those slashes *again*, without escaping the // one that we need for escaping the | character. As it works out, // escaping an even number of slashes can be done by simply repeating // it exactly after itself. That's why this trick works. // // I am sorry that you have to see this. return $1 + $1 + $2 + '|' }) this.debug('tail=%j\n %s', tail, tail, pl, re) var t = pl.type === '*' ? star : pl.type === '?' ? qmark : '\\' + pl.type hasMagic = true re = re.slice(0, pl.reStart) + t + '\\(' + tail } // handle trailing things that only matter at the very end. clearStateChar() if (escaping) { // trailing \\ re += '\\\\' } // only need to apply the nodot start if the re starts with // something that could conceivably capture a dot var addPatternStart = false switch (re.charAt(0)) { case '.': case '[': case '(': addPatternStart = true } // Hack to work around lack of negative lookbehind in JS // A pattern like: *.!(x).!(y|z) needs to ensure that a name // like 'a.xyz.yz' doesn't match. So, the first negative // lookahead, has to look ALL the way ahead, to the end of // the pattern. for (var n = negativeLists.length - 1; n > -1; n--) { var nl = negativeLists[n] var nlBefore = re.slice(0, nl.reStart) var nlFirst = re.slice(nl.reStart, nl.reEnd - 8) var nlLast = re.slice(nl.reEnd - 8, nl.reEnd) var nlAfter = re.slice(nl.reEnd) nlLast += nlAfter // Handle nested stuff like *(*.js|!(*.json)), where open parens // mean that we should *not* include the ) in the bit that is considered // "after" the negated section. var openParensBefore = nlBefore.split('(').length - 1 var cleanAfter = nlAfter for (i = 0; i < openParensBefore; i++) { cleanAfter = cleanAfter.replace(/\)[+*?]?/, '') } nlAfter = cleanAfter var dollar = '' if (nlAfter === '' && isSub !== SUBPARSE) { dollar = '$' } var newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast re = newRe } // if the re is not "" at this point, then we need to make sure // it doesn't match against an empty path part. // Otherwise a/* will match a/, which it should not. if (re !== '' && hasMagic) { re = '(?=.)' + re } if (addPatternStart) { re = patternStart + re } // parsing just a piece of a larger pattern. if (isSub === SUBPARSE) { return [re, hasMagic] } // skip the regexp for non-magical patterns // unescape anything in it, though, so that it'll be // an exact match against a file etc. if (!hasMagic) { return globUnescape(pattern) } var flags = options.nocase ? 'i' : '' try { var regExp = new RegExp('^' + re + '$', flags) } catch (er) { // If it was an invalid regular expression, then it can't match // anything. This trick looks for a character after the end of // the string, which is of course impossible, except in multi-line // mode, but it's not a /m regex. return new RegExp('$.') } regExp._glob = pattern regExp._src = re return regExp } minimatch.makeRe = function (pattern, options) { return new Minimatch(pattern, options || {}).makeRe() } Minimatch.prototype.makeRe = makeRe function makeRe () { if (this.regexp || this.regexp === false) return this.regexp // at this point, this.set is a 2d array of partial // pattern strings, or "**". // // It's better to use .match(). This function shouldn't // be used, really, but it's pretty convenient sometimes, // when you just want to work with a regex. var set = this.set if (!set.length) { this.regexp = false return this.regexp } var options = this.options var twoStar = options.noglobstar ? star : options.dot ? twoStarDot : twoStarNoDot var flags = options.nocase ? 'i' : '' var re = set.map(function (pattern) { return pattern.map(function (p) { return (p === GLOBSTAR) ? twoStar : (typeof p === 'string') ? regExpEscape(p) : p._src }).join('\\\/') }).join('|') // must match entire pattern // ending in a * or ** will make it less strict. re = '^(?:' + re + ')$' // can match anything, as long as it's not this. if (this.negate) re = '^(?!' + re + ').*$' try { this.regexp = new RegExp(re, flags) } catch (ex) { this.regexp = false } return this.regexp } minimatch.match = function (list, pattern, options) { options = options || {} var mm = new Minimatch(pattern, options) list = list.filter(function (f) { return mm.match(f) }) if (mm.options.nonull && !list.length) { list.push(pattern) } return list } Minimatch.prototype.match = match function match (f, partial) { this.debug('match', f, this.pattern) // short-circuit in the case of busted things. // comments, etc. if (this.comment) return false if (this.empty) return f === '' if (f === '/' && partial) return true var options = this.options // windows: need to use /, not \ if (path.sep !== '/') { f = f.split(path.sep).join('/') } // treat the test path as a set of pathparts. f = f.split(slashSplit) this.debug(this.pattern, 'split', f) // just ONE of the pattern sets in this.set needs to match // in order for it to be valid. If negating, then just one // match means that we have failed. // Either way, return on the first hit. var set = this.set this.debug(this.pattern, 'set', set) // Find the basename of the path by looking for the last non-empty segment var filename var i for (i = f.length - 1; i >= 0; i--) { filename = f[i] if (filename) break } for (i = 0; i < set.length; i++) { var pattern = set[i] var file = f if (options.matchBase && pattern.length === 1) { file = [filename] } var hit = this.matchOne(file, pattern, partial) if (hit) { if (options.flipNegate) return true return !this.negate } } // didn't get any hits. this is success if it's a negative // pattern, failure otherwise. if (options.flipNegate) return false return this.negate } // set partial to true to test if, for example, // "/a/b" matches the start of "/*/b/*/d" // Partial means, if you run out of file before you run // out of pattern, then that's fine, as long as all // the parts match. Minimatch.prototype.matchOne = function (file, pattern, partial) { var options = this.options this.debug('matchOne', { 'this': this, file: file, pattern: pattern }) this.debug('matchOne', file.length, pattern.length) for (var fi = 0, pi = 0, fl = file.length, pl = pattern.length ; (fi < fl) && (pi < pl) ; fi++, pi++) { this.debug('matchOne loop') var p = pattern[pi] var f = file[fi] this.debug(pattern, p, f) // should be impossible. // some invalid regexp stuff in the set. if (p === false) return false if (p === GLOBSTAR) { this.debug('GLOBSTAR', [pattern, p, f]) // "**" // a/**/b/**/c would match the following: // a/b/x/y/z/c // a/x/y/z/b/c // a/b/x/b/x/c // a/b/c // To do this, take the rest of the pattern after // the **, and see if it would match the file remainder. // If so, return success. // If not, the ** "swallows" a segment, and try again. // This is recursively awful. // // a/**/b/**/c matching a/b/x/y/z/c // - a matches a // - doublestar // - matchOne(b/x/y/z/c, b/**/c) // - b matches b // - doublestar // - matchOne(x/y/z/c, c) -> no // - matchOne(y/z/c, c) -> no // - matchOne(z/c, c) -> no // - matchOne(c, c) yes, hit var fr = fi var pr = pi + 1 if (pr === pl) { this.debug('** at the end') // a ** at the end will just swallow the rest. // We have found a match. // however, it will not swallow /.x, unless // options.dot is set. // . and .. are *never* matched by **, for explosively // exponential reasons. for (; fi < fl; fi++) { if (file[fi] === '.' || file[fi] === '..' || (!options.dot && file[fi].charAt(0) === '.')) return false } return true } // ok, let's see if we can swallow whatever we can. while (fr < fl) { var swallowee = file[fr] this.debug('\nglobstar while', file, fr, pattern, pr, swallowee) // XXX remove this slice. Just pass the start index. if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) { this.debug('globstar found match!', fr, fl, swallowee) // found a match. return true } else { // can't swallow "." or ".." ever. // can only swallow ".foo" when explicitly asked. if (swallowee === '.' || swallowee === '..' || (!options.dot && swallowee.charAt(0) === '.')) { this.debug('dot detected!', file, fr, pattern, pr) break } // ** swallows a segment, and continue. this.debug('globstar swallow a segment, and continue') fr++ } } // no match was found. // However, in partial mode, we can't say this is necessarily over. // If there's more *pattern* left, then if (partial) { // ran out of file this.debug('\n>>> no match, partial?', file, fr, pattern, pr) if (fr === fl) return true } return false } // something other than ** // non-magic patterns just have to match exactly // patterns with magic have been turned into regexps. var hit if (typeof p === 'string') { if (options.nocase) { hit = f.toLowerCase() === p.toLowerCase() } else { hit = f === p } this.debug('string match', p, f, hit) } else { hit = f.match(p) this.debug('pattern match', p, f, hit) } if (!hit) return false } // Note: ending in / means that we'll get a final "" // at the end of the pattern. This can only match a // corresponding "" at the end of the file. // If the file ends in /, then it can only match a // a pattern that ends in /, unless the pattern just // doesn't have any more for it. But, a/b/ should *not* // match "a/b/*", even though "" matches against the // [^/]*? pattern, except in partial mode, where it might // simply not be reached yet. // However, a/b/ should still satisfy a/* // now either we fell off the end of the pattern, or we're done. if (fi === fl && pi === pl) { // ran out of pattern and filename at the same time. // an exact hit! return true } else if (fi === fl) { // ran out of file, but still had pattern left. // this is ok if we're doing the match as part of // a glob fs traversal. return partial } else if (pi === pl) { // ran out of pattern, still have file left. // this is only acceptable if we're on the very last // empty segment of a file with a trailing slash. // a/* should match a/b/ var emptyFileEnd = (fi === fl - 1) && (file[fi] === '') return emptyFileEnd } // should be unreachable. throw new Error('wtf?') } // replace stuff like \* with * function globUnescape (s) { return s.replace(/\\(.)/g, '$1') } function regExpEscape (s) { return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&') } /***/ }), /* 37 */ /***/ (function(module, exports) { module.exports = require("events"); /***/ }), /* 38 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; function posix(path) { return path.charAt(0) === '/'; } function win32(path) { // https://github.com/nodejs/node/blob/b3fcc245fb25539909ef1d5eaa01dbf92e168633/lib/path.js#L56 var splitDeviceRe = /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/; var result = splitDeviceRe.exec(path); var device = result[1] || ''; var isUnc = Boolean(device && device.charAt(1) !== ':'); // UNC paths are always absolute return Boolean(result[2] || isUnc); } module.exports = process.platform === 'win32' ? win32 : posix; module.exports.posix = posix; module.exports.win32 = win32; /***/ }), /* 39 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = __webpack_require__(155); /***/ }), /* 40 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = trimTrailingLines var line = '\n' /* Remove final newline characters from `value`. */ function trimTrailingLines(value) { var val = String(value) var index = val.length while (val.charAt(--index) === line) { /* Empty */ } return val.slice(0, index + 1) } /***/ }), /* 41 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = interrupt function interrupt(interruptors, tokenizers, ctx, params) { var length = interruptors.length var index = -1 var interruptor var config while (++index < length) { interruptor = interruptors[index] config = interruptor[1] || {} if ( config.pedantic !== undefined && config.pedantic !== ctx.options.pedantic ) { continue } if ( config.commonmark !== undefined && config.commonmark !== ctx.options.commonmark ) { continue } if (tokenizers[interruptor[0]].apply(ctx, params)) { return true } } return false } /***/ }), /* 42 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var collapseWhiteSpace = __webpack_require__(234) module.exports = normalize // Normalize an identifier. Collapses multiple white space characters into a // single space, and removes casing. function normalize(value) { return collapseWhiteSpace(value).toLowerCase() } /***/ }), /* 43 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var count = __webpack_require__(290) module.exports = enclose var leftParenthesis = '(' var rightParenthesis = ')' var lessThan = '<' var greaterThan = '>' var expression = /\s/ // Wrap `url` in angle brackets when needed, or when // forced. // In links, images, and definitions, the URL part needs // to be enclosed when it: // // - has a length of `0` // - contains white-space // - has more or less opening than closing parentheses function enclose(uri, always) { if ( always || uri.length === 0 || expression.test(uri) || count(uri, leftParenthesis) !== count(uri, rightParenthesis) ) { return lessThan + uri + greaterThan } return uri } /***/ }), /* 44 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = enclose var quotationMark = '"' var apostrophe = "'" // There is currently no way to support nested delimiters across Markdown.pl, // CommonMark, and GitHub (RedCarpet). The following code supports Markdown.pl // and GitHub. // CommonMark is not supported when mixing double- and single quotes inside a // title. function enclose(title) { var delimiter = title.indexOf(quotationMark) === -1 ? quotationMark : apostrophe return delimiter + title + delimiter } /***/ }), /* 45 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = toString /* Get the text content of a node. If the node itself * does not expose plain-text fields, `toString` will * recursivly try its children. */ function toString(node) { return ( valueOf(node) || (node.children && node.children.map(toString).join('')) || '' ) } /* Get the value of `node`. Checks, `value`, * `alt`, and `title`, in that order. */ function valueOf(node) { return ( (node && node.value ? node.value : node.alt ? node.alt : node.title) || '' ) } /***/ }), /* 46 */ /***/ (function(module, exports) { module.exports = function(module) { if (!module.webpackPolyfill) { module.deprecate = function() {}; module.paths = []; // module.parent = undefined by default if (!module.children) module.children = []; Object.defineProperty(module, "loaded", { enumerable: true, get: function() { return module.l; } }); Object.defineProperty(module, "id", { enumerable: true, get: function() { return module.i; } }); module.webpackPolyfill = 1; } return module; }; /***/ }), /* 47 */ /***/ (function(module, exports) { module.exports = require("module"); /***/ }), /* 48 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; // Standard YAML's Core schema. // http://www.yaml.org/spec/1.2/spec.html#id2804923 // // NOTE: JS-YAML does not support schema-specific tag resolution restrictions. // So, Core schema has no distinctions from JSON schema is JS-YAML. var Schema = __webpack_require__(16); module.exports = new Schema({ include: [ __webpack_require__(49) ] }); /***/ }), /* 49 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; // Standard YAML's JSON schema. // http://www.yaml.org/spec/1.2/spec.html#id2803231 // // NOTE: JS-YAML does not support schema-specific tag resolution restrictions. // So, this schema is not such strict as defined in the YAML specification. // It allows numbers in binary notaion, use `Null` and `NULL` as `null`, etc. var Schema = __webpack_require__(16); module.exports = new Schema({ include: [ __webpack_require__(33) ], implicit: [ __webpack_require__(108), __webpack_require__(109), __webpack_require__(110), __webpack_require__(111) ] }); /***/ }), /* 50 */ /***/ (function(module, exports) { module.exports = require("buffer"); /***/ }), /* 51 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; const errorEx = __webpack_require__(123); const fallback = __webpack_require__(125); const JSONError = errorEx('JSONError', { fileName: errorEx.append('in %s') }); module.exports = (input, reviver, filename) => { if (typeof reviver === 'string') { filename = reviver; reviver = null; } try { try { return JSON.parse(input, reviver); } catch (err) { fallback(input, reviver); throw err; } } catch (err) { err.message = err.message.replace(/\n/g, ''); const jsonErr = new JSONError(err); if (filename) { jsonErr.fileName = filename; } throw jsonErr; } }; /***/ }), /* 52 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * This is the common logic for both the Node.js and web browser * implementations of `debug()`. */ function setup(env) { createDebug.debug = createDebug; createDebug.default = createDebug; createDebug.coerce = coerce; createDebug.disable = disable; createDebug.enable = enable; createDebug.enabled = enabled; createDebug.humanize = __webpack_require__(127); Object.keys(env).forEach(function (key) { createDebug[key] = env[key]; }); /** * Active `debug` instances. */ createDebug.instances = []; /** * The currently active debug mode names, and names to skip. */ createDebug.names = []; createDebug.skips = []; /** * Map of special "%n" handling functions, for the debug "format" argument. * * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N". */ createDebug.formatters = {}; /** * Selects a color for a debug namespace * @param {String} namespace The namespace string for the for the debug instance to be colored * @return {Number|String} An ANSI color code for the given namespace * @api private */ function selectColor(namespace) { var hash = 0; for (var i = 0; i < namespace.length; i++) { hash = (hash << 5) - hash + namespace.charCodeAt(i); hash |= 0; // Convert to 32bit integer } return createDebug.colors[Math.abs(hash) % createDebug.colors.length]; } createDebug.selectColor = selectColor; /** * Create a debugger with the given `namespace`. * * @param {String} namespace * @return {Function} * @api public */ function createDebug(namespace) { var prevTime; function debug() { for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { args[_key] = arguments[_key]; } // Disabled? if (!debug.enabled) { return; } var self = debug; // Set `diff` timestamp var curr = Number(new Date()); var ms = curr - (prevTime || curr); self.diff = ms; self.prev = prevTime; self.curr = curr; prevTime = curr; args[0] = createDebug.coerce(args[0]); if (typeof args[0] !== 'string') { // Anything else let's inspect with %O args.unshift('%O'); } // Apply any `formatters` transformations var index = 0; args[0] = args[0].replace(/%([a-zA-Z%])/g, function (match, format) { // If we encounter an escaped % then don't increase the array index if (match === '%%') { return match; } index++; var formatter = createDebug.formatters[format]; if (typeof formatter === 'function') { var val = args[index]; match = formatter.call(self, val); // Now we need to remove `args[index]` since it's inlined in the `format` args.splice(index, 1); index--; } return match; }); // Apply env-specific formatting (colors, etc.) createDebug.formatArgs.call(self, args); var logFn = self.log || createDebug.log; logFn.apply(self, args); } debug.namespace = namespace; debug.enabled = createDebug.enabled(namespace); debug.useColors = createDebug.useColors(); debug.color = selectColor(namespace); debug.destroy = destroy; debug.extend = extend; // Debug.formatArgs = formatArgs; // debug.rawLog = rawLog; // env-specific initialization logic for debug instances if (typeof createDebug.init === 'function') { createDebug.init(debug); } createDebug.instances.push(debug); return debug; } function destroy() { var index = createDebug.instances.indexOf(this); if (index !== -1) { createDebug.instances.splice(index, 1); return true; } return false; } function extend(namespace, delimiter) { return createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace); } /** * Enables a debug mode by namespaces. This can include modes * separated by a colon and wildcards. * * @param {String} namespaces * @api public */ function enable(namespaces) { createDebug.save(namespaces); createDebug.names = []; createDebug.skips = []; var i; var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/); var len = split.length; for (i = 0; i < len; i++) { if (!split[i]) { // ignore empty strings continue; } namespaces = split[i].replace(/\*/g, '.*?'); if (namespaces[0] === '-') { createDebug.skips.push(new RegExp('^' + namespaces.substr(1) + '$')); } else { createDebug.names.push(new RegExp('^' + namespaces + '$')); } } for (i = 0; i < createDebug.instances.length; i++) { var instance = createDebug.instances[i]; instance.enabled = createDebug.enabled(instance.namespace); } } /** * Disable debug output. * * @api public */ function disable() { createDebug.enable(''); } /** * Returns true if the given mode name is enabled, false otherwise. * * @param {String} name * @return {Boolean} * @api public */ function enabled(name) { if (name[name.length - 1] === '*') { return true; } var i; var len; for (i = 0, len = createDebug.skips.length; i < len; i++) { if (createDebug.skips[i].test(name)) { return false; } } for (i = 0, len = createDebug.names.length; i < len; i++) { if (createDebug.names[i].test(name)) { return true; } } return false; } /** * Coerce `val`. * * @param {Mixed} val * @return {Mixed} * @api private */ function coerce(val) { if (val instanceof Error) { return val.stack || val.message; } return val; } createDebug.enable(createDebug.load()); return createDebug; } module.exports = setup; /***/ }), /* 53 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; const os = __webpack_require__(54); const hasFlag = __webpack_require__(130); const env = process.env; const support = level => { if (level === 0) { return false; } return { level, hasBasic: true, has256: level >= 2, has16m: level >= 3 }; }; let supportLevel = (() => { if (hasFlag('no-color') || hasFlag('no-colors') || hasFlag('color=false')) { return 0; } if (hasFlag('color=16m') || hasFlag('color=full') || hasFlag('color=truecolor')) { return 3; } if (hasFlag('color=256')) { return 2; } if (hasFlag('color') || hasFlag('colors') || hasFlag('color=true') || hasFlag('color=always')) { return 1; } if (process.stdout && !process.stdout.isTTY) { return 0; } if (process.platform === 'win32') { // Node.js 7.5.0 is the first version of Node.js to include a patch to // libuv that enables 256 color output on Windows. Anything earlier and it // won't work. However, here we target Node.js 8 at minimum as it is an LTS // release, and Node.js 7 is not. Windows 10 build 10586 is the first Windows // release that supports 256 colors. const osRelease = os.release().split('.'); if ( Number(process.versions.node.split('.')[0]) >= 8 && Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586 ) { return 2; } return 1; } if ('CI' in env) { if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(sign => sign in env) || env.CI_NAME === 'codeship') { return 1; } return 0; } if ('TEAMCITY_VERSION' in env) { return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0; } if ('TERM_PROGRAM' in env) { const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10); switch (env.TERM_PROGRAM) { case 'iTerm.app': return version >= 3 ? 3 : 2; case 'Hyper': return 3; case 'Apple_Terminal': return 2; // No default } } if (/-256(color)?$/i.test(env.TERM)) { return 2; } if (/^screen|^xterm|^vt100|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) { return 1; } if ('COLORTERM' in env) { return 1; } if (env.TERM === 'dumb') { return 0; } return 0; })(); if ('FORCE_COLOR' in env) { supportLevel = parseInt(env.FORCE_COLOR, 10) === 0 ? 0 : (supportLevel || 1); } module.exports = process && support(supportLevel); /***/ }), /* 54 */ /***/ (function(module, exports) { module.exports = require("os"); /***/ }), /* 55 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var fs = __webpack_require__(6) var path = __webpack_require__(4) var resolve = __webpack_require__(131).silent var npmPrefix = __webpack_require__(132)() module.exports = loadPlugin loadPlugin.resolve = resolvePlugin var electron = process.versions.electron !== undefined var argv = process.argv[1] || /* istanbul ignore next */ '' var nvm = process.env.NVM_BIN var globally = electron || argv.indexOf(npmPrefix) === 0 var windows = process.platform === 'win32' var prefix = windows ? /* istanbul ignore next */ '' : 'lib' var globals = path.resolve(npmPrefix, prefix, 'node_modules') /* istanbul ignore next - If we’re in Electron, we’re running in a modified * Node that cannot really install global node modules. To find the actual * modules, the user has to either set `prefix` in their `.npmrc` (which is * picked up by `npm-prefix`). Most people don’t do that, and some use NVM * instead to manage different versions of Node. Luckily NVM leaks some * environment variables that we can pick up on to try and detect the actual * modules. */ if (electron && nvm && !fs.existsSync(globals)) { globals = path.resolve(nvm, '..', prefix, 'node_modules') } /* Load the plug-in found using `resolvePlugin`. */ function loadPlugin(name, options) { return __webpack_require__(141)(resolvePlugin(name, options) || name) } /* Find a plugin. * * See also: * * * * Uses the standard node module loading strategy to find $name * in each given `cwd` (and optionally the global node_modules * directory). * * If a prefix is given and $name is not a path, `$prefix-$name` * is also searched (preferring these over non-prefixed modules). */ function resolvePlugin(name, options) { var settings = options || {} var prefix = settings.prefix var cwd = settings.cwd var filePath var sources var length var index var plugin if (cwd && typeof cwd === 'object') { sources = cwd.concat() } else { sources = [cwd || process.cwd()] } /* Non-path. */ if (name.indexOf(path.sep) === -1 && name.charAt(0) !== '.') { if (settings.global == null ? globally : settings.global) { sources.push(globals) } /* Unprefix module. */ if (prefix) { prefix = prefix.charAt(prefix.length - 1) === '-' ? prefix : prefix + '-' if (name.slice(0, prefix.length) !== prefix) { plugin = prefix + name } } } length = sources.length index = -1 while (++index < length) { cwd = sources[index] filePath = (plugin && resolve(cwd, plugin)) || resolve(cwd, name) if (filePath) { return filePath } } return null } /***/ }), /* 56 */ /***/ (function(module, exports) { module.exports = function (args, opts) { if (!opts) opts = {}; var flags = { bools : {}, strings : {}, unknownFn: null }; if (typeof opts['unknown'] === 'function') { flags.unknownFn = opts['unknown']; } if (typeof opts['boolean'] === 'boolean' && opts['boolean']) { flags.allBools = true; } else { [].concat(opts['boolean']).filter(Boolean).forEach(function (key) { flags.bools[key] = true; }); } var aliases = {}; Object.keys(opts.alias || {}).forEach(function (key) { aliases[key] = [].concat(opts.alias[key]); aliases[key].forEach(function (x) { aliases[x] = [key].concat(aliases[key].filter(function (y) { return x !== y; })); }); }); [].concat(opts.string).filter(Boolean).forEach(function (key) { flags.strings[key] = true; if (aliases[key]) { flags.strings[aliases[key]] = true; } }); var defaults = opts['default'] || {}; var argv = { _ : [] }; Object.keys(flags.bools).forEach(function (key) { setArg(key, defaults[key] === undefined ? false : defaults[key]); }); var notFlags = []; if (args.indexOf('--') !== -1) { notFlags = args.slice(args.indexOf('--')+1); args = args.slice(0, args.indexOf('--')); } function argDefined(key, arg) { return (flags.allBools && /^--[^=]+$/.test(arg)) || flags.strings[key] || flags.bools[key] || aliases[key]; } function setArg (key, val, arg) { if (arg && flags.unknownFn && !argDefined(key, arg)) { if (flags.unknownFn(arg) === false) return; } var value = !flags.strings[key] && isNumber(val) ? Number(val) : val ; setKey(argv, key.split('.'), value); (aliases[key] || []).forEach(function (x) { setKey(argv, x.split('.'), value); }); } function setKey (obj, keys, value) { var o = obj; keys.slice(0,-1).forEach(function (key) { if (o[key] === undefined) o[key] = {}; o = o[key]; }); var key = keys[keys.length - 1]; if (o[key] === undefined || flags.bools[key] || typeof o[key] === 'boolean') { o[key] = value; } else if (Array.isArray(o[key])) { o[key].push(value); } else { o[key] = [ o[key], value ]; } } function aliasIsBoolean(key) { return aliases[key].some(function (x) { return flags.bools[x]; }); } for (var i = 0; i < args.length; i++) { var arg = args[i]; if (/^--.+=/.test(arg)) { // Using [\s\S] instead of . because js doesn't support the // 'dotall' regex modifier. See: // http://stackoverflow.com/a/1068308/13216 var m = arg.match(/^--([^=]+)=([\s\S]*)$/); var key = m[1]; var value = m[2]; if (flags.bools[key]) { value = value !== 'false'; } setArg(key, value, arg); } else if (/^--no-.+/.test(arg)) { var key = arg.match(/^--no-(.+)/)[1]; setArg(key, false, arg); } else if (/^--.+/.test(arg)) { var key = arg.match(/^--(.+)/)[1]; var next = args[i + 1]; if (next !== undefined && !/^-/.test(next) && !flags.bools[key] && !flags.allBools && (aliases[key] ? !aliasIsBoolean(key) : true)) { setArg(key, next, arg); i++; } else if (/^(true|false)$/.test(next)) { setArg(key, next === 'true', arg); i++; } else { setArg(key, flags.strings[key] ? '' : true, arg); } } else if (/^-[^-]+/.test(arg)) { var letters = arg.slice(1,-1).split(''); var broken = false; for (var j = 0; j < letters.length; j++) { var next = arg.slice(j+2); if (next === '-') { setArg(letters[j], next, arg) continue; } if (/[A-Za-z]/.test(letters[j]) && /=/.test(next)) { setArg(letters[j], next.split('=')[1], arg); broken = true; break; } if (/[A-Za-z]/.test(letters[j]) && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) { setArg(letters[j], next, arg); broken = true; break; } if (letters[j+1] && letters[j+1].match(/\W/)) { setArg(letters[j], arg.slice(j+2), arg); broken = true; break; } else { setArg(letters[j], flags.strings[letters[j]] ? '' : true, arg); } } var key = arg.slice(-1)[0]; if (!broken && key !== '-') { if (args[i+1] && !/^(-|--)[^-]/.test(args[i+1]) && !flags.bools[key] && (aliases[key] ? !aliasIsBoolean(key) : true)) { setArg(key, args[i+1], arg); i++; } else if (args[i+1] && /true|false/.test(args[i+1])) { setArg(key, args[i+1] === 'true', arg); i++; } else { setArg(key, flags.strings[key] ? '' : true, arg); } } } else { if (!flags.unknownFn || flags.unknownFn(arg) !== false) { argv._.push( flags.strings['_'] || !isNumber(arg) ? arg : Number(arg) ); } if (opts.stopEarly) { argv._.push.apply(argv._, args.slice(i + 1)); break; } } } Object.keys(defaults).forEach(function (key) { if (!hasKey(argv, key.split('.'))) { setKey(argv, key.split('.'), defaults[key]); (aliases[key] || []).forEach(function (x) { setKey(argv, x.split('.'), defaults[key]); }); } }); if (opts['--']) { argv['--'] = new Array(); notFlags.forEach(function(key) { argv['--'].push(key); }); } else { notFlags.forEach(function(key) { argv._.push(key); }); } return argv; }; function hasKey (obj, keys) { var o = obj; keys.slice(0,-1).forEach(function (key) { o = (o[key] || {}); }); var key = keys[keys.length - 1]; return key in o; } function isNumber (x) { if (typeof x === 'number') return true; if (/^0x[0-9a-f]+$/i.test(x)) return true; return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x); } /***/ }), /* 57 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var fs = __webpack_require__(6); var path = __webpack_require__(4); var fault = __webpack_require__(34); var debug = __webpack_require__(9)('unified-engine:find-up'); var func = __webpack_require__(26); var object = __webpack_require__(35); module.exports = FindUp; var read = fs.readFile; var resolve = path.resolve; var relative = path.relative; var join = path.join; var dirname = path.dirname; FindUp.prototype.load = load; function FindUp(options) { var self = this; var fp = options.filePath; self.cache = {}; self.cwd = options.cwd; self.detect = options.detect; self.names = options.names; self.create = options.create; if (fp) { self.givenFilePath = resolve(options.cwd, fp); } } function load(filePath, callback) { var self = this; var cache = self.cache; var givenFilePath = self.givenFilePath; var givenFile = self.givenFile; var names = self.names; var create = self.create; var cwd = self.cwd; var parent; if (givenFilePath) { if (givenFile) { apply(callback, givenFile); } else { givenFile = [callback]; self.givenFile = givenFile; debug('Checking given file `%s`', givenFilePath); read(givenFilePath, loadGiven); } return; } if (!self.detect) { return callback(); } filePath = resolve(cwd, filePath); parent = dirname(filePath); if (parent in cache) { apply(callback, cache[parent]); } else { cache[parent] = [callback]; find(parent); } function loadGiven(err, buf) { var cbs = self.givenFile; var result; if (err) { result = fault('Cannot read given file `%s`\n%s', relative(cwd, givenFilePath), err.stack); result.code = 'ENOENT'; result.path = err.path; result.syscall = err.syscall; } else { try { result = create(buf, givenFilePath); debug('Read given file `%s`', givenFilePath); } catch (err) { result = fault('Cannot parse given file `%s`\n%s', relative(cwd, givenFilePath), err.stack); debug(err.message); } } givenFile = result; self.givenFile = result; applyAll(cbs, result); } function find(directory) { var index = -1; var length = names.length; next(); function next() { var parent; /* Try to read the next file. We don’t use `readdir` because on * huge directories, that could be *very* slow. */ if (++index < length) { read(join(directory, names[index]), done); } else { parent = dirname(directory); if (directory === parent) { debug('No files found for `%s`', filePath); found(); } else if (parent in cache) { apply(found, cache[parent]); } else { cache[parent] = [found]; find(parent); } } } function done(err, buf) { var name = names[index]; var fp = join(directory, name); var contents; /* istanbul ignore if - Hard to test. */ if (err) { if (err.code === 'ENOENT') { return next(); } err = fault('Cannot read file `%s`\n%s', relative(cwd, fp), err.message); debug(err.message); return found(err); } try { contents = create(buf, fp); } catch (err) { return found(fault('Cannot parse file `%s`\n%s', relative(cwd, fp), err.message)); } /* istanbul ignore else - maybe used in the future. */ if (contents) { debug('Read file `%s`', fp); found(null, contents); } else { next(); } } function found(err, result) { var cbs = cache[directory]; cache[directory] = err || result; applyAll(cbs, err || result); } } function applyAll(cbs, result) { var index = cbs.length; while (index--) { apply(cbs[index], result); } } function apply(cb, result) { if (object(result) && func(result[0])) { result.push(cb); } else if (result instanceof Error) { cb(result); } else { cb(null, result); } } } /***/ }), /* 58 */ /***/ (function(module, exports, __webpack_require__) { // Approach: // // 1. Get the minimatch set // 2. For each pattern in the set, PROCESS(pattern, false) // 3. Store matches per-set, then uniq them // // PROCESS(pattern, inGlobStar) // Get the first [n] items from pattern that are all strings // Join these together. This is PREFIX. // If there is no more remaining, then stat(PREFIX) and // add to matches if it succeeds. END. // // If inGlobStar and PREFIX is symlink and points to dir // set ENTRIES = [] // else readdir(PREFIX) as ENTRIES // If fail, END // // with ENTRIES // If pattern[n] is GLOBSTAR // // handle the case where the globstar match is empty // // by pruning it out, and testing the resulting pattern // PROCESS(pattern[0..n] + pattern[n+1 .. $], false) // // handle other cases. // for ENTRY in ENTRIES (not dotfiles) // // attach globstar + tail onto the entry // // Mark that this entry is a globstar match // PROCESS(pattern[0..n] + ENTRY + pattern[n .. $], true) // // else // not globstar // for ENTRY in ENTRIES (not dotfiles, unless pattern[n] is dot) // Test ENTRY against pattern[n] // If fails, continue // If passes, PROCESS(pattern[0..n] + item + pattern[n+1 .. $]) // // Caveat: // Cache all stats and readdirs results to minimize syscall. Since all // we ever care about is existence and directory-ness, we can just keep // `true` for files, and [children,...] for directories, or `false` for // things that don't exist. module.exports = glob var fs = __webpack_require__(6) var rp = __webpack_require__(59) var minimatch = __webpack_require__(36) var Minimatch = minimatch.Minimatch var inherits = __webpack_require__(13) var EE = __webpack_require__(37).EventEmitter var path = __webpack_require__(4) var assert = __webpack_require__(60) var isAbsolute = __webpack_require__(38) var globSync = __webpack_require__(153) var common = __webpack_require__(61) var alphasort = common.alphasort var alphasorti = common.alphasorti var setopts = common.setopts var ownProp = common.ownProp var inflight = __webpack_require__(154) var util = __webpack_require__(11) var childrenIgnored = common.childrenIgnored var isIgnored = common.isIgnored var once = __webpack_require__(63) function glob (pattern, options, cb) { if (typeof options === 'function') cb = options, options = {} if (!options) options = {} if (options.sync) { if (cb) throw new TypeError('callback provided to sync glob') return globSync(pattern, options) } return new Glob(pattern, options, cb) } glob.sync = globSync var GlobSync = glob.GlobSync = globSync.GlobSync // old api surface glob.glob = glob function extend (origin, add) { if (add === null || typeof add !== 'object') { return origin } var keys = Object.keys(add) var i = keys.length while (i--) { origin[keys[i]] = add[keys[i]] } return origin } glob.hasMagic = function (pattern, options_) { var options = extend({}, options_) options.noprocess = true var g = new Glob(pattern, options) var set = g.minimatch.set if (!pattern) return false if (set.length > 1) return true for (var j = 0; j < set[0].length; j++) { if (typeof set[0][j] !== 'string') return true } return false } glob.Glob = Glob inherits(Glob, EE) function Glob (pattern, options, cb) { if (typeof options === 'function') { cb = options options = null } if (options && options.sync) { if (cb) throw new TypeError('callback provided to sync glob') return new GlobSync(pattern, options) } if (!(this instanceof Glob)) return new Glob(pattern, options, cb) setopts(this, pattern, options) this._didRealPath = false // process each pattern in the minimatch set var n = this.minimatch.set.length // The matches are stored as {: true,...} so that // duplicates are automagically pruned. // Later, we do an Object.keys() on these. // Keep them as a list so we can fill in when nonull is set. this.matches = new Array(n) if (typeof cb === 'function') { cb = once(cb) this.on('error', cb) this.on('end', function (matches) { cb(null, matches) }) } var self = this this._processing = 0 this._emitQueue = [] this._processQueue = [] this.paused = false if (this.noprocess) return this if (n === 0) return done() var sync = true for (var i = 0; i < n; i ++) { this._process(this.minimatch.set[i], i, false, done) } sync = false function done () { --self._processing if (self._processing <= 0) { if (sync) { process.nextTick(function () { self._finish() }) } else { self._finish() } } } } Glob.prototype._finish = function () { assert(this instanceof Glob) if (this.aborted) return if (this.realpath && !this._didRealpath) return this._realpath() common.finish(this) this.emit('end', this.found) } Glob.prototype._realpath = function () { if (this._didRealpath) return this._didRealpath = true var n = this.matches.length if (n === 0) return this._finish() var self = this for (var i = 0; i < this.matches.length; i++) this._realpathSet(i, next) function next () { if (--n === 0) self._finish() } } Glob.prototype._realpathSet = function (index, cb) { var matchset = this.matches[index] if (!matchset) return cb() var found = Object.keys(matchset) var self = this var n = found.length if (n === 0) return cb() var set = this.matches[index] = Object.create(null) found.forEach(function (p, i) { // If there's a problem with the stat, then it means that // one or more of the links in the realpath couldn't be // resolved. just return the abs value in that case. p = self._makeAbs(p) rp.realpath(p, self.realpathCache, function (er, real) { if (!er) set[real] = true else if (er.syscall === 'stat') set[p] = true else self.emit('error', er) // srsly wtf right here if (--n === 0) { self.matches[index] = set cb() } }) }) } Glob.prototype._mark = function (p) { return common.mark(this, p) } Glob.prototype._makeAbs = function (f) { return common.makeAbs(this, f) } Glob.prototype.abort = function () { this.aborted = true this.emit('abort') } Glob.prototype.pause = function () { if (!this.paused) { this.paused = true this.emit('pause') } } Glob.prototype.resume = function () { if (this.paused) { this.emit('resume') this.paused = false if (this._emitQueue.length) { var eq = this._emitQueue.slice(0) this._emitQueue.length = 0 for (var i = 0; i < eq.length; i ++) { var e = eq[i] this._emitMatch(e[0], e[1]) } } if (this._processQueue.length) { var pq = this._processQueue.slice(0) this._processQueue.length = 0 for (var i = 0; i < pq.length; i ++) { var p = pq[i] this._processing-- this._process(p[0], p[1], p[2], p[3]) } } } } Glob.prototype._process = function (pattern, index, inGlobStar, cb) { assert(this instanceof Glob) assert(typeof cb === 'function') if (this.aborted) return this._processing++ if (this.paused) { this._processQueue.push([pattern, index, inGlobStar, cb]) return } //console.error('PROCESS %d', this._processing, pattern) // Get the first [n] parts of pattern that are all strings. var n = 0 while (typeof pattern[n] === 'string') { n ++ } // now n is the index of the first one that is *not* a string. // see if there's anything else var prefix switch (n) { // if not, then this is rather simple case pattern.length: this._processSimple(pattern.join('/'), index, cb) return case 0: // pattern *starts* with some non-trivial item. // going to readdir(cwd), but not include the prefix in matches. prefix = null break default: // pattern has some string bits in the front. // whatever it starts with, whether that's 'absolute' like /foo/bar, // or 'relative' like '../baz' prefix = pattern.slice(0, n).join('/') break } var remain = pattern.slice(n) // get the list of entries. var read if (prefix === null) read = '.' else if (isAbsolute(prefix) || isAbsolute(pattern.join('/'))) { if (!prefix || !isAbsolute(prefix)) prefix = '/' + prefix read = prefix } else read = prefix var abs = this._makeAbs(read) //if ignored, skip _processing if (childrenIgnored(this, read)) return cb() var isGlobStar = remain[0] === minimatch.GLOBSTAR if (isGlobStar) this._processGlobStar(prefix, read, abs, remain, index, inGlobStar, cb) else this._processReaddir(prefix, read, abs, remain, index, inGlobStar, cb) } Glob.prototype._processReaddir = function (prefix, read, abs, remain, index, inGlobStar, cb) { var self = this this._readdir(abs, inGlobStar, function (er, entries) { return self._processReaddir2(prefix, read, abs, remain, index, inGlobStar, entries, cb) }) } Glob.prototype._processReaddir2 = function (prefix, read, abs, remain, index, inGlobStar, entries, cb) { // if the abs isn't a dir, then nothing can match! if (!entries) return cb() // It will only match dot entries if it starts with a dot, or if // dot is set. Stuff like @(.foo|.bar) isn't allowed. var pn = remain[0] var negate = !!this.minimatch.negate var rawGlob = pn._glob var dotOk = this.dot || rawGlob.charAt(0) === '.' var matchedEntries = [] for (var i = 0; i < entries.length; i++) { var e = entries[i] if (e.charAt(0) !== '.' || dotOk) { var m if (negate && !prefix) { m = !e.match(pn) } else { m = e.match(pn) } if (m) matchedEntries.push(e) } } //console.error('prd2', prefix, entries, remain[0]._glob, matchedEntries) var len = matchedEntries.length // If there are no matched entries, then nothing matches. if (len === 0) return cb() // if this is the last remaining pattern bit, then no need for // an additional stat *unless* the user has specified mark or // stat explicitly. We know they exist, since readdir returned // them. if (remain.length === 1 && !this.mark && !this.stat) { if (!this.matches[index]) this.matches[index] = Object.create(null) for (var i = 0; i < len; i ++) { var e = matchedEntries[i] if (prefix) { if (prefix !== '/') e = prefix + '/' + e else e = prefix + e } if (e.charAt(0) === '/' && !this.nomount) { e = path.join(this.root, e) } this._emitMatch(index, e) } // This was the last one, and no stats were needed return cb() } // now test all matched entries as stand-ins for that part // of the pattern. remain.shift() for (var i = 0; i < len; i ++) { var e = matchedEntries[i] var newPattern if (prefix) { if (prefix !== '/') e = prefix + '/' + e else e = prefix + e } this._process([e].concat(remain), index, inGlobStar, cb) } cb() } Glob.prototype._emitMatch = function (index, e) { if (this.aborted) return if (isIgnored(this, e)) return if (this.paused) { this._emitQueue.push([index, e]) return } var abs = isAbsolute(e) ? e : this._makeAbs(e) if (this.mark) e = this._mark(e) if (this.absolute) e = abs if (this.matches[index][e]) return if (this.nodir) { var c = this.cache[abs] if (c === 'DIR' || Array.isArray(c)) return } this.matches[index][e] = true var st = this.statCache[abs] if (st) this.emit('stat', e, st) this.emit('match', e) } Glob.prototype._readdirInGlobStar = function (abs, cb) { if (this.aborted) return // follow all symlinked directories forever // just proceed as if this is a non-globstar situation if (this.follow) return this._readdir(abs, false, cb) var lstatkey = 'lstat\0' + abs var self = this var lstatcb = inflight(lstatkey, lstatcb_) if (lstatcb) fs.lstat(abs, lstatcb) function lstatcb_ (er, lstat) { if (er && er.code === 'ENOENT') return cb() var isSym = lstat && lstat.isSymbolicLink() self.symlinks[abs] = isSym // If it's not a symlink or a dir, then it's definitely a regular file. // don't bother doing a readdir in that case. if (!isSym && lstat && !lstat.isDirectory()) { self.cache[abs] = 'FILE' cb() } else self._readdir(abs, false, cb) } } Glob.prototype._readdir = function (abs, inGlobStar, cb) { if (this.aborted) return cb = inflight('readdir\0'+abs+'\0'+inGlobStar, cb) if (!cb) return //console.error('RD %j %j', +inGlobStar, abs) if (inGlobStar && !ownProp(this.symlinks, abs)) return this._readdirInGlobStar(abs, cb) if (ownProp(this.cache, abs)) { var c = this.cache[abs] if (!c || c === 'FILE') return cb() if (Array.isArray(c)) return cb(null, c) } var self = this fs.readdir(abs, readdirCb(this, abs, cb)) } function readdirCb (self, abs, cb) { return function (er, entries) { if (er) self._readdirError(abs, er, cb) else self._readdirEntries(abs, entries, cb) } } Glob.prototype._readdirEntries = function (abs, entries, cb) { if (this.aborted) return // if we haven't asked to stat everything, then just // assume that everything in there exists, so we can avoid // having to stat it a second time. if (!this.mark && !this.stat) { for (var i = 0; i < entries.length; i ++) { var e = entries[i] if (abs === '/') e = abs + e else e = abs + '/' + e this.cache[e] = true } } this.cache[abs] = entries return cb(null, entries) } Glob.prototype._readdirError = function (f, er, cb) { if (this.aborted) return // handle errors, and cache the information switch (er.code) { case 'ENOTSUP': // https://github.com/isaacs/node-glob/issues/205 case 'ENOTDIR': // totally normal. means it *does* exist. var abs = this._makeAbs(f) this.cache[abs] = 'FILE' if (abs === this.cwdAbs) { var error = new Error(er.code + ' invalid cwd ' + this.cwd) error.path = this.cwd error.code = er.code this.emit('error', error) this.abort() } break case 'ENOENT': // not terribly unusual case 'ELOOP': case 'ENAMETOOLONG': case 'UNKNOWN': this.cache[this._makeAbs(f)] = false break default: // some unusual error. Treat as failure. this.cache[this._makeAbs(f)] = false if (this.strict) { this.emit('error', er) // If the error is handled, then we abort // if not, we threw out of here this.abort() } if (!this.silent) console.error('glob error', er) break } return cb() } Glob.prototype._processGlobStar = function (prefix, read, abs, remain, index, inGlobStar, cb) { var self = this this._readdir(abs, inGlobStar, function (er, entries) { self._processGlobStar2(prefix, read, abs, remain, index, inGlobStar, entries, cb) }) } Glob.prototype._processGlobStar2 = function (prefix, read, abs, remain, index, inGlobStar, entries, cb) { //console.error('pgs2', prefix, remain[0], entries) // no entries means not a dir, so it can never have matches // foo.txt/** doesn't match foo.txt if (!entries) return cb() // test without the globstar, and with every child both below // and replacing the globstar. var remainWithoutGlobStar = remain.slice(1) var gspref = prefix ? [ prefix ] : [] var noGlobStar = gspref.concat(remainWithoutGlobStar) // the noGlobStar pattern exits the inGlobStar state this._process(noGlobStar, index, false, cb) var isSym = this.symlinks[abs] var len = entries.length // If it's a symlink, and we're in a globstar, then stop if (isSym && inGlobStar) return cb() for (var i = 0; i < len; i++) { var e = entries[i] if (e.charAt(0) === '.' && !this.dot) continue // these two cases enter the inGlobStar state var instead = gspref.concat(entries[i], remainWithoutGlobStar) this._process(instead, index, true, cb) var below = gspref.concat(entries[i], remain) this._process(below, index, true, cb) } cb() } Glob.prototype._processSimple = function (prefix, index, cb) { // XXX review this. Shouldn't it be doing the mounting etc // before doing stat? kinda weird? var self = this this._stat(prefix, function (er, exists) { self._processSimple2(prefix, index, er, exists, cb) }) } Glob.prototype._processSimple2 = function (prefix, index, er, exists, cb) { //console.error('ps2', prefix, exists) if (!this.matches[index]) this.matches[index] = Object.create(null) // If it doesn't exist, then just mark the lack of results if (!exists) return cb() if (prefix && isAbsolute(prefix) && !this.nomount) { var trail = /[\/\\]$/.test(prefix) if (prefix.charAt(0) === '/') { prefix = path.join(this.root, prefix) } else { prefix = path.resolve(this.root, prefix) if (trail) prefix += '/' } } if (process.platform === 'win32') prefix = prefix.replace(/\\/g, '/') // Mark this as a match this._emitMatch(index, prefix) cb() } // Returns either 'DIR', 'FILE', or false Glob.prototype._stat = function (f, cb) { var abs = this._makeAbs(f) var needDir = f.slice(-1) === '/' if (f.length > this.maxLength) return cb() if (!this.stat && ownProp(this.cache, abs)) { var c = this.cache[abs] if (Array.isArray(c)) c = 'DIR' // It exists, but maybe not how we need it if (!needDir || c === 'DIR') return cb(null, c) if (needDir && c === 'FILE') return cb() // otherwise we have to stat, because maybe c=true // if we know it exists, but not what it is. } var exists var stat = this.statCache[abs] if (stat !== undefined) { if (stat === false) return cb(null, stat) else { var type = stat.isDirectory() ? 'DIR' : 'FILE' if (needDir && type === 'FILE') return cb() else return cb(null, type, stat) } } var self = this var statcb = inflight('stat\0' + abs, lstatcb_) if (statcb) fs.lstat(abs, statcb) function lstatcb_ (er, lstat) { if (lstat && lstat.isSymbolicLink()) { // If it's a symlink, then treat it as the target, unless // the target does not exist, then treat it as a file. return fs.stat(abs, function (er, stat) { if (er) self._stat2(f, abs, null, lstat, cb) else self._stat2(f, abs, er, stat, cb) }) } else { self._stat2(f, abs, er, lstat, cb) } } } Glob.prototype._stat2 = function (f, abs, er, stat, cb) { if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) { this.statCache[abs] = false return cb() } var needDir = f.slice(-1) === '/' this.statCache[abs] = stat if (abs.slice(-1) === '/' && stat && !stat.isDirectory()) return cb(null, false, stat) var c = true if (stat) c = stat.isDirectory() ? 'DIR' : 'FILE' this.cache[abs] = this.cache[abs] || c if (needDir && c === 'FILE') return cb() return cb(null, c, stat) } /***/ }), /* 59 */ /***/ (function(module, exports, __webpack_require__) { module.exports = realpath realpath.realpath = realpath realpath.sync = realpathSync realpath.realpathSync = realpathSync realpath.monkeypatch = monkeypatch realpath.unmonkeypatch = unmonkeypatch var fs = __webpack_require__(6) var origRealpath = fs.realpath var origRealpathSync = fs.realpathSync var version = process.version var ok = /^v[0-5]\./.test(version) var old = __webpack_require__(148) function newError (er) { return er && er.syscall === 'realpath' && ( er.code === 'ELOOP' || er.code === 'ENOMEM' || er.code === 'ENAMETOOLONG' ) } function realpath (p, cache, cb) { if (ok) { return origRealpath(p, cache, cb) } if (typeof cache === 'function') { cb = cache cache = null } origRealpath(p, cache, function (er, result) { if (newError(er)) { old.realpath(p, cache, cb) } else { cb(er, result) } }) } function realpathSync (p, cache) { if (ok) { return origRealpathSync(p, cache) } try { return origRealpathSync(p, cache) } catch (er) { if (newError(er)) { return old.realpathSync(p, cache) } else { throw er } } } function monkeypatch () { fs.realpath = realpath fs.realpathSync = realpathSync } function unmonkeypatch () { fs.realpath = origRealpath fs.realpathSync = origRealpathSync } /***/ }), /* 60 */ /***/ (function(module, exports) { module.exports = require("assert"); /***/ }), /* 61 */ /***/ (function(module, exports, __webpack_require__) { exports.alphasort = alphasort exports.alphasorti = alphasorti exports.setopts = setopts exports.ownProp = ownProp exports.makeAbs = makeAbs exports.finish = finish exports.mark = mark exports.isIgnored = isIgnored exports.childrenIgnored = childrenIgnored function ownProp (obj, field) { return Object.prototype.hasOwnProperty.call(obj, field) } var path = __webpack_require__(4) var minimatch = __webpack_require__(36) var isAbsolute = __webpack_require__(38) var Minimatch = minimatch.Minimatch function alphasorti (a, b) { return a.toLowerCase().localeCompare(b.toLowerCase()) } function alphasort (a, b) { return a.localeCompare(b) } function setupIgnores (self, options) { self.ignore = options.ignore || [] if (!Array.isArray(self.ignore)) self.ignore = [self.ignore] if (self.ignore.length) { self.ignore = self.ignore.map(ignoreMap) } } // ignore patterns are always in dot:true mode. function ignoreMap (pattern) { var gmatcher = null if (pattern.slice(-3) === '/**') { var gpattern = pattern.replace(/(\/\*\*)+$/, '') gmatcher = new Minimatch(gpattern, { dot: true }) } return { matcher: new Minimatch(pattern, { dot: true }), gmatcher: gmatcher } } function setopts (self, pattern, options) { if (!options) options = {} // base-matching: just use globstar for that. if (options.matchBase && -1 === pattern.indexOf("/")) { if (options.noglobstar) { throw new Error("base matching requires globstar") } pattern = "**/" + pattern } self.silent = !!options.silent self.pattern = pattern self.strict = options.strict !== false self.realpath = !!options.realpath self.realpathCache = options.realpathCache || Object.create(null) self.follow = !!options.follow self.dot = !!options.dot self.mark = !!options.mark self.nodir = !!options.nodir if (self.nodir) self.mark = true self.sync = !!options.sync self.nounique = !!options.nounique self.nonull = !!options.nonull self.nosort = !!options.nosort self.nocase = !!options.nocase self.stat = !!options.stat self.noprocess = !!options.noprocess self.absolute = !!options.absolute self.maxLength = options.maxLength || Infinity self.cache = options.cache || Object.create(null) self.statCache = options.statCache || Object.create(null) self.symlinks = options.symlinks || Object.create(null) setupIgnores(self, options) self.changedCwd = false var cwd = process.cwd() if (!ownProp(options, "cwd")) self.cwd = cwd else { self.cwd = path.resolve(options.cwd) self.changedCwd = self.cwd !== cwd } self.root = options.root || path.resolve(self.cwd, "/") self.root = path.resolve(self.root) if (process.platform === "win32") self.root = self.root.replace(/\\/g, "/") // TODO: is an absolute `cwd` supposed to be resolved against `root`? // e.g. { cwd: '/test', root: __dirname } === path.join(__dirname, '/test') self.cwdAbs = isAbsolute(self.cwd) ? self.cwd : makeAbs(self, self.cwd) if (process.platform === "win32") self.cwdAbs = self.cwdAbs.replace(/\\/g, "/") self.nomount = !!options.nomount // disable comments and negation in Minimatch. // Note that they are not supported in Glob itself anyway. options.nonegate = true options.nocomment = true self.minimatch = new Minimatch(pattern, options) self.options = self.minimatch.options } function finish (self) { var nou = self.nounique var all = nou ? [] : Object.create(null) for (var i = 0, l = self.matches.length; i < l; i ++) { var matches = self.matches[i] if (!matches || Object.keys(matches).length === 0) { if (self.nonull) { // do like the shell, and spit out the literal glob var literal = self.minimatch.globSet[i] if (nou) all.push(literal) else all[literal] = true } } else { // had matches var m = Object.keys(matches) if (nou) all.push.apply(all, m) else m.forEach(function (m) { all[m] = true }) } } if (!nou) all = Object.keys(all) if (!self.nosort) all = all.sort(self.nocase ? alphasorti : alphasort) // at *some* point we statted all of these if (self.mark) { for (var i = 0; i < all.length; i++) { all[i] = self._mark(all[i]) } if (self.nodir) { all = all.filter(function (e) { var notDir = !(/\/$/.test(e)) var c = self.cache[e] || self.cache[makeAbs(self, e)] if (notDir && c) notDir = c !== 'DIR' && !Array.isArray(c) return notDir }) } } if (self.ignore.length) all = all.filter(function(m) { return !isIgnored(self, m) }) self.found = all } function mark (self, p) { var abs = makeAbs(self, p) var c = self.cache[abs] var m = p if (c) { var isDir = c === 'DIR' || Array.isArray(c) var slash = p.slice(-1) === '/' if (isDir && !slash) m += '/' else if (!isDir && slash) m = m.slice(0, -1) if (m !== p) { var mabs = makeAbs(self, m) self.statCache[mabs] = self.statCache[abs] self.cache[mabs] = self.cache[abs] } } return m } // lotta situps... function makeAbs (self, f) { var abs = f if (f.charAt(0) === '/') { abs = path.join(self.root, f) } else if (isAbsolute(f) || f === '') { abs = f } else if (self.changedCwd) { abs = path.resolve(self.cwd, f) } else { abs = path.resolve(f) } if (process.platform === 'win32') abs = abs.replace(/\\/g, '/') return abs } // Return true, if pattern ends with globstar '**', for the accompanying parent directory. // Ex:- If node_modules/** is the pattern, add 'node_modules' to ignore list along with it's contents function isIgnored (self, path) { if (!self.ignore.length) return false return self.ignore.some(function(item) { return item.matcher.match(path) || !!(item.gmatcher && item.gmatcher.match(path)) }) } function childrenIgnored (self, path) { if (!self.ignore.length) return false return self.ignore.some(function(item) { return !!(item.gmatcher && item.gmatcher.match(path)) }) } /***/ }), /* 62 */ /***/ (function(module, exports) { // Returns a wrapper function that returns a wrapped callback // The wrapper function should do some stuff, and return a // presumably different callback function. // This makes sure that own properties are retained, so that // decorations and such are not lost along the way. module.exports = wrappy function wrappy (fn, cb) { if (fn && cb) return wrappy(fn)(cb) if (typeof fn !== 'function') throw new TypeError('need wrapper function') Object.keys(fn).forEach(function (k) { wrapper[k] = fn[k] }) return wrapper function wrapper() { var args = new Array(arguments.length) for (var i = 0; i < args.length; i++) { args[i] = arguments[i] } var ret = fn.apply(this, args) var cb = args[args.length-1] if (typeof ret === 'function' && ret !== cb) { Object.keys(cb).forEach(function (k) { ret[k] = cb[k] }) } return ret } } /***/ }), /* 63 */ /***/ (function(module, exports, __webpack_require__) { var wrappy = __webpack_require__(62) module.exports = wrappy(once) module.exports.strict = wrappy(onceStrict) once.proto = once(function () { Object.defineProperty(Function.prototype, 'once', { value: function () { return once(this) }, configurable: true }) Object.defineProperty(Function.prototype, 'onceStrict', { value: function () { return onceStrict(this) }, configurable: true }) }) function once (fn) { var f = function () { if (f.called) return f.value f.called = true return f.value = fn.apply(this, arguments) } f.called = false return f } function onceStrict (fn) { var f = function () { if (f.called) throw new Error(f.onceError) f.called = true return f.value = fn.apply(this, arguments) } var name = fn.name || 'Function wrapped with `once`' f.onceError = name + " shouldn't be called more than once" f.called = false return f } /***/ }), /* 64 */ /***/ (function(module, exports) { /*! * Determine if an object is a Buffer * * @author Feross Aboukhadijeh * @license MIT */ // The _isBuffer check is for Safari 5-7 support, because it's missing // Object.prototype.constructor. Remove this eventually module.exports = function (obj) { return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer) } function isBuffer (obj) { return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj) } // For Node v0.10 support. Remove this eventually. function isSlowBuffer (obj) { return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0)) } /***/ }), /* 65 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var stringify = __webpack_require__(27) module.exports = VMessage /* Inherit from `Error#`. */ function VMessagePrototype() {} VMessagePrototype.prototype = Error.prototype VMessage.prototype = new VMessagePrototype() /* Message properties. */ var proto = VMessage.prototype proto.file = '' proto.name = '' proto.reason = '' proto.message = '' proto.stack = '' proto.fatal = null proto.column = null proto.line = null /* Construct a new VMessage. * * Note: We cannot invoke `Error` on the created context, * as that adds readonly `line` and `column` attributes on * Safari 9, thus throwing and failing the data. */ function VMessage(reason, position, origin) { var parts var range var location if (typeof position === 'string') { origin = position position = null } parts = parseOrigin(origin) range = stringify(position) || '1:1' location = { start: {line: null, column: null}, end: {line: null, column: null} } /* Node. */ if (position && position.position) { position = position.position } if (position) { /* Position. */ if (position.start) { location = position position = position.start } else { /* Point. */ location.start = position } } if (reason.stack) { this.stack = reason.stack reason = reason.message } this.message = reason this.name = range this.reason = reason this.line = position ? position.line : null this.column = position ? position.column : null this.location = location this.source = parts[0] this.ruleId = parts[1] } function parseOrigin(origin) { var result = [null, null] var index if (typeof origin === 'string') { index = origin.indexOf(':') if (index === -1) { result[1] = origin } else { result[0] = origin.slice(0, index) result[1] = origin.slice(index + 1) } } return result } /***/ }), /* 66 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var path = __webpack_require__(4); function replaceExt(npath, ext) { if (typeof npath !== 'string') { return npath; } if (npath.length === 0) { return npath; } var nFileName = path.basename(npath, path.extname(npath)) + ext; return path.join(path.dirname(npath), nFileName); } module.exports = replaceExt; /***/ }), /* 67 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; // 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. /**/ var pna = __webpack_require__(28); /**/ module.exports = Readable; /**/ var isArray = __webpack_require__(163); /**/ /**/ var Duplex; /**/ Readable.ReadableState = ReadableState; /**/ var EE = __webpack_require__(37).EventEmitter; var EElistenerCount = function (emitter, type) { return emitter.listeners(type).length; }; /**/ /**/ var Stream = __webpack_require__(68); /**/ /**/ var Buffer = __webpack_require__(29).Buffer; var OurUint8Array = global.Uint8Array || function () {}; function _uint8ArrayToBuffer(chunk) { return Buffer.from(chunk); } function _isUint8Array(obj) { return Buffer.isBuffer(obj) || obj instanceof OurUint8Array; } /**/ /**/ var util = __webpack_require__(22); util.inherits = __webpack_require__(13); /**/ /**/ var debugUtil = __webpack_require__(11); var debug = void 0; if (debugUtil && debugUtil.debuglog) { debug = debugUtil.debuglog('stream'); } else { debug = function () {}; } /**/ var BufferList = __webpack_require__(164); var destroyImpl = __webpack_require__(69); var StringDecoder; util.inherits(Readable, Stream); var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume']; function prependListener(emitter, event, fn) { // Sadly this is not cacheable as some libraries bundle their own // event emitter implementation with them. if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn); // This is a hack to make sure that our error handler is attached before any // userland ones. NEVER DO THIS. This is here only because this code needs // to continue to work with older versions of Node.js that do not include // the prependListener() method. The goal is to eventually remove this hack. if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]]; } function ReadableState(options, stream) { Duplex = Duplex || __webpack_require__(18); options = options || {}; // Duplex streams are both readable and writable, but share // the same options object. // However, some cases require setting options to different // values for the readable and the writable sides of the duplex stream. // These options can be provided separately as readableXXX and writableXXX. var isDuplex = stream instanceof Duplex; // object stream flag. Used to make read(n) ignore n and to // make all the buffer merging and length checks go away this.objectMode = !!options.objectMode; if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode; // the point at which it stops calling _read() to fill the buffer // Note: 0 is a valid value, means "don't call _read preemptively ever" var hwm = options.highWaterMark; var readableHwm = options.readableHighWaterMark; var defaultHwm = this.objectMode ? 16 : 16 * 1024; if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;else this.highWaterMark = defaultHwm; // cast to ints. this.highWaterMark = Math.floor(this.highWaterMark); // A linked list is used to store data chunks instead of an array because the // linked list can remove elements from the beginning faster than // array.shift() this.buffer = new BufferList(); this.length = 0; this.pipes = null; this.pipesCount = 0; this.flowing = null; this.ended = false; this.endEmitted = false; this.reading = false; // a flag to be able to tell if the event 'readable'/'data' is emitted // immediately, or on a later tick. We set this to true at first, because // any actions that shouldn't happen until "later" should generally also // not happen before the first read call. this.sync = true; // whenever we return null, then we set a flag to say // that we're awaiting a 'readable' event emission. this.needReadable = false; this.emittedReadable = false; this.readableListening = false; this.resumeScheduled = false; // has it been destroyed this.destroyed = false; // Crypto is kind of old and crusty. Historically, its default string // encoding is 'binary' so we have to make this configurable. // Everything else in the universe uses 'utf8', though. this.defaultEncoding = options.defaultEncoding || 'utf8'; // the number of writers that are awaiting a drain event in .pipe()s this.awaitDrain = 0; // if true, a maybeReadMore has been scheduled this.readingMore = false; this.decoder = null; this.encoding = null; if (options.encoding) { if (!StringDecoder) StringDecoder = __webpack_require__(71).StringDecoder; this.decoder = new StringDecoder(options.encoding); this.encoding = options.encoding; } } function Readable(options) { Duplex = Duplex || __webpack_require__(18); if (!(this instanceof Readable)) return new Readable(options); this._readableState = new ReadableState(options, this); // legacy this.readable = true; if (options) { if (typeof options.read === 'function') this._read = options.read; if (typeof options.destroy === 'function') this._destroy = options.destroy; } Stream.call(this); } Object.defineProperty(Readable.prototype, 'destroyed', { get: function () { if (this._readableState === undefined) { return false; } return this._readableState.destroyed; }, set: function (value) { // we ignore the value if the stream // has not been initialized yet if (!this._readableState) { return; } // backward compatibility, the user is explicitly // managing destroyed this._readableState.destroyed = value; } }); Readable.prototype.destroy = destroyImpl.destroy; Readable.prototype._undestroy = destroyImpl.undestroy; Readable.prototype._destroy = function (err, cb) { this.push(null); cb(err); }; // Manually shove something into the read() buffer. // This returns true if the highWaterMark has not been hit yet, // similar to how Writable.write() returns true if you should // write() some more. Readable.prototype.push = function (chunk, encoding) { var state = this._readableState; var skipChunkCheck; if (!state.objectMode) { if (typeof chunk === 'string') { encoding = encoding || state.defaultEncoding; if (encoding !== state.encoding) { chunk = Buffer.from(chunk, encoding); encoding = ''; } skipChunkCheck = true; } } else { skipChunkCheck = true; } return readableAddChunk(this, chunk, encoding, false, skipChunkCheck); }; // Unshift should *always* be something directly out of read() Readable.prototype.unshift = function (chunk) { return readableAddChunk(this, chunk, null, true, false); }; function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) { var state = stream._readableState; if (chunk === null) { state.reading = false; onEofChunk(stream, state); } else { var er; if (!skipChunkCheck) er = chunkInvalid(state, chunk); if (er) { stream.emit('error', er); } else if (state.objectMode || chunk && chunk.length > 0) { if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) { chunk = _uint8ArrayToBuffer(chunk); } if (addToFront) { if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true); } else if (state.ended) { stream.emit('error', new Error('stream.push() after EOF')); } else { state.reading = false; if (state.decoder && !encoding) { chunk = state.decoder.write(chunk); if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state); } else { addChunk(stream, state, chunk, false); } } } else if (!addToFront) { state.reading = false; } } return needMoreData(state); } function addChunk(stream, state, chunk, addToFront) { if (state.flowing && state.length === 0 && !state.sync) { stream.emit('data', chunk); stream.read(0); } else { // update the buffer info. state.length += state.objectMode ? 1 : chunk.length; if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk); if (state.needReadable) emitReadable(stream); } maybeReadMore(stream, state); } function chunkInvalid(state, chunk) { var er; if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) { er = new TypeError('Invalid non-string/buffer chunk'); } return er; } // if it's past the high water mark, we can push in some more. // Also, if we have no data yet, we can stand some // more bytes. This is to work around cases where hwm=0, // such as the repl. Also, if the push() triggered a // readable event, and the user called read(largeNumber) such that // needReadable was set, then we ought to push more, so that another // 'readable' event will be triggered. function needMoreData(state) { return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0); } Readable.prototype.isPaused = function () { return this._readableState.flowing === false; }; // backwards compatibility. Readable.prototype.setEncoding = function (enc) { if (!StringDecoder) StringDecoder = __webpack_require__(71).StringDecoder; this._readableState.decoder = new StringDecoder(enc); this._readableState.encoding = enc; return this; }; // Don't raise the hwm > 8MB var MAX_HWM = 0x800000; function computeNewHighWaterMark(n) { if (n >= MAX_HWM) { n = MAX_HWM; } else { // Get the next highest power of 2 to prevent increasing hwm excessively in // tiny amounts n--; n |= n >>> 1; n |= n >>> 2; n |= n >>> 4; n |= n >>> 8; n |= n >>> 16; n++; } return n; } // This function is designed to be inlinable, so please take care when making // changes to the function body. function howMuchToRead(n, state) { if (n <= 0 || state.length === 0 && state.ended) return 0; if (state.objectMode) return 1; if (n !== n) { // Only flow one buffer at a time if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length; } // If we're asking for more than the current hwm, then raise the hwm. if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n); if (n <= state.length) return n; // Don't have enough if (!state.ended) { state.needReadable = true; return 0; } return state.length; } // you can override either this method, or the async _read(n) below. Readable.prototype.read = function (n) { debug('read', n); n = parseInt(n, 10); var state = this._readableState; var nOrig = n; if (n !== 0) state.emittedReadable = false; // if we're doing read(0) to trigger a readable event, but we // already have a bunch of data in the buffer, then just trigger // the 'readable' event and move on. if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) { debug('read: emitReadable', state.length, state.ended); if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this); return null; } n = howMuchToRead(n, state); // if we've ended, and we're now clear, then finish it up. if (n === 0 && state.ended) { if (state.length === 0) endReadable(this); return null; } // All the actual chunk generation logic needs to be // *below* the call to _read. The reason is that in certain // synthetic stream cases, such as passthrough streams, _read // may be a completely synchronous operation which may change // the state of the read buffer, providing enough data when // before there was *not* enough. // // So, the steps are: // 1. Figure out what the state of things will be after we do // a read from the buffer. // // 2. If that resulting state will trigger a _read, then call _read. // Note that this may be asynchronous, or synchronous. Yes, it is // deeply ugly to write APIs this way, but that still doesn't mean // that the Readable class should behave improperly, as streams are // designed to be sync/async agnostic. // Take note if the _read call is sync or async (ie, if the read call // has returned yet), so that we know whether or not it's safe to emit // 'readable' etc. // // 3. Actually pull the requested chunks out of the buffer and return. // if we need a readable event, then we need to do some reading. var doRead = state.needReadable; debug('need readable', doRead); // if we currently have less than the highWaterMark, then also read some if (state.length === 0 || state.length - n < state.highWaterMark) { doRead = true; debug('length less than watermark', doRead); } // however, if we've ended, then there's no point, and if we're already // reading, then it's unnecessary. if (state.ended || state.reading) { doRead = false; debug('reading or ended', doRead); } else if (doRead) { debug('do read'); state.reading = true; state.sync = true; // if the length is currently zero, then we *need* a readable event. if (state.length === 0) state.needReadable = true; // call internal read method this._read(state.highWaterMark); state.sync = false; // If _read pushed data synchronously, then `reading` will be false, // and we need to re-evaluate how much data we can return to the user. if (!state.reading) n = howMuchToRead(nOrig, state); } var ret; if (n > 0) ret = fromList(n, state);else ret = null; if (ret === null) { state.needReadable = true; n = 0; } else { state.length -= n; } if (state.length === 0) { // If we have nothing in the buffer, then we want to know // as soon as we *do* get something into the buffer. if (!state.ended) state.needReadable = true; // If we tried to read() past the EOF, then emit end on the next tick. if (nOrig !== n && state.ended) endReadable(this); } if (ret !== null) this.emit('data', ret); return ret; }; function onEofChunk(stream, state) { if (state.ended) return; if (state.decoder) { var chunk = state.decoder.end(); if (chunk && chunk.length) { state.buffer.push(chunk); state.length += state.objectMode ? 1 : chunk.length; } } state.ended = true; // emit 'readable' now to make sure it gets picked up. emitReadable(stream); } // Don't emit readable right away in sync mode, because this can trigger // another read() call => stack overflow. This way, it might trigger // a nextTick recursion warning, but that's not so bad. function emitReadable(stream) { var state = stream._readableState; state.needReadable = false; if (!state.emittedReadable) { debug('emitReadable', state.flowing); state.emittedReadable = true; if (state.sync) pna.nextTick(emitReadable_, stream);else emitReadable_(stream); } } function emitReadable_(stream) { debug('emit readable'); stream.emit('readable'); flow(stream); } // at this point, the user has presumably seen the 'readable' event, // and called read() to consume some data. that may have triggered // in turn another _read(n) call, in which case reading = true if // it's in progress. // However, if we're not ended, or reading, and the length < hwm, // then go ahead and try to read some more preemptively. function maybeReadMore(stream, state) { if (!state.readingMore) { state.readingMore = true; pna.nextTick(maybeReadMore_, stream, state); } } function maybeReadMore_(stream, state) { var len = state.length; while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) { debug('maybeReadMore read 0'); stream.read(0); if (len === state.length) // didn't get any data, stop spinning. break;else len = state.length; } state.readingMore = false; } // abstract method. to be overridden in specific implementation classes. // call cb(er, data) where data is <= n in length. // for virtual (non-string, non-buffer) streams, "length" is somewhat // arbitrary, and perhaps not very meaningful. Readable.prototype._read = function (n) { this.emit('error', new Error('_read() is not implemented')); }; Readable.prototype.pipe = function (dest, pipeOpts) { var src = this; var state = this._readableState; switch (state.pipesCount) { case 0: state.pipes = dest; break; case 1: state.pipes = [state.pipes, dest]; break; default: state.pipes.push(dest); break; } state.pipesCount += 1; debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts); var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr; var endFn = doEnd ? onend : unpipe; if (state.endEmitted) pna.nextTick(endFn);else src.once('end', endFn); dest.on('unpipe', onunpipe); function onunpipe(readable, unpipeInfo) { debug('onunpipe'); if (readable === src) { if (unpipeInfo && unpipeInfo.hasUnpiped === false) { unpipeInfo.hasUnpiped = true; cleanup(); } } } function onend() { debug('onend'); dest.end(); } // when the dest drains, it reduces the awaitDrain counter // on the source. This would be more elegant with a .once() // handler in flow(), but adding and removing repeatedly is // too slow. var ondrain = pipeOnDrain(src); dest.on('drain', ondrain); var cleanedUp = false; function cleanup() { debug('cleanup'); // cleanup event handlers once the pipe is broken dest.removeListener('close', onclose); dest.removeListener('finish', onfinish); dest.removeListener('drain', ondrain); dest.removeListener('error', onerror); dest.removeListener('unpipe', onunpipe); src.removeListener('end', onend); src.removeListener('end', unpipe); src.removeListener('data', ondata); cleanedUp = true; // if the reader is waiting for a drain event from this // specific writer, then it would cause it to never start // flowing again. // So, if this is awaiting a drain, then we just call it now. // If we don't know, then assume that we are waiting for one. if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain(); } // If the user pushes more data while we're writing to dest then we'll end up // in ondata again. However, we only want to increase awaitDrain once because // dest will only emit one 'drain' event for the multiple writes. // => Introduce a guard on increasing awaitDrain. var increasedAwaitDrain = false; src.on('data', ondata); function ondata(chunk) { debug('ondata'); increasedAwaitDrain = false; var ret = dest.write(chunk); if (false === ret && !increasedAwaitDrain) { // If the user unpiped during `dest.write()`, it is possible // to get stuck in a permanently paused state if that write // also returned false. // => Check whether `dest` is still a piping destination. if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) { debug('false write response, pause', src._readableState.awaitDrain); src._readableState.awaitDrain++; increasedAwaitDrain = true; } src.pause(); } } // if the dest has an error, then stop piping into it. // however, don't suppress the throwing behavior for this. function onerror(er) { debug('onerror', er); unpipe(); dest.removeListener('error', onerror); if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er); } // Make sure our error handler is attached before userland ones. prependListener(dest, 'error', onerror); // Both close and finish should trigger unpipe, but only once. function onclose() { dest.removeListener('finish', onfinish); unpipe(); } dest.once('close', onclose); function onfinish() { debug('onfinish'); dest.removeListener('close', onclose); unpipe(); } dest.once('finish', onfinish); function unpipe() { debug('unpipe'); src.unpipe(dest); } // tell the dest that it's being piped to dest.emit('pipe', src); // start the flow if it hasn't been started already. if (!state.flowing) { debug('pipe resume'); src.resume(); } return dest; }; function pipeOnDrain(src) { return function () { var state = src._readableState; debug('pipeOnDrain', state.awaitDrain); if (state.awaitDrain) state.awaitDrain--; if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) { state.flowing = true; flow(src); } }; } Readable.prototype.unpipe = function (dest) { var state = this._readableState; var unpipeInfo = { hasUnpiped: false }; // if we're not piping anywhere, then do nothing. if (state.pipesCount === 0) return this; // just one destination. most common case. if (state.pipesCount === 1) { // passed in one, but it's not the right one. if (dest && dest !== state.pipes) return this; if (!dest) dest = state.pipes; // got a match. state.pipes = null; state.pipesCount = 0; state.flowing = false; if (dest) dest.emit('unpipe', this, unpipeInfo); return this; } // slow case. multiple pipe destinations. if (!dest) { // remove all. var dests = state.pipes; var len = state.pipesCount; state.pipes = null; state.pipesCount = 0; state.flowing = false; for (var i = 0; i < len; i++) { dests[i].emit('unpipe', this, unpipeInfo); }return this; } // try to find the right one. var index = indexOf(state.pipes, dest); if (index === -1) return this; state.pipes.splice(index, 1); state.pipesCount -= 1; if (state.pipesCount === 1) state.pipes = state.pipes[0]; dest.emit('unpipe', this, unpipeInfo); return this; }; // set up data events if they are asked for // Ensure readable listeners eventually get something Readable.prototype.on = function (ev, fn) { var res = Stream.prototype.on.call(this, ev, fn); if (ev === 'data') { // Start flowing on next tick if stream isn't explicitly paused if (this._readableState.flowing !== false) this.resume(); } else if (ev === 'readable') { var state = this._readableState; if (!state.endEmitted && !state.readableListening) { state.readableListening = state.needReadable = true; state.emittedReadable = false; if (!state.reading) { pna.nextTick(nReadingNextTick, this); } else if (state.length) { emitReadable(this); } } } return res; }; Readable.prototype.addListener = Readable.prototype.on; function nReadingNextTick(self) { debug('readable nexttick read 0'); self.read(0); } // pause() and resume() are remnants of the legacy readable stream API // If the user uses them, then switch into old mode. Readable.prototype.resume = function () { var state = this._readableState; if (!state.flowing) { debug('resume'); state.flowing = true; resume(this, state); } return this; }; function resume(stream, state) { if (!state.resumeScheduled) { state.resumeScheduled = true; pna.nextTick(resume_, stream, state); } } function resume_(stream, state) { if (!state.reading) { debug('resume read 0'); stream.read(0); } state.resumeScheduled = false; state.awaitDrain = 0; stream.emit('resume'); flow(stream); if (state.flowing && !state.reading) stream.read(0); } Readable.prototype.pause = function () { debug('call pause flowing=%j', this._readableState.flowing); if (false !== this._readableState.flowing) { debug('pause'); this._readableState.flowing = false; this.emit('pause'); } return this; }; function flow(stream) { var state = stream._readableState; debug('flow', state.flowing); while (state.flowing && stream.read() !== null) {} } // wrap an old-style stream as the async data source. // This is *not* part of the readable stream interface. // It is an ugly unfortunate mess of history. Readable.prototype.wrap = function (stream) { var _this = this; var state = this._readableState; var paused = false; stream.on('end', function () { debug('wrapped end'); if (state.decoder && !state.ended) { var chunk = state.decoder.end(); if (chunk && chunk.length) _this.push(chunk); } _this.push(null); }); stream.on('data', function (chunk) { debug('wrapped data'); if (state.decoder) chunk = state.decoder.write(chunk); // don't skip over falsy values in objectMode if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return; var ret = _this.push(chunk); if (!ret) { paused = true; stream.pause(); } }); // proxy all the other methods. // important when wrapping filters and duplexes. for (var i in stream) { if (this[i] === undefined && typeof stream[i] === 'function') { this[i] = function (method) { return function () { return stream[method].apply(stream, arguments); }; }(i); } } // proxy certain important events. for (var n = 0; n < kProxyEvents.length; n++) { stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n])); } // when we try to consume some more bytes, simply unpause the // underlying stream. this._read = function (n) { debug('wrapped _read', n); if (paused) { paused = false; stream.resume(); } }; return this; }; Object.defineProperty(Readable.prototype, 'readableHighWaterMark', { // making it explicit this property is not enumerable // because otherwise some prototype manipulation in // userland will fail enumerable: false, get: function () { return this._readableState.highWaterMark; } }); // exposed for testing purposes only. Readable._fromList = fromList; // Pluck off n bytes from an array of buffers. // Length is the combined lengths of all the buffers in the list. // This function is designed to be inlinable, so please take care when making // changes to the function body. function fromList(n, state) { // nothing buffered if (state.length === 0) return null; var ret; if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) { // read it all, truncate the list if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length); state.buffer.clear(); } else { // read part of list ret = fromListPartial(n, state.buffer, state.decoder); } return ret; } // Extracts only enough buffered data to satisfy the amount requested. // This function is designed to be inlinable, so please take care when making // changes to the function body. function fromListPartial(n, list, hasStrings) { var ret; if (n < list.head.data.length) { // slice is the same for buffers and strings ret = list.head.data.slice(0, n); list.head.data = list.head.data.slice(n); } else if (n === list.head.data.length) { // first chunk is a perfect match ret = list.shift(); } else { // result spans more than one buffer ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list); } return ret; } // Copies a specified amount of characters from the list of buffered data // chunks. // This function is designed to be inlinable, so please take care when making // changes to the function body. function copyFromBufferString(n, list) { var p = list.head; var c = 1; var ret = p.data; n -= ret.length; while (p = p.next) { var str = p.data; var nb = n > str.length ? str.length : n; if (nb === str.length) ret += str;else ret += str.slice(0, n); n -= nb; if (n === 0) { if (nb === str.length) { ++c; if (p.next) list.head = p.next;else list.head = list.tail = null; } else { list.head = p; p.data = str.slice(nb); } break; } ++c; } list.length -= c; return ret; } // Copies a specified amount of bytes from the list of buffered data chunks. // This function is designed to be inlinable, so please take care when making // changes to the function body. function copyFromBuffer(n, list) { var ret = Buffer.allocUnsafe(n); var p = list.head; var c = 1; p.data.copy(ret); n -= p.data.length; while (p = p.next) { var buf = p.data; var nb = n > buf.length ? buf.length : n; buf.copy(ret, ret.length - n, 0, nb); n -= nb; if (n === 0) { if (nb === buf.length) { ++c; if (p.next) list.head = p.next;else list.head = list.tail = null; } else { list.head = p; p.data = buf.slice(nb); } break; } ++c; } list.length -= c; return ret; } function endReadable(stream) { var state = stream._readableState; // If we get here before consuming all the bytes, then that is a // bug in node. Should never happen. if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream'); if (!state.endEmitted) { state.ended = true; pna.nextTick(endReadableNT, state, stream); } } function endReadableNT(state, stream) { // Check that we didn't get one last unshift. if (!state.endEmitted && state.length === 0) { state.endEmitted = true; stream.readable = false; stream.emit('end'); } } function indexOf(xs, x) { for (var i = 0, l = xs.length; i < l; i++) { if (xs[i] === x) return i; } return -1; } /***/ }), /* 68 */ /***/ (function(module, exports, __webpack_require__) { module.exports = __webpack_require__(32); /***/ }), /* 69 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /**/ var pna = __webpack_require__(28); /**/ // undocumented cb() API, needed for core, not for public API function destroy(err, cb) { var _this = this; var readableDestroyed = this._readableState && this._readableState.destroyed; var writableDestroyed = this._writableState && this._writableState.destroyed; if (readableDestroyed || writableDestroyed) { if (cb) { cb(err); } else if (err && (!this._writableState || !this._writableState.errorEmitted)) { pna.nextTick(emitErrorNT, this, err); } return this; } // we set destroyed to true before firing error callbacks in order // to make it re-entrance safe in case destroy() is called within callbacks if (this._readableState) { this._readableState.destroyed = true; } // if this is a duplex stream mark the writable part as destroyed as well if (this._writableState) { this._writableState.destroyed = true; } this._destroy(err || null, function (err) { if (!cb && err) { pna.nextTick(emitErrorNT, _this, err); if (_this._writableState) { _this._writableState.errorEmitted = true; } } else if (cb) { cb(err); } }); return this; } function undestroy() { if (this._readableState) { this._readableState.destroyed = false; this._readableState.reading = false; this._readableState.ended = false; this._readableState.endEmitted = false; } if (this._writableState) { this._writableState.destroyed = false; this._writableState.ended = false; this._writableState.ending = false; this._writableState.finished = false; this._writableState.errorEmitted = false; } } function emitErrorNT(self, err) { self.emit('error', err); } module.exports = { destroy: destroy, undestroy: undestroy }; /***/ }), /* 70 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; // 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. // A bit simpler than readable streams. // Implement an async ._write(chunk, encoding, cb), and it'll handle all // the drain event emission and buffering. /**/ var pna = __webpack_require__(28); /**/ module.exports = Writable; /* */ function WriteReq(chunk, encoding, cb) { this.chunk = chunk; this.encoding = encoding; this.callback = cb; this.next = null; } // It seems a linked list but it is not // there will be only 2 of these for each stream function CorkedRequest(state) { var _this = this; this.next = null; this.entry = null; this.finish = function () { onCorkedFinish(_this, state); }; } /* */ /**/ var asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick; /**/ /**/ var Duplex; /**/ Writable.WritableState = WritableState; /**/ var util = __webpack_require__(22); util.inherits = __webpack_require__(13); /**/ /**/ var internalUtil = { deprecate: __webpack_require__(165) }; /**/ /**/ var Stream = __webpack_require__(68); /**/ /**/ var Buffer = __webpack_require__(29).Buffer; var OurUint8Array = global.Uint8Array || function () {}; function _uint8ArrayToBuffer(chunk) { return Buffer.from(chunk); } function _isUint8Array(obj) { return Buffer.isBuffer(obj) || obj instanceof OurUint8Array; } /**/ var destroyImpl = __webpack_require__(69); util.inherits(Writable, Stream); function nop() {} function WritableState(options, stream) { Duplex = Duplex || __webpack_require__(18); options = options || {}; // Duplex streams are both readable and writable, but share // the same options object. // However, some cases require setting options to different // values for the readable and the writable sides of the duplex stream. // These options can be provided separately as readableXXX and writableXXX. var isDuplex = stream instanceof Duplex; // object stream flag to indicate whether or not this stream // contains buffers or objects. this.objectMode = !!options.objectMode; if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode; // the point at which write() starts returning false // Note: 0 is a valid value, means that we always return false if // the entire buffer is not flushed immediately on write() var hwm = options.highWaterMark; var writableHwm = options.writableHighWaterMark; var defaultHwm = this.objectMode ? 16 : 16 * 1024; if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;else this.highWaterMark = defaultHwm; // cast to ints. this.highWaterMark = Math.floor(this.highWaterMark); // if _final has been called this.finalCalled = false; // drain event flag. this.needDrain = false; // at the start of calling end() this.ending = false; // when end() has been called, and returned this.ended = false; // when 'finish' is emitted this.finished = false; // has it been destroyed this.destroyed = false; // should we decode strings into buffers before passing to _write? // this is here so that some node-core streams can optimize string // handling at a lower level. var noDecode = options.decodeStrings === false; this.decodeStrings = !noDecode; // Crypto is kind of old and crusty. Historically, its default string // encoding is 'binary' so we have to make this configurable. // Everything else in the universe uses 'utf8', though. this.defaultEncoding = options.defaultEncoding || 'utf8'; // not an actual buffer we keep track of, but a measurement // of how much we're waiting to get pushed to some underlying // socket or file. this.length = 0; // a flag to see when we're in the middle of a write. this.writing = false; // when true all writes will be buffered until .uncork() call this.corked = 0; // a flag to be able to tell if the onwrite cb is called immediately, // or on a later tick. We set this to true at first, because any // actions that shouldn't happen until "later" should generally also // not happen before the first write call. this.sync = true; // a flag to know if we're processing previously buffered items, which // may call the _write() callback in the same tick, so that we don't // end up in an overlapped onwrite situation. this.bufferProcessing = false; // the callback that's passed to _write(chunk,cb) this.onwrite = function (er) { onwrite(stream, er); }; // the callback that the user supplies to write(chunk,encoding,cb) this.writecb = null; // the amount that is being written when _write is called. this.writelen = 0; this.bufferedRequest = null; this.lastBufferedRequest = null; // number of pending user-supplied write callbacks // this must be 0 before 'finish' can be emitted this.pendingcb = 0; // emit prefinish if the only thing we're waiting for is _write cbs // This is relevant for synchronous Transform streams this.prefinished = false; // True if the error was already emitted and should not be thrown again this.errorEmitted = false; // count buffered requests this.bufferedRequestCount = 0; // allocate the first CorkedRequest, there is always // one allocated and free to use, and we maintain at most two this.corkedRequestsFree = new CorkedRequest(this); } WritableState.prototype.getBuffer = function getBuffer() { var current = this.bufferedRequest; var out = []; while (current) { out.push(current); current = current.next; } return out; }; (function () { try { Object.defineProperty(WritableState.prototype, 'buffer', { get: internalUtil.deprecate(function () { return this.getBuffer(); }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003') }); } catch (_) {} })(); // Test _writableState for inheritance to account for Duplex streams, // whose prototype chain only points to Readable. var realHasInstance; if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') { realHasInstance = Function.prototype[Symbol.hasInstance]; Object.defineProperty(Writable, Symbol.hasInstance, { value: function (object) { if (realHasInstance.call(this, object)) return true; if (this !== Writable) return false; return object && object._writableState instanceof WritableState; } }); } else { realHasInstance = function (object) { return object instanceof this; }; } function Writable(options) { Duplex = Duplex || __webpack_require__(18); // Writable ctor is applied to Duplexes, too. // `realHasInstance` is necessary because using plain `instanceof` // would return false, as no `_writableState` property is attached. // Trying to use the custom `instanceof` for Writable here will also break the // Node.js LazyTransform implementation, which has a non-trivial getter for // `_writableState` that would lead to infinite recursion. if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) { return new Writable(options); } this._writableState = new WritableState(options, this); // legacy. this.writable = true; if (options) { if (typeof options.write === 'function') this._write = options.write; if (typeof options.writev === 'function') this._writev = options.writev; if (typeof options.destroy === 'function') this._destroy = options.destroy; if (typeof options.final === 'function') this._final = options.final; } Stream.call(this); } // Otherwise people can pipe Writable streams, which is just wrong. Writable.prototype.pipe = function () { this.emit('error', new Error('Cannot pipe, not readable')); }; function writeAfterEnd(stream, cb) { var er = new Error('write after end'); // TODO: defer error events consistently everywhere, not just the cb stream.emit('error', er); pna.nextTick(cb, er); } // Checks that a user-supplied chunk is valid, especially for the particular // mode the stream is in. Currently this means that `null` is never accepted // and undefined/non-string values are only allowed in object mode. function validChunk(stream, state, chunk, cb) { var valid = true; var er = false; if (chunk === null) { er = new TypeError('May not write null values to stream'); } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) { er = new TypeError('Invalid non-string/buffer chunk'); } if (er) { stream.emit('error', er); pna.nextTick(cb, er); valid = false; } return valid; } Writable.prototype.write = function (chunk, encoding, cb) { var state = this._writableState; var ret = false; var isBuf = !state.objectMode && _isUint8Array(chunk); if (isBuf && !Buffer.isBuffer(chunk)) { chunk = _uint8ArrayToBuffer(chunk); } if (typeof encoding === 'function') { cb = encoding; encoding = null; } if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding; if (typeof cb !== 'function') cb = nop; if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) { state.pendingcb++; ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb); } return ret; }; Writable.prototype.cork = function () { var state = this._writableState; state.corked++; }; Writable.prototype.uncork = function () { var state = this._writableState; if (state.corked) { state.corked--; if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state); } }; Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) { // node::ParseEncoding() requires lower case. if (typeof encoding === 'string') encoding = encoding.toLowerCase(); if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding); this._writableState.defaultEncoding = encoding; return this; }; function decodeChunk(state, chunk, encoding) { if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') { chunk = Buffer.from(chunk, encoding); } return chunk; } Object.defineProperty(Writable.prototype, 'writableHighWaterMark', { // making it explicit this property is not enumerable // because otherwise some prototype manipulation in // userland will fail enumerable: false, get: function () { return this._writableState.highWaterMark; } }); // if we're already writing something, then just put this // in the queue, and wait our turn. Otherwise, call _write // If we return false, then we need a drain event, so set that flag. function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) { if (!isBuf) { var newChunk = decodeChunk(state, chunk, encoding); if (chunk !== newChunk) { isBuf = true; encoding = 'buffer'; chunk = newChunk; } } var len = state.objectMode ? 1 : chunk.length; state.length += len; var ret = state.length < state.highWaterMark; // we must ensure that previous needDrain will not be reset to false. if (!ret) state.needDrain = true; if (state.writing || state.corked) { var last = state.lastBufferedRequest; state.lastBufferedRequest = { chunk: chunk, encoding: encoding, isBuf: isBuf, callback: cb, next: null }; if (last) { last.next = state.lastBufferedRequest; } else { state.bufferedRequest = state.lastBufferedRequest; } state.bufferedRequestCount += 1; } else { doWrite(stream, state, false, len, chunk, encoding, cb); } return ret; } function doWrite(stream, state, writev, len, chunk, encoding, cb) { state.writelen = len; state.writecb = cb; state.writing = true; state.sync = true; if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite); state.sync = false; } function onwriteError(stream, state, sync, er, cb) { --state.pendingcb; if (sync) { // defer the callback if we are being called synchronously // to avoid piling up things on the stack pna.nextTick(cb, er); // this can emit finish, and it will always happen // after error pna.nextTick(finishMaybe, stream, state); stream._writableState.errorEmitted = true; stream.emit('error', er); } else { // the caller expect this to happen before if // it is async cb(er); stream._writableState.errorEmitted = true; stream.emit('error', er); // this can emit finish, but finish must // always follow error finishMaybe(stream, state); } } function onwriteStateUpdate(state) { state.writing = false; state.writecb = null; state.length -= state.writelen; state.writelen = 0; } function onwrite(stream, er) { var state = stream._writableState; var sync = state.sync; var cb = state.writecb; onwriteStateUpdate(state); if (er) onwriteError(stream, state, sync, er, cb);else { // Check if we're actually ready to finish, but don't emit yet var finished = needFinish(state); if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) { clearBuffer(stream, state); } if (sync) { /**/ asyncWrite(afterWrite, stream, state, finished, cb); /**/ } else { afterWrite(stream, state, finished, cb); } } } function afterWrite(stream, state, finished, cb) { if (!finished) onwriteDrain(stream, state); state.pendingcb--; cb(); finishMaybe(stream, state); } // Must force callback to be called on nextTick, so that we don't // emit 'drain' before the write() consumer gets the 'false' return // value, and has a chance to attach a 'drain' listener. function onwriteDrain(stream, state) { if (state.length === 0 && state.needDrain) { state.needDrain = false; stream.emit('drain'); } } // if there's something in the buffer waiting, then process it function clearBuffer(stream, state) { state.bufferProcessing = true; var entry = state.bufferedRequest; if (stream._writev && entry && entry.next) { // Fast case, write everything using _writev() var l = state.bufferedRequestCount; var buffer = new Array(l); var holder = state.corkedRequestsFree; holder.entry = entry; var count = 0; var allBuffers = true; while (entry) { buffer[count] = entry; if (!entry.isBuf) allBuffers = false; entry = entry.next; count += 1; } buffer.allBuffers = allBuffers; doWrite(stream, state, true, state.length, buffer, '', holder.finish); // doWrite is almost always async, defer these to save a bit of time // as the hot path ends with doWrite state.pendingcb++; state.lastBufferedRequest = null; if (holder.next) { state.corkedRequestsFree = holder.next; holder.next = null; } else { state.corkedRequestsFree = new CorkedRequest(state); } state.bufferedRequestCount = 0; } else { // Slow case, write chunks one-by-one while (entry) { var chunk = entry.chunk; var encoding = entry.encoding; var cb = entry.callback; var len = state.objectMode ? 1 : chunk.length; doWrite(stream, state, false, len, chunk, encoding, cb); entry = entry.next; state.bufferedRequestCount--; // if we didn't call the onwrite immediately, then // it means that we need to wait until it does. // also, that means that the chunk and cb are currently // being processed, so move the buffer counter past them. if (state.writing) { break; } } if (entry === null) state.lastBufferedRequest = null; } state.bufferedRequest = entry; state.bufferProcessing = false; } Writable.prototype._write = function (chunk, encoding, cb) { cb(new Error('_write() is not implemented')); }; Writable.prototype._writev = null; Writable.prototype.end = function (chunk, encoding, cb) { var state = this._writableState; if (typeof chunk === 'function') { cb = chunk; chunk = null; encoding = null; } else if (typeof encoding === 'function') { cb = encoding; encoding = null; } if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); // .end() fully uncorks if (state.corked) { state.corked = 1; this.uncork(); } // ignore unnecessary end() calls. if (!state.ending && !state.finished) endWritable(this, state, cb); }; function needFinish(state) { return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing; } function callFinal(stream, state) { stream._final(function (err) { state.pendingcb--; if (err) { stream.emit('error', err); } state.prefinished = true; stream.emit('prefinish'); finishMaybe(stream, state); }); } function prefinish(stream, state) { if (!state.prefinished && !state.finalCalled) { if (typeof stream._final === 'function') { state.pendingcb++; state.finalCalled = true; pna.nextTick(callFinal, stream, state); } else { state.prefinished = true; stream.emit('prefinish'); } } } function finishMaybe(stream, state) { var need = needFinish(state); if (need) { prefinish(stream, state); if (state.pendingcb === 0) { state.finished = true; stream.emit('finish'); } } return need; } function endWritable(stream, state, cb) { state.ending = true; finishMaybe(stream, state); if (cb) { if (state.finished) pna.nextTick(cb);else stream.once('finish', cb); } state.ended = true; stream.writable = false; } function onCorkedFinish(corkReq, state, err) { var entry = corkReq.entry; corkReq.entry = null; while (entry) { var cb = entry.callback; state.pendingcb--; cb(err); entry = entry.next; } if (state.corkedRequestsFree) { state.corkedRequestsFree.next = corkReq; } else { state.corkedRequestsFree = corkReq; } } Object.defineProperty(Writable.prototype, 'destroyed', { get: function () { if (this._writableState === undefined) { return false; } return this._writableState.destroyed; }, set: function (value) { // we ignore the value if the stream // has not been initialized yet if (!this._writableState) { return; } // backward compatibility, the user is explicitly // managing destroyed this._writableState.destroyed = value; } }); Writable.prototype.destroy = destroyImpl.destroy; Writable.prototype._undestroy = destroyImpl.undestroy; Writable.prototype._destroy = function (err, cb) { this.end(); cb(err); }; /***/ }), /* 71 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; // 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. /**/ var Buffer = __webpack_require__(29).Buffer; /**/ var isEncoding = Buffer.isEncoding || function (encoding) { encoding = '' + encoding; switch (encoding && encoding.toLowerCase()) { case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw': return true; default: return false; } }; function _normalizeEncoding(enc) { if (!enc) return 'utf8'; var retried; while (true) { switch (enc) { case 'utf8': case 'utf-8': return 'utf8'; case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': return 'utf16le'; case 'latin1': case 'binary': return 'latin1'; case 'base64': case 'ascii': case 'hex': return enc; default: if (retried) return; // undefined enc = ('' + enc).toLowerCase(); retried = true; } } }; // Do not cache `Buffer.isEncoding` when checking encoding names as some // modules monkey-patch it to support additional encodings function normalizeEncoding(enc) { var nenc = _normalizeEncoding(enc); if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc); return nenc || enc; } // StringDecoder provides an interface for efficiently splitting a series of // buffers into a series of JS strings without breaking apart multi-byte // characters. exports.StringDecoder = StringDecoder; function StringDecoder(encoding) { this.encoding = normalizeEncoding(encoding); var nb; switch (this.encoding) { case 'utf16le': this.text = utf16Text; this.end = utf16End; nb = 4; break; case 'utf8': this.fillLast = utf8FillLast; nb = 4; break; case 'base64': this.text = base64Text; this.end = base64End; nb = 3; break; default: this.write = simpleWrite; this.end = simpleEnd; return; } this.lastNeed = 0; this.lastTotal = 0; this.lastChar = Buffer.allocUnsafe(nb); } StringDecoder.prototype.write = function (buf) { if (buf.length === 0) return ''; var r; var i; if (this.lastNeed) { r = this.fillLast(buf); if (r === undefined) return ''; i = this.lastNeed; this.lastNeed = 0; } else { i = 0; } if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i); return r || ''; }; StringDecoder.prototype.end = utf8End; // Returns only complete characters in a Buffer StringDecoder.prototype.text = utf8Text; // Attempts to complete a partial non-UTF-8 character using bytes from a Buffer StringDecoder.prototype.fillLast = function (buf) { if (this.lastNeed <= buf.length) { buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed); return this.lastChar.toString(this.encoding, 0, this.lastTotal); } buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length); this.lastNeed -= buf.length; }; // Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a // continuation byte. If an invalid byte is detected, -2 is returned. function utf8CheckByte(byte) { if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4; return byte >> 6 === 0x02 ? -1 : -2; } // Checks at most 3 bytes at the end of a Buffer in order to detect an // incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4) // needed to complete the UTF-8 character (if applicable) are returned. function utf8CheckIncomplete(self, buf, i) { var j = buf.length - 1; if (j < i) return 0; var nb = utf8CheckByte(buf[j]); if (nb >= 0) { if (nb > 0) self.lastNeed = nb - 1; return nb; } if (--j < i || nb === -2) return 0; nb = utf8CheckByte(buf[j]); if (nb >= 0) { if (nb > 0) self.lastNeed = nb - 2; return nb; } if (--j < i || nb === -2) return 0; nb = utf8CheckByte(buf[j]); if (nb >= 0) { if (nb > 0) { if (nb === 2) nb = 0;else self.lastNeed = nb - 3; } return nb; } return 0; } // Validates as many continuation bytes for a multi-byte UTF-8 character as // needed or are available. If we see a non-continuation byte where we expect // one, we "replace" the validated continuation bytes we've seen so far with // a single UTF-8 replacement character ('\ufffd'), to match v8's UTF-8 decoding // behavior. The continuation byte check is included three times in the case // where all of the continuation bytes for a character exist in the same buffer. // It is also done this way as a slight performance increase instead of using a // loop. function utf8CheckExtraBytes(self, buf, p) { if ((buf[0] & 0xC0) !== 0x80) { self.lastNeed = 0; return '\ufffd'; } if (self.lastNeed > 1 && buf.length > 1) { if ((buf[1] & 0xC0) !== 0x80) { self.lastNeed = 1; return '\ufffd'; } if (self.lastNeed > 2 && buf.length > 2) { if ((buf[2] & 0xC0) !== 0x80) { self.lastNeed = 2; return '\ufffd'; } } } } // Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer. function utf8FillLast(buf) { var p = this.lastTotal - this.lastNeed; var r = utf8CheckExtraBytes(this, buf, p); if (r !== undefined) return r; if (this.lastNeed <= buf.length) { buf.copy(this.lastChar, p, 0, this.lastNeed); return this.lastChar.toString(this.encoding, 0, this.lastTotal); } buf.copy(this.lastChar, p, 0, buf.length); this.lastNeed -= buf.length; } // Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a // partial character, the character's bytes are buffered until the required // number of bytes are available. function utf8Text(buf, i) { var total = utf8CheckIncomplete(this, buf, i); if (!this.lastNeed) return buf.toString('utf8', i); this.lastTotal = total; var end = buf.length - (total - this.lastNeed); buf.copy(this.lastChar, 0, end); return buf.toString('utf8', i, end); } // For UTF-8, a replacement character is added when ending on a partial // character. function utf8End(buf) { var r = buf && buf.length ? this.write(buf) : ''; if (this.lastNeed) return r + '\ufffd'; return r; } // UTF-16LE typically needs two bytes per character, but even if we have an even // number of bytes available, we need to check if we end on a leading/high // surrogate. In that case, we need to wait for the next two bytes in order to // decode the last character properly. function utf16Text(buf, i) { if ((buf.length - i) % 2 === 0) { var r = buf.toString('utf16le', i); if (r) { var c = r.charCodeAt(r.length - 1); if (c >= 0xD800 && c <= 0xDBFF) { this.lastNeed = 2; this.lastTotal = 4; this.lastChar[0] = buf[buf.length - 2]; this.lastChar[1] = buf[buf.length - 1]; return r.slice(0, -1); } } return r; } this.lastNeed = 1; this.lastTotal = 2; this.lastChar[0] = buf[buf.length - 1]; return buf.toString('utf16le', i, buf.length - 1); } // For UTF-16LE we do not explicitly append special replacement characters if we // end on a partial character, we simply let v8 handle that. function utf16End(buf) { var r = buf && buf.length ? this.write(buf) : ''; if (this.lastNeed) { var end = this.lastTotal - this.lastNeed; return r + this.lastChar.toString('utf16le', 0, end); } return r; } function base64Text(buf, i) { var n = (buf.length - i) % 3; if (n === 0) return buf.toString('base64', i); this.lastNeed = 3 - n; this.lastTotal = 3; if (n === 1) { this.lastChar[0] = buf[buf.length - 1]; } else { this.lastChar[0] = buf[buf.length - 2]; this.lastChar[1] = buf[buf.length - 1]; } return buf.toString('base64', i, buf.length - n); } function base64End(buf) { var r = buf && buf.length ? this.write(buf) : ''; if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed); return r; } // Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex) function simpleWrite(buf) { return buf.toString(this.encoding); } function simpleEnd(buf) { return buf && buf.length ? this.write(buf) : ''; } /***/ }), /* 72 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; // 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. // a transform stream is a readable/writable stream where you do // something with the data. Sometimes it's called a "filter", // but that's not a great name for it, since that implies a thing where // some bits pass through, and others are simply ignored. (That would // be a valid example of a transform, of course.) // // While the output is causally related to the input, it's not a // necessarily symmetric or synchronous transformation. For example, // a zlib stream might take multiple plain-text writes(), and then // emit a single compressed chunk some time in the future. // // Here's how this works: // // The Transform stream has all the aspects of the readable and writable // stream classes. When you write(chunk), that calls _write(chunk,cb) // internally, and returns false if there's a lot of pending writes // buffered up. When you call read(), that calls _read(n) until // there's enough pending readable data buffered up. // // In a transform stream, the written data is placed in a buffer. When // _read(n) is called, it transforms the queued up data, calling the // buffered _write cb's as it consumes chunks. If consuming a single // written chunk would result in multiple output chunks, then the first // outputted bit calls the readcb, and subsequent chunks just go into // the read buffer, and will cause it to emit 'readable' if necessary. // // This way, back-pressure is actually determined by the reading side, // since _read has to be called to start processing a new chunk. However, // a pathological inflate type of transform can cause excessive buffering // here. For example, imagine a stream where every byte of input is // interpreted as an integer from 0-255, and then results in that many // bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in // 1kb of data being output. In this case, you could write a very small // amount of input, and end up with a very large amount of output. In // such a pathological inflating mechanism, there'd be no way to tell // the system to stop doing the transform. A single 4MB write could // cause the system to run out of memory. // // However, even in such a pathological case, only a single written chunk // would be consumed, and then the rest would wait (un-transformed) until // the results of the previous transformed chunk were consumed. module.exports = Transform; var Duplex = __webpack_require__(18); /**/ var util = __webpack_require__(22); util.inherits = __webpack_require__(13); /**/ util.inherits(Transform, Duplex); function afterTransform(er, data) { var ts = this._transformState; ts.transforming = false; var cb = ts.writecb; if (!cb) { return this.emit('error', new Error('write callback called multiple times')); } ts.writechunk = null; ts.writecb = null; if (data != null) // single equals check for both `null` and `undefined` this.push(data); cb(er); var rs = this._readableState; rs.reading = false; if (rs.needReadable || rs.length < rs.highWaterMark) { this._read(rs.highWaterMark); } } function Transform(options) { if (!(this instanceof Transform)) return new Transform(options); Duplex.call(this, options); this._transformState = { afterTransform: afterTransform.bind(this), needTransform: false, transforming: false, writecb: null, writechunk: null, writeencoding: null }; // start out asking for a readable event once data is transformed. this._readableState.needReadable = true; // we have implemented the _read method, and done the other things // that Readable wants before the first _read call, so unset the // sync guard flag. this._readableState.sync = false; if (options) { if (typeof options.transform === 'function') this._transform = options.transform; if (typeof options.flush === 'function') this._flush = options.flush; } // When the writable side finishes, then flush out anything remaining. this.on('prefinish', prefinish); } function prefinish() { var _this = this; if (typeof this._flush === 'function') { this._flush(function (er, data) { done(_this, er, data); }); } else { done(this, null, null); } } Transform.prototype.push = function (chunk, encoding) { this._transformState.needTransform = false; return Duplex.prototype.push.call(this, chunk, encoding); }; // This is the part where you do stuff! // override this function in implementation classes. // 'chunk' is an input chunk. // // Call `push(newChunk)` to pass along transformed output // to the readable side. You may call 'push' zero or more times. // // Call `cb(err)` when you are done with this chunk. If you pass // an error, then that'll put the hurt on the whole operation. If you // never call cb(), then you'll never get another chunk. Transform.prototype._transform = function (chunk, encoding, cb) { throw new Error('_transform() is not implemented'); }; Transform.prototype._write = function (chunk, encoding, cb) { var ts = this._transformState; ts.writecb = cb; ts.writechunk = chunk; ts.writeencoding = encoding; if (!ts.transforming) { var rs = this._readableState; if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark); } }; // Doesn't matter what the args are here. // _transform does all the work. // That we got here means that the readable side wants more data. Transform.prototype._read = function (n) { var ts = this._transformState; if (ts.writechunk !== null && ts.writecb && !ts.transforming) { ts.transforming = true; this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform); } else { // mark that we need a transform, so that any data that comes in // will get processed, now that we've asked for it. ts.needTransform = true; } }; Transform.prototype._destroy = function (err, cb) { var _this2 = this; Duplex.prototype._destroy.call(this, err, function (err2) { cb(err2); _this2.emit('close'); }); }; function done(stream, er, data) { if (er) return stream.emit('error', er); if (data != null) // single equals check for both `null` and `undefined` stream.push(data); // if there's nothing in the write buffer, then that means // that nothing more will ever be provided if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0'); if (stream._transformState.transforming) throw new Error('Calling transform done when still transforming'); return stream.push(null); } /***/ }), /* 73 */ /***/ (function(module, exports) { /** * Has own property. * * @type {Function} */ var has = Object.prototype.hasOwnProperty /** * To string. * * @type {Function} */ var toString = Object.prototype.toString /** * Test whether a value is "empty". * * @param {Mixed} val * @return {Boolean} */ function isEmpty(val) { // Null and Undefined... if (val == null) return true // Booleans... if ('boolean' == typeof val) return false // Numbers... if ('number' == typeof val) return val === 0 // Strings... if ('string' == typeof val) return val.length === 0 // Functions... if ('function' == typeof val) return val.length === 0 // Arrays... if (Array.isArray(val)) return val.length === 0 // Errors... if (val instanceof Error) return val.message === '' // Objects... if (val.toString == toString) { switch (val.toString()) { // Maps, Sets, Files and Errors... case '[object File]': case '[object Map]': case '[object Set]': { return val.size === 0 } // Plain objects... case '[object Object]': { for (var key in val) { if (has.call(val, key)) return false } return true } } } // Anything else... return false } /** * Export `isEmpty`. * * @type {Function} */ module.exports = isEmpty /***/ }), /* 74 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports,'__esModule',{value:true});exports.isSpaceSeparator=isSpaceSeparator;exports.isIdStartChar=isIdStartChar;exports.isIdContinueChar=isIdContinueChar;exports.isDigit=isDigit;exports.isHexDigit=isHexDigit;var _unicode=__webpack_require__(196);var unicode=_interopRequireWildcard(_unicode);function _interopRequireWildcard(obj){if(obj&&obj.__esModule){return obj}else{var newObj={};if(obj!=null){for(var key in obj){if(Object.prototype.hasOwnProperty.call(obj,key))newObj[key]=obj[key]}}newObj.default=obj;return newObj}}function isSpaceSeparator(c){return unicode.Space_Separator.test(c)}function isIdStartChar(c){return c>='a'&&c<='z'||c>='A'&&c<='Z'||c==='$'||c==='_'||unicode.ID_Start.test(c)}function isIdContinueChar(c){return c>='a'&&c<='z'||c>='A'&&c<='Z'||c>='0'&&c<='9'||c==='$'||c==='_'||c==='\u200C'||c==='\u200D'||unicode.ID_Continue.test(c)}function isDigit(c){return /[0-9]/.test(c)}function isHexDigit(c){return /[0-9A-Fa-f]/.test(c)} /***/ }), /* 75 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var xtend = __webpack_require__(7) var inherits = __webpack_require__(13) module.exports = unherit /* Create a custom constructor which can be modified * without affecting the original class. */ function unherit(Super) { var result var key var value inherits(Of, Super) inherits(From, Of) /* Clone values. */ result = Of.prototype for (key in result) { value = result[key] if (value && typeof value === 'object') { result[key] = 'concat' in value ? value.concat() : xtend(value) } } return Of /* Constructor accepting a single argument, * which itself is an `arguments` object. */ function From(parameters) { return Super.apply(this, parameters) } /* Constructor accepting variadic arguments. */ function Of() { if (!(this instanceof Of)) { return new From(arguments) } return Super.apply(this, arguments) } } /***/ }), /* 76 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = factory /* Construct a state `toggler`: a function which inverses * `property` in context based on its current value. * The by `toggler` returned function restores that value. */ function factory(key, state, ctx) { return enter function enter() { var context = ctx || this var current = context[key] context[key] = !state return exit function exit() { context[key] = current } } } /***/ }), /* 77 */ /***/ (function(module) { module.exports = {"AElig":"Æ","AMP":"&","Aacute":"Á","Acirc":"Â","Agrave":"À","Aring":"Å","Atilde":"Ã","Auml":"Ä","COPY":"©","Ccedil":"Ç","ETH":"Ð","Eacute":"É","Ecirc":"Ê","Egrave":"È","Euml":"Ë","GT":">","Iacute":"Í","Icirc":"Î","Igrave":"Ì","Iuml":"Ï","LT":"<","Ntilde":"Ñ","Oacute":"Ó","Ocirc":"Ô","Ograve":"Ò","Oslash":"Ø","Otilde":"Õ","Ouml":"Ö","QUOT":"\"","REG":"®","THORN":"Þ","Uacute":"Ú","Ucirc":"Û","Ugrave":"Ù","Uuml":"Ü","Yacute":"Ý","aacute":"á","acirc":"â","acute":"´","aelig":"æ","agrave":"à","amp":"&","aring":"å","atilde":"ã","auml":"ä","brvbar":"¦","ccedil":"ç","cedil":"¸","cent":"¢","copy":"©","curren":"¤","deg":"°","divide":"÷","eacute":"é","ecirc":"ê","egrave":"è","eth":"ð","euml":"ë","frac12":"½","frac14":"¼","frac34":"¾","gt":">","iacute":"í","icirc":"î","iexcl":"¡","igrave":"ì","iquest":"¿","iuml":"ï","laquo":"«","lt":"<","macr":"¯","micro":"µ","middot":"·","nbsp":" ","not":"¬","ntilde":"ñ","oacute":"ó","ocirc":"ô","ograve":"ò","ordf":"ª","ordm":"º","oslash":"ø","otilde":"õ","ouml":"ö","para":"¶","plusmn":"±","pound":"£","quot":"\"","raquo":"»","reg":"®","sect":"§","shy":"­","sup1":"¹","sup2":"²","sup3":"³","szlig":"ß","thorn":"þ","times":"×","uacute":"ú","ucirc":"û","ugrave":"ù","uml":"¨","uuml":"ü","yacute":"ý","yen":"¥","yuml":"ÿ"}; /***/ }), /* 78 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = hexadecimal /* Check if the given character code, or the character * code at the first character, is hexadecimal. */ function hexadecimal(character) { var code = typeof character === 'string' ? character.charCodeAt(0) : character return ( (code >= 97 /* a */ && code <= 102) /* z */ || (code >= 65 /* A */ && code <= 70) /* Z */ || (code >= 48 /* A */ && code <= 57) /* Z */ ) } /***/ }), /* 79 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var alphabetical = __webpack_require__(80) var decimal = __webpack_require__(23) module.exports = alphanumerical /* Check if the given character code, or the character * code at the first character, is alphanumerical. */ function alphanumerical(character) { return alphabetical(character) || decimal(character) } /***/ }), /* 80 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = alphabetical /* Check if the given character code, or the character * code at the first character, is alphabetical. */ function alphabetical(character) { var code = typeof character === 'string' ? character.charCodeAt(0) : character return ( (code >= 97 && code <= 122) /* a-z */ || (code >= 65 && code <= 90) /* A-Z */ ) } /***/ }), /* 81 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = escapes var defaults = [ '\\', '`', '*', '{', '}', '[', ']', '(', ')', '#', '+', '-', '.', '!', '_', '>' ] var gfm = defaults.concat(['~', '|']) var commonmark = gfm.concat([ '\n', '"', '$', '%', '&', "'", ',', '/', ':', ';', '<', '=', '?', '@', '^' ]) escapes.default = defaults escapes.gfm = gfm escapes.commonmark = commonmark /* Get markdown escapes. */ function escapes(options) { var settings = options || {} if (settings.commonmark) { return commonmark } return settings.gfm ? gfm : defaults } /***/ }), /* 82 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = { position: true, gfm: true, commonmark: false, footnotes: false, pedantic: false, blocks: __webpack_require__(218) } /***/ }), /* 83 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = indentation var tab = '\t' var space = ' ' var spaceSize = 1 var tabSize = 4 // Gets indentation information for a line. function indentation(value) { var index = 0 var indent = 0 var character = value.charAt(index) var stops = {} var size while (character === tab || character === space) { size = character === tab ? tabSize : spaceSize indent += size if (size > 1) { indent = Math.floor(indent / size) * size } stops[indent] = index character = value.charAt(++index) } return {indent: indent, stops: stops} } /***/ }), /* 84 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var attributeName = '[a-zA-Z_:][a-zA-Z0-9:._-]*' var unquoted = '[^"\'=<>`\\u0000-\\u0020]+' var singleQuoted = "'[^']*'" var doubleQuoted = '"[^"]*"' var attributeValue = '(?:' + unquoted + '|' + singleQuoted + '|' + doubleQuoted + ')' var attribute = '(?:\\s+' + attributeName + '(?:\\s*=\\s*' + attributeValue + ')?)' var openTag = '<[A-Za-z][A-Za-z0-9\\-]*' + attribute + '*\\s*\\/?>' var closeTag = '<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>' var comment = '|' var processing = '<[?].*?[?]>' var declaration = ']*>' var cdata = '' exports.openCloseTag = new RegExp('^(?:' + openTag + '|' + closeTag + ')') exports.tag = new RegExp( '^(?:' + openTag + '|' + closeTag + '|' + comment + '|' + processing + '|' + declaration + '|' + cdata + ')' ) /***/ }), /* 85 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = locate function locate(value, fromIndex) { return value.indexOf('<', fromIndex) } /***/ }), /* 86 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = locate function locate(value, fromIndex) { var link = value.indexOf('[', fromIndex) var image = value.indexOf('![', fromIndex) if (image === -1) { return link } // Link can never be `-1` if an image is found, so we don’t need to check // for that :) return link < image ? link : image } /***/ }), /* 87 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = identity function identity(value) { return value } /***/ }), /* 88 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = { gfm: true, commonmark: false, pedantic: false, entities: 'false', setext: false, closeAtx: false, looseTable: false, spacedTable: true, paddedTable: true, stringLength: stringLength, incrementListMarker: true, fences: false, fence: '`', bullet: '-', listItemIndent: 'tab', rule: '*', ruleSpaces: true, ruleRepetition: 3, strong: '*', emphasis: '_' } function stringLength(value) { return value.length } /***/ }), /* 89 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var decode = __webpack_require__(30) module.exports = length var ampersand = '&' // Returns the length of HTML entity that is a prefix of the given string // (excluding the ampersand), 0 if it does not start with an entity. function length(value) { var prefix /* istanbul ignore if - Currently also tested for at implemention, but we * keep it here because that’s proper. */ if (value.charAt(0) !== ampersand) { return 0 } prefix = value.split(ampersand, 2).join(ampersand) return prefix.length - decode(prefix).length } /***/ }), /* 90 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var repeat = __webpack_require__(10) module.exports = pad var lineFeed = '\n' var space = ' ' var tabSize = 4 // Pad `value` with `level * tabSize` spaces. Respects lines. Ignores empty // lines. function pad(value, level) { var values = value.split(lineFeed) var index = values.length var padding = repeat(space, level * tabSize) while (index--) { if (values[index].length !== 0) { values[index] = padding + values[index] } } return values.join(lineFeed) } /***/ }), /* 91 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /* Expose. */ module.exports = longestStreak; /* Get the count of the longest repeating streak of * `character` in `value`. */ function longestStreak(value, character) { var count = 0; var maximum = 0; var expected; var index; if (typeof character !== 'string' || character.length !== 1) { throw new Error('Expected character'); } value = String(value); index = value.indexOf(character); expected = index; while (index !== -1) { count++; if (index === expected) { if (count > maximum) { maximum = count; } } else { count = 1; } expected = index + 1; index = value.indexOf(character, expected); } return maximum; } /***/ }), /* 92 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = label var leftSquareBracket = '[' var rightSquareBracket = ']' var shortcut = 'shortcut' var collapsed = 'collapsed' // Stringify a reference label. // Because link references are easily, mistakingly, created (for example, // `[foo]`), reference nodes have an extra property depicting how it looked in // the original document, so stringification can cause minimal changes. function label(node) { var type = node.referenceType if (type === shortcut) { return '' } return ( leftSquareBracket + (type === collapsed ? '' : node.label || node.identifier) + rightSquareBracket ) } /***/ }), /* 93 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * @author Titus Wormer * @copyright 2015 Titus Wormer * @license MIT * @module hard-break-spaces * @fileoverview * Warn when too many spaces are used to create a hard break. * * @example {"name": "valid.md"} * * Lorem ipsum·· * dolor sit amet * * @example {"name": "invalid.md", "label": "input"} * * Lorem ipsum··· * dolor sit amet. * * @example {"name": "invalid.md", "label": "output"} * * 1:12-2:1: Use two spaces for hard line breaks */ var rule = __webpack_require__(0) var visit = __webpack_require__(1) var position = __webpack_require__(3) var generated = __webpack_require__(2) module.exports = rule('remark-lint:hard-break-spaces', hardBreakSpaces) var reason = 'Use two spaces for hard line breaks' function hardBreakSpaces(tree, file) { var contents = String(file) visit(tree, 'break', visitor) function visitor(node) { var value if (!generated(node)) { value = contents .slice(position.start(node).offset, position.end(node).offset) .split('\n', 1)[0] .replace(/\r$/, '') if (value.length > 2) { file.message(reason, node) } } } } /***/ }), /* 94 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = style function style(node, relative) { var last = node.children[node.children.length - 1] var depth = node.depth var pos = node && node.position && node.position.end var final = last && last.position && last.position.end if (!pos) { return null } /* This can only occur for `'atx'` and `'atx-closed'` * headings. This might incorrectly match `'atx'` * headings with lots of trailing white space as an * `'atx-closed'` heading. */ if (!last) { if (pos.column - 1 <= depth * 2) { return consolidate(depth, relative) } return 'atx-closed' } if (final.line + 1 === pos.line) { return 'setext' } if (final.column + depth < pos.column) { return 'atx-closed' } return consolidate(depth, relative) } /* Get the probable style of an atx-heading, depending on * preferred style. */ function consolidate(depth, relative) { return depth < 3 ? 'atx' : relative === 'atx' || relative === 'setext' ? relative : null } /***/ }), /* 95 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; const engine = __webpack_require__(96); const options = __webpack_require__(191); const extensions = __webpack_require__(199); const processor = __webpack_require__(201); const proc = __webpack_require__(302); const cli = __webpack_require__(303); const { plugins } = __webpack_require__(304); const args = { processor: processor, name: proc.name, description: cli.description, version: [ proc.name + ': ' + proc.version, cli.name + ': ' + cli.version ].join(', '), ignoreName: '.' + proc.name + 'ignore', extensions: extensions }; const config = options(process.argv.slice(2), args); config.detectConfig = false; config.plugins = plugins; engine(config, function done(err, code) { if (err) console.error(err); process.exit(code); }); /***/ }), /* 96 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var PassThrough = __webpack_require__(32).PassThrough; var statistics = __webpack_require__(12); var fileSetPipeline = __webpack_require__(97); module.exports = run; /* Run the file set pipeline once. * `callback` is invoked with a fatal error, * or with a status code (`0` on success, `1` on failure). */ function run(options, callback) { var settings = {}; var stdin = new PassThrough(); var tree; var detectConfig; var hasConfig; var detectIgnore; var hasIgnore; try { stdin = process.stdin; } catch (err) { /* Obscure bug in Node (seen on windows): * - https://github.com/nodejs/node/blob/f856234/lib/internal/ * process/stdio.js#L82; * - https://github.com/AtomLinter/linter-markdown/pull/85. */ } if (!callback) { throw new Error('Missing `callback`'); } if (!options || !options.processor) { return next(new Error('Missing `processor`')); } /* Processor. */ settings.processor = options.processor; /* Path to run as. */ settings.cwd = options.cwd || process.cwd(); /* Input. */ settings.files = options.files || []; settings.extensions = (options.extensions || []).map(function (extension) { return extension.charAt(0) === '.' ? extension : '.' + extension; }); settings.filePath = options.filePath || null; settings.streamIn = options.streamIn || stdin; /* Output. */ settings.streamOut = options.streamOut || process.stdout; settings.streamError = options.streamError || process.stderr; settings.alwaysStringify = options.alwaysStringify; settings.output = options.output; settings.out = options.out; /* Null overwrites config settings, `undefined` doesn’t. */ if (settings.output === null || settings.output === undefined) { settings.output = undefined; } if (settings.output && settings.out) { return next(new Error('Cannot accept both `output` and `out`')); } /* Process phase management. */ tree = options.tree || false; settings.treeIn = options.treeIn; settings.treeOut = options.treeOut; settings.inspect = options.inspect; if (settings.treeIn === null || settings.treeIn === undefined) { settings.treeIn = tree; } if (settings.treeOut === null || settings.treeOut === undefined) { settings.treeOut = tree; } /* Configuration. */ detectConfig = options.detectConfig; hasConfig = Boolean(options.rcName || options.packageField); if (detectConfig && !hasConfig) { return next(new Error( 'Missing `rcName` or `packageField` with `detectConfig`' )); } settings.detectConfig = detectConfig === null || detectConfig === undefined ? hasConfig : detectConfig; settings.rcName = options.rcName || null; settings.rcPath = options.rcPath || null; settings.packageField = options.packageField || null; settings.settings = options.settings || {}; settings.configTransform = options.configTransform; settings.defaultConfig = options.defaultConfig; /* Ignore. */ detectIgnore = options.detectIgnore; hasIgnore = Boolean(options.ignoreName); settings.detectIgnore = detectIgnore === null || detectIgnore === undefined ? hasIgnore : detectIgnore; settings.ignoreName = options.ignoreName || null; settings.ignorePath = options.ignorePath || null; settings.silentlyIgnore = Boolean(options.silentlyIgnore); if (detectIgnore && !hasIgnore) { return next(new Error('Missing `ignoreName` with `detectIgnore`')); } /* Plug-ins. */ settings.pluginPrefix = options.pluginPrefix || null; settings.plugins = options.plugins || {}; /* Reporting. */ settings.reporter = options.reporter || null; settings.reporterOptions = options.reporterOptions || null; settings.color = options.color || false; settings.silent = options.silent || false; settings.quiet = options.quiet || false; settings.frail = options.frail || false; /* Process. */ fileSetPipeline.run({files: options.files || []}, settings, next); function next(err, context) { var stats = statistics((context || {}).files); var failed = Boolean(settings.frail ? stats.fatal || stats.warn : stats.fatal); if (err) { callback(err); } else { callback(null, failed ? 1 : 0, context); } } } /***/ }), /* 97 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var trough = __webpack_require__(24); var configure = __webpack_require__(99); var fileSystem = __webpack_require__(144); var stdin = __webpack_require__(160); var transform = __webpack_require__(169); var log = __webpack_require__(183); module.exports = trough() .use(configure) .use(fileSystem) .use(stdin) .use(transform) .use(log); /***/ }), /* 98 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var slice = [].slice module.exports = wrap /* Wrap `fn`. Can be sync or async; return a promise, * receive a completion handler, return new values and * errors. */ function wrap(fn, callback) { var invoked return wrapped function wrapped() { var params = slice.call(arguments, 0) var callback = fn.length > params.length var result if (callback) { params.push(done) } try { result = fn.apply(null, params) } catch (err) { /* Well, this is quite the pickle. `fn` received * a callback and invoked it (thus continuing the * pipeline), but later also threw an error. * We’re not about to restart the pipeline again, * so the only thing left to do is to throw the * thing instea. */ if (callback && invoked) { throw err } return done(err) } if (!callback) { if (result && typeof result.then === 'function') { result.then(then, done) } else if (result instanceof Error) { done(result) } else { then(result) } } } /* Invoke `next`, only once. */ function done() { if (!invoked) { invoked = true callback.apply(null, arguments) } } /* Invoke `done` with one value. * Tracks if an error is passed, too. */ function then(value) { done(null, value) } } /***/ }), /* 99 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var Configuration = __webpack_require__(100); module.exports = configure; function configure(context, settings) { context.configuration = new Configuration(settings); } /***/ }), /* 100 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /* WEBPACK VAR INJECTION */(function(module) { var path = __webpack_require__(4); var Module = __webpack_require__(47); var yaml = __webpack_require__(101); var json = __webpack_require__(51); var debug = __webpack_require__(9)('unified-engine:configuration'); var resolve = __webpack_require__(55).resolve; var fault = __webpack_require__(34); var xtend = __webpack_require__(7); var object = __webpack_require__(35); var string = __webpack_require__(17); var func = __webpack_require__(26); var FindUp = __webpack_require__(57); module.exports = Config; var own = {}.hasOwnProperty; var extname = path.extname; var basename = path.basename; var dirname = path.dirname; var relative = path.relative; var loaders = { '.json': loadJSON, '.js': loadScript, '.yaml': loadYAML, '.yml': loadYAML }; var defaultLoader = loadJSON; Config.prototype.load = load; function Config(options) { var rcName = options.rcName; var packageField = options.packageField; var names = []; this.cwd = options.cwd; this.packageField = options.packageField; this.pluginPrefix = options.pluginPrefix; this.configTransform = options.configTransform; this.defaultConfig = options.defaultConfig; if (rcName) { names.push(rcName, rcName + '.js', rcName + '.yml', rcName + '.yaml'); debug('Looking for `%s` configuration files', names); } if (packageField) { names.push('package.json'); debug('Looking for `%s` fields in `package.json` files', packageField); } this.given = {settings: options.settings, plugins: options.plugins}; this.create = create.bind(this); this.findUp = new FindUp({ filePath: options.rcPath, cwd: options.cwd, detect: options.detectConfig, names: names, create: this.create }); } function load(filePath, callback) { var searchPath = filePath || path.resolve(this.cwd, 'stdin.js'); var self = this; self.findUp.load(searchPath, done); function done(err, res) { if (err || res) { return callback(err, res); } callback(null, self.create()); } } function create(buf, filePath) { var self = this; var transform = self.configTransform; var defaults = self.defaultConfig; var fn = (filePath && loaders[extname(filePath)]) || defaultLoader; var options = {prefix: self.pluginPrefix, cwd: self.cwd}; var result = {settings: {}, plugins: []}; var contents = buf ? fn.apply(self, arguments) : undefined; if (transform && contents !== undefined) { contents = transform(contents, filePath); } /* Exit if we did find a `package.json`, but it doesn’t have configuration. */ if (buf && contents === undefined && basename(filePath) === 'package.json') { return; } if (contents === undefined) { if (defaults) { merge(result, defaults, null, xtend(options, {root: self.cwd})); } } else { merge(result, contents, null, xtend(options, {root: dirname(filePath)})); } merge(result, self.given, null, xtend(options, {root: self.cwd})); return result; } /* Basically `Module.prototype.load`, but for a buffer instead * of a filepath. */ function loadScript(buf, filePath) { var submodule = Module._cache[filePath]; if (!submodule) { submodule = new Module(filePath, module); submodule.filename = filePath; submodule.paths = Module._nodeModulePaths(dirname(filePath)); submodule._compile(String(buf), filePath); submodule.loaded = true; Module._cache[filePath] = submodule; } return submodule.exports; } function loadYAML(buf, filePath) { return yaml.safeLoad(buf, {filename: basename(filePath)}); } function loadJSON(buf, filePath) { var result = json(buf, filePath); if (basename(filePath) === 'package.json') { result = result[this.packageField]; } return result; } function merge(target, raw, val, options) { var root = options.root; var cwd = options.cwd; var prefix = options.prefix; if (object(raw)) { addPreset(raw); } else { throw new Error('Expected preset, not `' + raw + '`'); } return target; function addPreset(result) { var plugins = result.plugins; if (plugins === null || plugins === undefined) { /* Empty. */ } else if (object(plugins)) { if ('length' in plugins) { addEach(plugins); } else { addIn(plugins); } } else { throw new Error('Expected a list or object of plugins, not `' + plugins + '`'); } target.settings = xtend(target.settings, result.settings); } function addEach(result) { var length = result.length; var index = -1; var value; while (++index < length) { value = result[index]; if (object(value) && 'length' in value) { use.apply(null, value); } else { use(value); } } } function addIn(result) { var key; for (key in result) { use(key, result[key]); } } function use(usable, value) { if (string(usable)) { addModule(usable, value); } else if (func(usable)) { addPlugin(usable, value); } else { merge(target, usable, value, options); } } function addModule(id, value) { var fp = resolve(id, {cwd: root, prefix: prefix}); var res; if (fp) { try { res = __webpack_require__(143)(fp); // eslint-disable-line import/no-dynamic-require } catch (err) { throw fault('Cannot parse script `%s`\n%s', relative(root, fp), err.stack); } try { if (func(res)) { addPlugin(res, value); } else { merge(target, res, value, xtend(options, {root: dirname(fp)})); } } catch (err) { throw fault('Error: Expected preset or plugin, not %s, at `%s`', res, relative(root, fp)); } } else { fp = relative(cwd, path.resolve(root, id)); addPlugin(failingModule(fp, new Error('Could not find module `' + id + '`')), value); } } function addPlugin(result, value) { var entry = find(target.plugins, result); if (entry) { reconfigure(entry, value); } else { target.plugins.push([result, value]); } } } function reconfigure(entry, value) { if (value !== false && entry[1] !== false && object(value)) { value = xtend(entry[1], value); } entry[1] = value; } function find(entries, plugin) { var length = entries.length; var index = -1; var entry; while (++index < length) { entry = entries[index]; if (entry[0] === plugin) { return entry; } } } function failingModule(id, err) { var cache = failingModule.cache || (failingModule.cache = {}); var submodule = own.call(cache, id) ? cache[id] : (cache[id] = fail); return submodule; function fail() { throw err; } } /* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(46)(module))) /***/ }), /* 101 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var yaml = __webpack_require__(102); module.exports = yaml; /***/ }), /* 102 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var loader = __webpack_require__(103); var dumper = __webpack_require__(122); function deprecated(name) { return function () { throw new Error('Function ' + name + ' is deprecated and cannot be used.'); }; } module.exports.Type = __webpack_require__(5); module.exports.Schema = __webpack_require__(16); module.exports.FAILSAFE_SCHEMA = __webpack_require__(33); module.exports.JSON_SCHEMA = __webpack_require__(49); module.exports.CORE_SCHEMA = __webpack_require__(48); module.exports.DEFAULT_SAFE_SCHEMA = __webpack_require__(21); module.exports.DEFAULT_FULL_SCHEMA = __webpack_require__(25); module.exports.load = loader.load; module.exports.loadAll = loader.loadAll; module.exports.safeLoad = loader.safeLoad; module.exports.safeLoadAll = loader.safeLoadAll; module.exports.dump = dumper.dump; module.exports.safeDump = dumper.safeDump; module.exports.YAMLException = __webpack_require__(20); // Deprecated schema names from JS-YAML 2.0.x module.exports.MINIMAL_SCHEMA = __webpack_require__(33); module.exports.SAFE_SCHEMA = __webpack_require__(21); module.exports.DEFAULT_SCHEMA = __webpack_require__(25); // Deprecated functions from JS-YAML 1.x.x module.exports.scan = deprecated('scan'); module.exports.parse = deprecated('parse'); module.exports.compose = deprecated('compose'); module.exports.addConstructor = deprecated('addConstructor'); /***/ }), /* 103 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /*eslint-disable max-len,no-use-before-define*/ var common = __webpack_require__(15); var YAMLException = __webpack_require__(20); var Mark = __webpack_require__(104); var DEFAULT_SAFE_SCHEMA = __webpack_require__(21); var DEFAULT_FULL_SCHEMA = __webpack_require__(25); var _hasOwnProperty = Object.prototype.hasOwnProperty; var CONTEXT_FLOW_IN = 1; var CONTEXT_FLOW_OUT = 2; var CONTEXT_BLOCK_IN = 3; var CONTEXT_BLOCK_OUT = 4; var CHOMPING_CLIP = 1; var CHOMPING_STRIP = 2; var CHOMPING_KEEP = 3; var PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/; var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/; var PATTERN_FLOW_INDICATORS = /[,\[\]\{\}]/; var PATTERN_TAG_HANDLE = /^(?:!|!!|![a-z\-]+!)$/i; var PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i; function is_EOL(c) { return (c === 0x0A/* LF */) || (c === 0x0D/* CR */); } function is_WHITE_SPACE(c) { return (c === 0x09/* Tab */) || (c === 0x20/* Space */); } function is_WS_OR_EOL(c) { return (c === 0x09/* Tab */) || (c === 0x20/* Space */) || (c === 0x0A/* LF */) || (c === 0x0D/* CR */); } function is_FLOW_INDICATOR(c) { return c === 0x2C/* , */ || c === 0x5B/* [ */ || c === 0x5D/* ] */ || c === 0x7B/* { */ || c === 0x7D/* } */; } function fromHexCode(c) { var lc; if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) { return c - 0x30; } /*eslint-disable no-bitwise*/ lc = c | 0x20; if ((0x61/* a */ <= lc) && (lc <= 0x66/* f */)) { return lc - 0x61 + 10; } return -1; } function escapedHexLen(c) { if (c === 0x78/* x */) { return 2; } if (c === 0x75/* u */) { return 4; } if (c === 0x55/* U */) { return 8; } return 0; } function fromDecimalCode(c) { if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) { return c - 0x30; } return -1; } function simpleEscapeSequence(c) { /* eslint-disable indent */ return (c === 0x30/* 0 */) ? '\x00' : (c === 0x61/* a */) ? '\x07' : (c === 0x62/* b */) ? '\x08' : (c === 0x74/* t */) ? '\x09' : (c === 0x09/* Tab */) ? '\x09' : (c === 0x6E/* n */) ? '\x0A' : (c === 0x76/* v */) ? '\x0B' : (c === 0x66/* f */) ? '\x0C' : (c === 0x72/* r */) ? '\x0D' : (c === 0x65/* e */) ? '\x1B' : (c === 0x20/* Space */) ? ' ' : (c === 0x22/* " */) ? '\x22' : (c === 0x2F/* / */) ? '/' : (c === 0x5C/* \ */) ? '\x5C' : (c === 0x4E/* N */) ? '\x85' : (c === 0x5F/* _ */) ? '\xA0' : (c === 0x4C/* L */) ? '\u2028' : (c === 0x50/* P */) ? '\u2029' : ''; } function charFromCodepoint(c) { if (c <= 0xFFFF) { return String.fromCharCode(c); } // Encode UTF-16 surrogate pair // https://en.wikipedia.org/wiki/UTF-16#Code_points_U.2B010000_to_U.2B10FFFF return String.fromCharCode( ((c - 0x010000) >> 10) + 0xD800, ((c - 0x010000) & 0x03FF) + 0xDC00 ); } var simpleEscapeCheck = new Array(256); // integer, for fast access var simpleEscapeMap = new Array(256); for (var i = 0; i < 256; i++) { simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0; simpleEscapeMap[i] = simpleEscapeSequence(i); } function State(input, options) { this.input = input; this.filename = options['filename'] || null; this.schema = options['schema'] || DEFAULT_FULL_SCHEMA; this.onWarning = options['onWarning'] || null; this.legacy = options['legacy'] || false; this.json = options['json'] || false; this.listener = options['listener'] || null; this.implicitTypes = this.schema.compiledImplicit; this.typeMap = this.schema.compiledTypeMap; this.length = input.length; this.position = 0; this.line = 0; this.lineStart = 0; this.lineIndent = 0; this.documents = []; /* this.version; this.checkLineBreaks; this.tagMap; this.anchorMap; this.tag; this.anchor; this.kind; this.result;*/ } function generateError(state, message) { return new YAMLException( message, new Mark(state.filename, state.input, state.position, state.line, (state.position - state.lineStart))); } function throwError(state, message) { throw generateError(state, message); } function throwWarning(state, message) { if (state.onWarning) { state.onWarning.call(null, generateError(state, message)); } } var directiveHandlers = { YAML: function handleYamlDirective(state, name, args) { var match, major, minor; if (state.version !== null) { throwError(state, 'duplication of %YAML directive'); } if (args.length !== 1) { throwError(state, 'YAML directive accepts exactly one argument'); } match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]); if (match === null) { throwError(state, 'ill-formed argument of the YAML directive'); } major = parseInt(match[1], 10); minor = parseInt(match[2], 10); if (major !== 1) { throwError(state, 'unacceptable YAML version of the document'); } state.version = args[0]; state.checkLineBreaks = (minor < 2); if (minor !== 1 && minor !== 2) { throwWarning(state, 'unsupported YAML version of the document'); } }, TAG: function handleTagDirective(state, name, args) { var handle, prefix; if (args.length !== 2) { throwError(state, 'TAG directive accepts exactly two arguments'); } handle = args[0]; prefix = args[1]; if (!PATTERN_TAG_HANDLE.test(handle)) { throwError(state, 'ill-formed tag handle (first argument) of the TAG directive'); } if (_hasOwnProperty.call(state.tagMap, handle)) { throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle'); } if (!PATTERN_TAG_URI.test(prefix)) { throwError(state, 'ill-formed tag prefix (second argument) of the TAG directive'); } state.tagMap[handle] = prefix; } }; function captureSegment(state, start, end, checkJson) { var _position, _length, _character, _result; if (start < end) { _result = state.input.slice(start, end); if (checkJson) { for (_position = 0, _length = _result.length; _position < _length; _position += 1) { _character = _result.charCodeAt(_position); if (!(_character === 0x09 || (0x20 <= _character && _character <= 0x10FFFF))) { throwError(state, 'expected valid JSON character'); } } } else if (PATTERN_NON_PRINTABLE.test(_result)) { throwError(state, 'the stream contains non-printable characters'); } state.result += _result; } } function mergeMappings(state, destination, source, overridableKeys) { var sourceKeys, key, index, quantity; if (!common.isObject(source)) { throwError(state, 'cannot merge mappings; the provided source object is unacceptable'); } sourceKeys = Object.keys(source); for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) { key = sourceKeys[index]; if (!_hasOwnProperty.call(destination, key)) { destination[key] = source[key]; overridableKeys[key] = true; } } } function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startPos) { var index, quantity; keyNode = String(keyNode); if (_result === null) { _result = {}; } if (keyTag === 'tag:yaml.org,2002:merge') { if (Array.isArray(valueNode)) { for (index = 0, quantity = valueNode.length; index < quantity; index += 1) { mergeMappings(state, _result, valueNode[index], overridableKeys); } } else { mergeMappings(state, _result, valueNode, overridableKeys); } } else { if (!state.json && !_hasOwnProperty.call(overridableKeys, keyNode) && _hasOwnProperty.call(_result, keyNode)) { state.line = startLine || state.line; state.position = startPos || state.position; throwError(state, 'duplicated mapping key'); } _result[keyNode] = valueNode; delete overridableKeys[keyNode]; } return _result; } function readLineBreak(state) { var ch; ch = state.input.charCodeAt(state.position); if (ch === 0x0A/* LF */) { state.position++; } else if (ch === 0x0D/* CR */) { state.position++; if (state.input.charCodeAt(state.position) === 0x0A/* LF */) { state.position++; } } else { throwError(state, 'a line break is expected'); } state.line += 1; state.lineStart = state.position; } function skipSeparationSpace(state, allowComments, checkIndent) { var lineBreaks = 0, ch = state.input.charCodeAt(state.position); while (ch !== 0) { while (is_WHITE_SPACE(ch)) { ch = state.input.charCodeAt(++state.position); } if (allowComments && ch === 0x23/* # */) { do { ch = state.input.charCodeAt(++state.position); } while (ch !== 0x0A/* LF */ && ch !== 0x0D/* CR */ && ch !== 0); } if (is_EOL(ch)) { readLineBreak(state); ch = state.input.charCodeAt(state.position); lineBreaks++; state.lineIndent = 0; while (ch === 0x20/* Space */) { state.lineIndent++; ch = state.input.charCodeAt(++state.position); } } else { break; } } if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) { throwWarning(state, 'deficient indentation'); } return lineBreaks; } function testDocumentSeparator(state) { var _position = state.position, ch; ch = state.input.charCodeAt(_position); // Condition state.position === state.lineStart is tested // in parent on each call, for efficiency. No needs to test here again. if ((ch === 0x2D/* - */ || ch === 0x2E/* . */) && ch === state.input.charCodeAt(_position + 1) && ch === state.input.charCodeAt(_position + 2)) { _position += 3; ch = state.input.charCodeAt(_position); if (ch === 0 || is_WS_OR_EOL(ch)) { return true; } } return false; } function writeFoldedLines(state, count) { if (count === 1) { state.result += ' '; } else if (count > 1) { state.result += common.repeat('\n', count - 1); } } function readPlainScalar(state, nodeIndent, withinFlowCollection) { var preceding, following, captureStart, captureEnd, hasPendingContent, _line, _lineStart, _lineIndent, _kind = state.kind, _result = state.result, ch; ch = state.input.charCodeAt(state.position); if (is_WS_OR_EOL(ch) || is_FLOW_INDICATOR(ch) || ch === 0x23/* # */ || ch === 0x26/* & */ || ch === 0x2A/* * */ || ch === 0x21/* ! */ || ch === 0x7C/* | */ || ch === 0x3E/* > */ || ch === 0x27/* ' */ || ch === 0x22/* " */ || ch === 0x25/* % */ || ch === 0x40/* @ */ || ch === 0x60/* ` */) { return false; } if (ch === 0x3F/* ? */ || ch === 0x2D/* - */) { following = state.input.charCodeAt(state.position + 1); if (is_WS_OR_EOL(following) || withinFlowCollection && is_FLOW_INDICATOR(following)) { return false; } } state.kind = 'scalar'; state.result = ''; captureStart = captureEnd = state.position; hasPendingContent = false; while (ch !== 0) { if (ch === 0x3A/* : */) { following = state.input.charCodeAt(state.position + 1); if (is_WS_OR_EOL(following) || withinFlowCollection && is_FLOW_INDICATOR(following)) { break; } } else if (ch === 0x23/* # */) { preceding = state.input.charCodeAt(state.position - 1); if (is_WS_OR_EOL(preceding)) { break; } } else if ((state.position === state.lineStart && testDocumentSeparator(state)) || withinFlowCollection && is_FLOW_INDICATOR(ch)) { break; } else if (is_EOL(ch)) { _line = state.line; _lineStart = state.lineStart; _lineIndent = state.lineIndent; skipSeparationSpace(state, false, -1); if (state.lineIndent >= nodeIndent) { hasPendingContent = true; ch = state.input.charCodeAt(state.position); continue; } else { state.position = captureEnd; state.line = _line; state.lineStart = _lineStart; state.lineIndent = _lineIndent; break; } } if (hasPendingContent) { captureSegment(state, captureStart, captureEnd, false); writeFoldedLines(state, state.line - _line); captureStart = captureEnd = state.position; hasPendingContent = false; } if (!is_WHITE_SPACE(ch)) { captureEnd = state.position + 1; } ch = state.input.charCodeAt(++state.position); } captureSegment(state, captureStart, captureEnd, false); if (state.result) { return true; } state.kind = _kind; state.result = _result; return false; } function readSingleQuotedScalar(state, nodeIndent) { var ch, captureStart, captureEnd; ch = state.input.charCodeAt(state.position); if (ch !== 0x27/* ' */) { return false; } state.kind = 'scalar'; state.result = ''; state.position++; captureStart = captureEnd = state.position; while ((ch = state.input.charCodeAt(state.position)) !== 0) { if (ch === 0x27/* ' */) { captureSegment(state, captureStart, state.position, true); ch = state.input.charCodeAt(++state.position); if (ch === 0x27/* ' */) { captureStart = state.position; state.position++; captureEnd = state.position; } else { return true; } } else if (is_EOL(ch)) { captureSegment(state, captureStart, captureEnd, true); writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent)); captureStart = captureEnd = state.position; } else if (state.position === state.lineStart && testDocumentSeparator(state)) { throwError(state, 'unexpected end of the document within a single quoted scalar'); } else { state.position++; captureEnd = state.position; } } throwError(state, 'unexpected end of the stream within a single quoted scalar'); } function readDoubleQuotedScalar(state, nodeIndent) { var captureStart, captureEnd, hexLength, hexResult, tmp, ch; ch = state.input.charCodeAt(state.position); if (ch !== 0x22/* " */) { return false; } state.kind = 'scalar'; state.result = ''; state.position++; captureStart = captureEnd = state.position; while ((ch = state.input.charCodeAt(state.position)) !== 0) { if (ch === 0x22/* " */) { captureSegment(state, captureStart, state.position, true); state.position++; return true; } else if (ch === 0x5C/* \ */) { captureSegment(state, captureStart, state.position, true); ch = state.input.charCodeAt(++state.position); if (is_EOL(ch)) { skipSeparationSpace(state, false, nodeIndent); // TODO: rework to inline fn with no type cast? } else if (ch < 256 && simpleEscapeCheck[ch]) { state.result += simpleEscapeMap[ch]; state.position++; } else if ((tmp = escapedHexLen(ch)) > 0) { hexLength = tmp; hexResult = 0; for (; hexLength > 0; hexLength--) { ch = state.input.charCodeAt(++state.position); if ((tmp = fromHexCode(ch)) >= 0) { hexResult = (hexResult << 4) + tmp; } else { throwError(state, 'expected hexadecimal character'); } } state.result += charFromCodepoint(hexResult); state.position++; } else { throwError(state, 'unknown escape sequence'); } captureStart = captureEnd = state.position; } else if (is_EOL(ch)) { captureSegment(state, captureStart, captureEnd, true); writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent)); captureStart = captureEnd = state.position; } else if (state.position === state.lineStart && testDocumentSeparator(state)) { throwError(state, 'unexpected end of the document within a double quoted scalar'); } else { state.position++; captureEnd = state.position; } } throwError(state, 'unexpected end of the stream within a double quoted scalar'); } function readFlowCollection(state, nodeIndent) { var readNext = true, _line, _tag = state.tag, _result, _anchor = state.anchor, following, terminator, isPair, isExplicitPair, isMapping, overridableKeys = {}, keyNode, keyTag, valueNode, ch; ch = state.input.charCodeAt(state.position); if (ch === 0x5B/* [ */) { terminator = 0x5D;/* ] */ isMapping = false; _result = []; } else if (ch === 0x7B/* { */) { terminator = 0x7D;/* } */ isMapping = true; _result = {}; } else { return false; } if (state.anchor !== null) { state.anchorMap[state.anchor] = _result; } ch = state.input.charCodeAt(++state.position); while (ch !== 0) { skipSeparationSpace(state, true, nodeIndent); ch = state.input.charCodeAt(state.position); if (ch === terminator) { state.position++; state.tag = _tag; state.anchor = _anchor; state.kind = isMapping ? 'mapping' : 'sequence'; state.result = _result; return true; } else if (!readNext) { throwError(state, 'missed comma between flow collection entries'); } keyTag = keyNode = valueNode = null; isPair = isExplicitPair = false; if (ch === 0x3F/* ? */) { following = state.input.charCodeAt(state.position + 1); if (is_WS_OR_EOL(following)) { isPair = isExplicitPair = true; state.position++; skipSeparationSpace(state, true, nodeIndent); } } _line = state.line; composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true); keyTag = state.tag; keyNode = state.result; skipSeparationSpace(state, true, nodeIndent); ch = state.input.charCodeAt(state.position); if ((isExplicitPair || state.line === _line) && ch === 0x3A/* : */) { isPair = true; ch = state.input.charCodeAt(++state.position); skipSeparationSpace(state, true, nodeIndent); composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true); valueNode = state.result; } if (isMapping) { storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode); } else if (isPair) { _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode)); } else { _result.push(keyNode); } skipSeparationSpace(state, true, nodeIndent); ch = state.input.charCodeAt(state.position); if (ch === 0x2C/* , */) { readNext = true; ch = state.input.charCodeAt(++state.position); } else { readNext = false; } } throwError(state, 'unexpected end of the stream within a flow collection'); } function readBlockScalar(state, nodeIndent) { var captureStart, folding, chomping = CHOMPING_CLIP, didReadContent = false, detectedIndent = false, textIndent = nodeIndent, emptyLines = 0, atMoreIndented = false, tmp, ch; ch = state.input.charCodeAt(state.position); if (ch === 0x7C/* | */) { folding = false; } else if (ch === 0x3E/* > */) { folding = true; } else { return false; } state.kind = 'scalar'; state.result = ''; while (ch !== 0) { ch = state.input.charCodeAt(++state.position); if (ch === 0x2B/* + */ || ch === 0x2D/* - */) { if (CHOMPING_CLIP === chomping) { chomping = (ch === 0x2B/* + */) ? CHOMPING_KEEP : CHOMPING_STRIP; } else { throwError(state, 'repeat of a chomping mode identifier'); } } else if ((tmp = fromDecimalCode(ch)) >= 0) { if (tmp === 0) { throwError(state, 'bad explicit indentation width of a block scalar; it cannot be less than one'); } else if (!detectedIndent) { textIndent = nodeIndent + tmp - 1; detectedIndent = true; } else { throwError(state, 'repeat of an indentation width identifier'); } } else { break; } } if (is_WHITE_SPACE(ch)) { do { ch = state.input.charCodeAt(++state.position); } while (is_WHITE_SPACE(ch)); if (ch === 0x23/* # */) { do { ch = state.input.charCodeAt(++state.position); } while (!is_EOL(ch) && (ch !== 0)); } } while (ch !== 0) { readLineBreak(state); state.lineIndent = 0; ch = state.input.charCodeAt(state.position); while ((!detectedIndent || state.lineIndent < textIndent) && (ch === 0x20/* Space */)) { state.lineIndent++; ch = state.input.charCodeAt(++state.position); } if (!detectedIndent && state.lineIndent > textIndent) { textIndent = state.lineIndent; } if (is_EOL(ch)) { emptyLines++; continue; } // End of the scalar. if (state.lineIndent < textIndent) { // Perform the chomping. if (chomping === CHOMPING_KEEP) { state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines); } else if (chomping === CHOMPING_CLIP) { if (didReadContent) { // i.e. only if the scalar is not empty. state.result += '\n'; } } // Break this `while` cycle and go to the funciton's epilogue. break; } // Folded style: use fancy rules to handle line breaks. if (folding) { // Lines starting with white space characters (more-indented lines) are not folded. if (is_WHITE_SPACE(ch)) { atMoreIndented = true; // except for the first content line (cf. Example 8.1) state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines); // End of more-indented block. } else if (atMoreIndented) { atMoreIndented = false; state.result += common.repeat('\n', emptyLines + 1); // Just one line break - perceive as the same line. } else if (emptyLines === 0) { if (didReadContent) { // i.e. only if we have already read some scalar content. state.result += ' '; } // Several line breaks - perceive as different lines. } else { state.result += common.repeat('\n', emptyLines); } // Literal style: just add exact number of line breaks between content lines. } else { // Keep all line breaks except the header line break. state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines); } didReadContent = true; detectedIndent = true; emptyLines = 0; captureStart = state.position; while (!is_EOL(ch) && (ch !== 0)) { ch = state.input.charCodeAt(++state.position); } captureSegment(state, captureStart, state.position, false); } return true; } function readBlockSequence(state, nodeIndent) { var _line, _tag = state.tag, _anchor = state.anchor, _result = [], following, detected = false, ch; if (state.anchor !== null) { state.anchorMap[state.anchor] = _result; } ch = state.input.charCodeAt(state.position); while (ch !== 0) { if (ch !== 0x2D/* - */) { break; } following = state.input.charCodeAt(state.position + 1); if (!is_WS_OR_EOL(following)) { break; } detected = true; state.position++; if (skipSeparationSpace(state, true, -1)) { if (state.lineIndent <= nodeIndent) { _result.push(null); ch = state.input.charCodeAt(state.position); continue; } } _line = state.line; composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true); _result.push(state.result); skipSeparationSpace(state, true, -1); ch = state.input.charCodeAt(state.position); if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) { throwError(state, 'bad indentation of a sequence entry'); } else if (state.lineIndent < nodeIndent) { break; } } if (detected) { state.tag = _tag; state.anchor = _anchor; state.kind = 'sequence'; state.result = _result; return true; } return false; } function readBlockMapping(state, nodeIndent, flowIndent) { var following, allowCompact, _line, _pos, _tag = state.tag, _anchor = state.anchor, _result = {}, overridableKeys = {}, keyTag = null, keyNode = null, valueNode = null, atExplicitKey = false, detected = false, ch; if (state.anchor !== null) { state.anchorMap[state.anchor] = _result; } ch = state.input.charCodeAt(state.position); while (ch !== 0) { following = state.input.charCodeAt(state.position + 1); _line = state.line; // Save the current line. _pos = state.position; // // Explicit notation case. There are two separate blocks: // first for the key (denoted by "?") and second for the value (denoted by ":") // if ((ch === 0x3F/* ? */ || ch === 0x3A/* : */) && is_WS_OR_EOL(following)) { if (ch === 0x3F/* ? */) { if (atExplicitKey) { storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null); keyTag = keyNode = valueNode = null; } detected = true; atExplicitKey = true; allowCompact = true; } else if (atExplicitKey) { // i.e. 0x3A/* : */ === character after the explicit key. atExplicitKey = false; allowCompact = true; } else { throwError(state, 'incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line'); } state.position += 1; ch = following; // // Implicit notation case. Flow-style node as the key first, then ":", and the value. // } else if (composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) { if (state.line === _line) { ch = state.input.charCodeAt(state.position); while (is_WHITE_SPACE(ch)) { ch = state.input.charCodeAt(++state.position); } if (ch === 0x3A/* : */) { ch = state.input.charCodeAt(++state.position); if (!is_WS_OR_EOL(ch)) { throwError(state, 'a whitespace character is expected after the key-value separator within a block mapping'); } if (atExplicitKey) { storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null); keyTag = keyNode = valueNode = null; } detected = true; atExplicitKey = false; allowCompact = false; keyTag = state.tag; keyNode = state.result; } else if (detected) { throwError(state, 'can not read an implicit mapping pair; a colon is missed'); } else { state.tag = _tag; state.anchor = _anchor; return true; // Keep the result of `composeNode`. } } else if (detected) { throwError(state, 'can not read a block mapping entry; a multiline key may not be an implicit key'); } else { state.tag = _tag; state.anchor = _anchor; return true; // Keep the result of `composeNode`. } } else { break; // Reading is done. Go to the epilogue. } // // Common reading code for both explicit and implicit notations. // if (state.line === _line || state.lineIndent > nodeIndent) { if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) { if (atExplicitKey) { keyNode = state.result; } else { valueNode = state.result; } } if (!atExplicitKey) { storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _pos); keyTag = keyNode = valueNode = null; } skipSeparationSpace(state, true, -1); ch = state.input.charCodeAt(state.position); } if (state.lineIndent > nodeIndent && (ch !== 0)) { throwError(state, 'bad indentation of a mapping entry'); } else if (state.lineIndent < nodeIndent) { break; } } // // Epilogue. // // Special case: last mapping's node contains only the key in explicit notation. if (atExplicitKey) { storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null); } // Expose the resulting mapping. if (detected) { state.tag = _tag; state.anchor = _anchor; state.kind = 'mapping'; state.result = _result; } return detected; } function readTagProperty(state) { var _position, isVerbatim = false, isNamed = false, tagHandle, tagName, ch; ch = state.input.charCodeAt(state.position); if (ch !== 0x21/* ! */) return false; if (state.tag !== null) { throwError(state, 'duplication of a tag property'); } ch = state.input.charCodeAt(++state.position); if (ch === 0x3C/* < */) { isVerbatim = true; ch = state.input.charCodeAt(++state.position); } else if (ch === 0x21/* ! */) { isNamed = true; tagHandle = '!!'; ch = state.input.charCodeAt(++state.position); } else { tagHandle = '!'; } _position = state.position; if (isVerbatim) { do { ch = state.input.charCodeAt(++state.position); } while (ch !== 0 && ch !== 0x3E/* > */); if (state.position < state.length) { tagName = state.input.slice(_position, state.position); ch = state.input.charCodeAt(++state.position); } else { throwError(state, 'unexpected end of the stream within a verbatim tag'); } } else { while (ch !== 0 && !is_WS_OR_EOL(ch)) { if (ch === 0x21/* ! */) { if (!isNamed) { tagHandle = state.input.slice(_position - 1, state.position + 1); if (!PATTERN_TAG_HANDLE.test(tagHandle)) { throwError(state, 'named tag handle cannot contain such characters'); } isNamed = true; _position = state.position + 1; } else { throwError(state, 'tag suffix cannot contain exclamation marks'); } } ch = state.input.charCodeAt(++state.position); } tagName = state.input.slice(_position, state.position); if (PATTERN_FLOW_INDICATORS.test(tagName)) { throwError(state, 'tag suffix cannot contain flow indicator characters'); } } if (tagName && !PATTERN_TAG_URI.test(tagName)) { throwError(state, 'tag name cannot contain such characters: ' + tagName); } if (isVerbatim) { state.tag = tagName; } else if (_hasOwnProperty.call(state.tagMap, tagHandle)) { state.tag = state.tagMap[tagHandle] + tagName; } else if (tagHandle === '!') { state.tag = '!' + tagName; } else if (tagHandle === '!!') { state.tag = 'tag:yaml.org,2002:' + tagName; } else { throwError(state, 'undeclared tag handle "' + tagHandle + '"'); } return true; } function readAnchorProperty(state) { var _position, ch; ch = state.input.charCodeAt(state.position); if (ch !== 0x26/* & */) return false; if (state.anchor !== null) { throwError(state, 'duplication of an anchor property'); } ch = state.input.charCodeAt(++state.position); _position = state.position; while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) { ch = state.input.charCodeAt(++state.position); } if (state.position === _position) { throwError(state, 'name of an anchor node must contain at least one character'); } state.anchor = state.input.slice(_position, state.position); return true; } function readAlias(state) { var _position, alias, ch; ch = state.input.charCodeAt(state.position); if (ch !== 0x2A/* * */) return false; ch = state.input.charCodeAt(++state.position); _position = state.position; while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) { ch = state.input.charCodeAt(++state.position); } if (state.position === _position) { throwError(state, 'name of an alias node must contain at least one character'); } alias = state.input.slice(_position, state.position); if (!state.anchorMap.hasOwnProperty(alias)) { throwError(state, 'unidentified alias "' + alias + '"'); } state.result = state.anchorMap[alias]; skipSeparationSpace(state, true, -1); return true; } function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) { var allowBlockStyles, allowBlockScalars, allowBlockCollections, indentStatus = 1, // 1: this>parent, 0: this=parent, -1: this parentIndent) { indentStatus = 1; } else if (state.lineIndent === parentIndent) { indentStatus = 0; } else if (state.lineIndent < parentIndent) { indentStatus = -1; } } } if (indentStatus === 1) { while (readTagProperty(state) || readAnchorProperty(state)) { if (skipSeparationSpace(state, true, -1)) { atNewLine = true; allowBlockCollections = allowBlockStyles; if (state.lineIndent > parentIndent) { indentStatus = 1; } else if (state.lineIndent === parentIndent) { indentStatus = 0; } else if (state.lineIndent < parentIndent) { indentStatus = -1; } } else { allowBlockCollections = false; } } } if (allowBlockCollections) { allowBlockCollections = atNewLine || allowCompact; } if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) { if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) { flowIndent = parentIndent; } else { flowIndent = parentIndent + 1; } blockIndent = state.position - state.lineStart; if (indentStatus === 1) { if (allowBlockCollections && (readBlockSequence(state, blockIndent) || readBlockMapping(state, blockIndent, flowIndent)) || readFlowCollection(state, flowIndent)) { hasContent = true; } else { if ((allowBlockScalars && readBlockScalar(state, flowIndent)) || readSingleQuotedScalar(state, flowIndent) || readDoubleQuotedScalar(state, flowIndent)) { hasContent = true; } else if (readAlias(state)) { hasContent = true; if (state.tag !== null || state.anchor !== null) { throwError(state, 'alias node should not have any properties'); } } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) { hasContent = true; if (state.tag === null) { state.tag = '?'; } } if (state.anchor !== null) { state.anchorMap[state.anchor] = state.result; } } } else if (indentStatus === 0) { // Special case: block sequences are allowed to have same indentation level as the parent. // http://www.yaml.org/spec/1.2/spec.html#id2799784 hasContent = allowBlockCollections && readBlockSequence(state, blockIndent); } } if (state.tag !== null && state.tag !== '!') { if (state.tag === '?') { for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) { type = state.implicitTypes[typeIndex]; // Implicit resolving is not allowed for non-scalar types, and '?' // non-specific tag is only assigned to plain scalars. So, it isn't // needed to check for 'kind' conformity. if (type.resolve(state.result)) { // `state.result` updated in resolver if matched state.result = type.construct(state.result); state.tag = type.tag; if (state.anchor !== null) { state.anchorMap[state.anchor] = state.result; } break; } } } else if (_hasOwnProperty.call(state.typeMap[state.kind || 'fallback'], state.tag)) { type = state.typeMap[state.kind || 'fallback'][state.tag]; if (state.result !== null && type.kind !== state.kind) { throwError(state, 'unacceptable node kind for !<' + state.tag + '> tag; it should be "' + type.kind + '", not "' + state.kind + '"'); } if (!type.resolve(state.result)) { // `state.result` updated in resolver if matched throwError(state, 'cannot resolve a node with !<' + state.tag + '> explicit tag'); } else { state.result = type.construct(state.result); if (state.anchor !== null) { state.anchorMap[state.anchor] = state.result; } } } else { throwError(state, 'unknown tag !<' + state.tag + '>'); } } if (state.listener !== null) { state.listener('close', state); } return state.tag !== null || state.anchor !== null || hasContent; } function readDocument(state) { var documentStart = state.position, _position, directiveName, directiveArgs, hasDirectives = false, ch; state.version = null; state.checkLineBreaks = state.legacy; state.tagMap = {}; state.anchorMap = {}; while ((ch = state.input.charCodeAt(state.position)) !== 0) { skipSeparationSpace(state, true, -1); ch = state.input.charCodeAt(state.position); if (state.lineIndent > 0 || ch !== 0x25/* % */) { break; } hasDirectives = true; ch = state.input.charCodeAt(++state.position); _position = state.position; while (ch !== 0 && !is_WS_OR_EOL(ch)) { ch = state.input.charCodeAt(++state.position); } directiveName = state.input.slice(_position, state.position); directiveArgs = []; if (directiveName.length < 1) { throwError(state, 'directive name must not be less than one character in length'); } while (ch !== 0) { while (is_WHITE_SPACE(ch)) { ch = state.input.charCodeAt(++state.position); } if (ch === 0x23/* # */) { do { ch = state.input.charCodeAt(++state.position); } while (ch !== 0 && !is_EOL(ch)); break; } if (is_EOL(ch)) break; _position = state.position; while (ch !== 0 && !is_WS_OR_EOL(ch)) { ch = state.input.charCodeAt(++state.position); } directiveArgs.push(state.input.slice(_position, state.position)); } if (ch !== 0) readLineBreak(state); if (_hasOwnProperty.call(directiveHandlers, directiveName)) { directiveHandlers[directiveName](state, directiveName, directiveArgs); } else { throwWarning(state, 'unknown document directive "' + directiveName + '"'); } } skipSeparationSpace(state, true, -1); if (state.lineIndent === 0 && state.input.charCodeAt(state.position) === 0x2D/* - */ && state.input.charCodeAt(state.position + 1) === 0x2D/* - */ && state.input.charCodeAt(state.position + 2) === 0x2D/* - */) { state.position += 3; skipSeparationSpace(state, true, -1); } else if (hasDirectives) { throwError(state, 'directives end mark is expected'); } composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true); skipSeparationSpace(state, true, -1); if (state.checkLineBreaks && PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) { throwWarning(state, 'non-ASCII line breaks are interpreted as content'); } state.documents.push(state.result); if (state.position === state.lineStart && testDocumentSeparator(state)) { if (state.input.charCodeAt(state.position) === 0x2E/* . */) { state.position += 3; skipSeparationSpace(state, true, -1); } return; } if (state.position < (state.length - 1)) { throwError(state, 'end of the stream or a document separator is expected'); } else { return; } } function loadDocuments(input, options) { input = String(input); options = options || {}; if (input.length !== 0) { // Add tailing `\n` if not exists if (input.charCodeAt(input.length - 1) !== 0x0A/* LF */ && input.charCodeAt(input.length - 1) !== 0x0D/* CR */) { input += '\n'; } // Strip BOM if (input.charCodeAt(0) === 0xFEFF) { input = input.slice(1); } } var state = new State(input, options); // Use 0 as string terminator. That significantly simplifies bounds check. state.input += '\0'; while (state.input.charCodeAt(state.position) === 0x20/* Space */) { state.lineIndent += 1; state.position += 1; } while (state.position < (state.length - 1)) { readDocument(state); } return state.documents; } function loadAll(input, iterator, options) { var documents = loadDocuments(input, options), index, length; if (typeof iterator !== 'function') { return documents; } for (index = 0, length = documents.length; index < length; index += 1) { iterator(documents[index]); } } function load(input, options) { var documents = loadDocuments(input, options); if (documents.length === 0) { /*eslint-disable no-undefined*/ return undefined; } else if (documents.length === 1) { return documents[0]; } throw new YAMLException('expected a single document in the stream, but found more'); } function safeLoadAll(input, output, options) { if (typeof output === 'function') { loadAll(input, output, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options)); } else { return loadAll(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options)); } } function safeLoad(input, options) { return load(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options)); } module.exports.loadAll = loadAll; module.exports.load = load; module.exports.safeLoadAll = safeLoadAll; module.exports.safeLoad = safeLoad; /***/ }), /* 104 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var common = __webpack_require__(15); function Mark(name, buffer, position, line, column) { this.name = name; this.buffer = buffer; this.position = position; this.line = line; this.column = column; } Mark.prototype.getSnippet = function getSnippet(indent, maxLength) { var head, start, tail, end, snippet; if (!this.buffer) return null; indent = indent || 4; maxLength = maxLength || 75; head = ''; start = this.position; while (start > 0 && '\x00\r\n\x85\u2028\u2029'.indexOf(this.buffer.charAt(start - 1)) === -1) { start -= 1; if (this.position - start > (maxLength / 2 - 1)) { head = ' ... '; start += 5; break; } } tail = ''; end = this.position; while (end < this.buffer.length && '\x00\r\n\x85\u2028\u2029'.indexOf(this.buffer.charAt(end)) === -1) { end += 1; if (end - this.position > (maxLength / 2 - 1)) { tail = ' ... '; end -= 5; break; } } snippet = this.buffer.slice(start, end); return common.repeat(' ', indent) + head + snippet + tail + '\n' + common.repeat(' ', indent + this.position - start + head.length) + '^'; }; Mark.prototype.toString = function toString(compact) { var snippet, where = ''; if (this.name) { where += 'in "' + this.name + '" '; } where += 'at line ' + (this.line + 1) + ', column ' + (this.column + 1); if (!compact) { snippet = this.getSnippet(); if (snippet) { where += ':\n' + snippet; } } return where; }; module.exports = Mark; /***/ }), /* 105 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var Type = __webpack_require__(5); module.exports = new Type('tag:yaml.org,2002:str', { kind: 'scalar', construct: function (data) { return data !== null ? data : ''; } }); /***/ }), /* 106 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var Type = __webpack_require__(5); module.exports = new Type('tag:yaml.org,2002:seq', { kind: 'sequence', construct: function (data) { return data !== null ? data : []; } }); /***/ }), /* 107 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var Type = __webpack_require__(5); module.exports = new Type('tag:yaml.org,2002:map', { kind: 'mapping', construct: function (data) { return data !== null ? data : {}; } }); /***/ }), /* 108 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var Type = __webpack_require__(5); function resolveYamlNull(data) { if (data === null) return true; var max = data.length; return (max === 1 && data === '~') || (max === 4 && (data === 'null' || data === 'Null' || data === 'NULL')); } function constructYamlNull() { return null; } function isNull(object) { return object === null; } module.exports = new Type('tag:yaml.org,2002:null', { kind: 'scalar', resolve: resolveYamlNull, construct: constructYamlNull, predicate: isNull, represent: { canonical: function () { return '~'; }, lowercase: function () { return 'null'; }, uppercase: function () { return 'NULL'; }, camelcase: function () { return 'Null'; } }, defaultStyle: 'lowercase' }); /***/ }), /* 109 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var Type = __webpack_require__(5); function resolveYamlBoolean(data) { if (data === null) return false; var max = data.length; return (max === 4 && (data === 'true' || data === 'True' || data === 'TRUE')) || (max === 5 && (data === 'false' || data === 'False' || data === 'FALSE')); } function constructYamlBoolean(data) { return data === 'true' || data === 'True' || data === 'TRUE'; } function isBoolean(object) { return Object.prototype.toString.call(object) === '[object Boolean]'; } module.exports = new Type('tag:yaml.org,2002:bool', { kind: 'scalar', resolve: resolveYamlBoolean, construct: constructYamlBoolean, predicate: isBoolean, represent: { lowercase: function (object) { return object ? 'true' : 'false'; }, uppercase: function (object) { return object ? 'TRUE' : 'FALSE'; }, camelcase: function (object) { return object ? 'True' : 'False'; } }, defaultStyle: 'lowercase' }); /***/ }), /* 110 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var common = __webpack_require__(15); var Type = __webpack_require__(5); function isHexCode(c) { return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) || ((0x41/* A */ <= c) && (c <= 0x46/* F */)) || ((0x61/* a */ <= c) && (c <= 0x66/* f */)); } function isOctCode(c) { return ((0x30/* 0 */ <= c) && (c <= 0x37/* 7 */)); } function isDecCode(c) { return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)); } function resolveYamlInteger(data) { if (data === null) return false; var max = data.length, index = 0, hasDigits = false, ch; if (!max) return false; ch = data[index]; // sign if (ch === '-' || ch === '+') { ch = data[++index]; } if (ch === '0') { // 0 if (index + 1 === max) return true; ch = data[++index]; // base 2, base 8, base 16 if (ch === 'b') { // base 2 index++; for (; index < max; index++) { ch = data[index]; if (ch === '_') continue; if (ch !== '0' && ch !== '1') return false; hasDigits = true; } return hasDigits && ch !== '_'; } if (ch === 'x') { // base 16 index++; for (; index < max; index++) { ch = data[index]; if (ch === '_') continue; if (!isHexCode(data.charCodeAt(index))) return false; hasDigits = true; } return hasDigits && ch !== '_'; } // base 8 for (; index < max; index++) { ch = data[index]; if (ch === '_') continue; if (!isOctCode(data.charCodeAt(index))) return false; hasDigits = true; } return hasDigits && ch !== '_'; } // base 10 (except 0) or base 60 // value should not start with `_`; if (ch === '_') return false; for (; index < max; index++) { ch = data[index]; if (ch === '_') continue; if (ch === ':') break; if (!isDecCode(data.charCodeAt(index))) { return false; } hasDigits = true; } // Should have digits and should not end with `_` if (!hasDigits || ch === '_') return false; // if !base60 - done; if (ch !== ':') return true; // base60 almost not used, no needs to optimize return /^(:[0-5]?[0-9])+$/.test(data.slice(index)); } function constructYamlInteger(data) { var value = data, sign = 1, ch, base, digits = []; if (value.indexOf('_') !== -1) { value = value.replace(/_/g, ''); } ch = value[0]; if (ch === '-' || ch === '+') { if (ch === '-') sign = -1; value = value.slice(1); ch = value[0]; } if (value === '0') return 0; if (ch === '0') { if (value[1] === 'b') return sign * parseInt(value.slice(2), 2); if (value[1] === 'x') return sign * parseInt(value, 16); return sign * parseInt(value, 8); } if (value.indexOf(':') !== -1) { value.split(':').forEach(function (v) { digits.unshift(parseInt(v, 10)); }); value = 0; base = 1; digits.forEach(function (d) { value += (d * base); base *= 60; }); return sign * value; } return sign * parseInt(value, 10); } function isInteger(object) { return (Object.prototype.toString.call(object)) === '[object Number]' && (object % 1 === 0 && !common.isNegativeZero(object)); } module.exports = new Type('tag:yaml.org,2002:int', { kind: 'scalar', resolve: resolveYamlInteger, construct: constructYamlInteger, predicate: isInteger, represent: { binary: function (obj) { return obj >= 0 ? '0b' + obj.toString(2) : '-0b' + obj.toString(2).slice(1); }, octal: function (obj) { return obj >= 0 ? '0' + obj.toString(8) : '-0' + obj.toString(8).slice(1); }, decimal: function (obj) { return obj.toString(10); }, /* eslint-disable max-len */ hexadecimal: function (obj) { return obj >= 0 ? '0x' + obj.toString(16).toUpperCase() : '-0x' + obj.toString(16).toUpperCase().slice(1); } }, defaultStyle: 'decimal', styleAliases: { binary: [ 2, 'bin' ], octal: [ 8, 'oct' ], decimal: [ 10, 'dec' ], hexadecimal: [ 16, 'hex' ] } }); /***/ }), /* 111 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var common = __webpack_require__(15); var Type = __webpack_require__(5); var YAML_FLOAT_PATTERN = new RegExp( // 2.5e4, 2.5 and integers '^(?:[-+]?(?:0|[1-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?' + // .2e4, .2 // special case, seems not from spec '|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?' + // 20:59 '|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*' + // .inf '|[-+]?\\.(?:inf|Inf|INF)' + // .nan '|\\.(?:nan|NaN|NAN))$'); function resolveYamlFloat(data) { if (data === null) return false; if (!YAML_FLOAT_PATTERN.test(data) || // Quick hack to not allow integers end with `_` // Probably should update regexp & check speed data[data.length - 1] === '_') { return false; } return true; } function constructYamlFloat(data) { var value, sign, base, digits; value = data.replace(/_/g, '').toLowerCase(); sign = value[0] === '-' ? -1 : 1; digits = []; if ('+-'.indexOf(value[0]) >= 0) { value = value.slice(1); } if (value === '.inf') { return (sign === 1) ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY; } else if (value === '.nan') { return NaN; } else if (value.indexOf(':') >= 0) { value.split(':').forEach(function (v) { digits.unshift(parseFloat(v, 10)); }); value = 0.0; base = 1; digits.forEach(function (d) { value += d * base; base *= 60; }); return sign * value; } return sign * parseFloat(value, 10); } var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/; function representYamlFloat(object, style) { var res; if (isNaN(object)) { switch (style) { case 'lowercase': return '.nan'; case 'uppercase': return '.NAN'; case 'camelcase': return '.NaN'; } } else if (Number.POSITIVE_INFINITY === object) { switch (style) { case 'lowercase': return '.inf'; case 'uppercase': return '.INF'; case 'camelcase': return '.Inf'; } } else if (Number.NEGATIVE_INFINITY === object) { switch (style) { case 'lowercase': return '-.inf'; case 'uppercase': return '-.INF'; case 'camelcase': return '-.Inf'; } } else if (common.isNegativeZero(object)) { return '-0.0'; } res = object.toString(10); // JS stringifier can build scientific format without dots: 5e-100, // while YAML requres dot: 5.e-100. Fix it with simple hack return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace('e', '.e') : res; } function isFloat(object) { return (Object.prototype.toString.call(object) === '[object Number]') && (object % 1 !== 0 || common.isNegativeZero(object)); } module.exports = new Type('tag:yaml.org,2002:float', { kind: 'scalar', resolve: resolveYamlFloat, construct: constructYamlFloat, predicate: isFloat, represent: representYamlFloat, defaultStyle: 'lowercase' }); /***/ }), /* 112 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var Type = __webpack_require__(5); var YAML_DATE_REGEXP = new RegExp( '^([0-9][0-9][0-9][0-9])' + // [1] year '-([0-9][0-9])' + // [2] month '-([0-9][0-9])$'); // [3] day var YAML_TIMESTAMP_REGEXP = new RegExp( '^([0-9][0-9][0-9][0-9])' + // [1] year '-([0-9][0-9]?)' + // [2] month '-([0-9][0-9]?)' + // [3] day '(?:[Tt]|[ \\t]+)' + // ... '([0-9][0-9]?)' + // [4] hour ':([0-9][0-9])' + // [5] minute ':([0-9][0-9])' + // [6] second '(?:\\.([0-9]*))?' + // [7] fraction '(?:[ \\t]*(Z|([-+])([0-9][0-9]?)' + // [8] tz [9] tz_sign [10] tz_hour '(?::([0-9][0-9]))?))?$'); // [11] tz_minute function resolveYamlTimestamp(data) { if (data === null) return false; if (YAML_DATE_REGEXP.exec(data) !== null) return true; if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true; return false; } function constructYamlTimestamp(data) { var match, year, month, day, hour, minute, second, fraction = 0, delta = null, tz_hour, tz_minute, date; match = YAML_DATE_REGEXP.exec(data); if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data); if (match === null) throw new Error('Date resolve error'); // match: [1] year [2] month [3] day year = +(match[1]); month = +(match[2]) - 1; // JS month starts with 0 day = +(match[3]); if (!match[4]) { // no hour return new Date(Date.UTC(year, month, day)); } // match: [4] hour [5] minute [6] second [7] fraction hour = +(match[4]); minute = +(match[5]); second = +(match[6]); if (match[7]) { fraction = match[7].slice(0, 3); while (fraction.length < 3) { // milli-seconds fraction += '0'; } fraction = +fraction; } // match: [8] tz [9] tz_sign [10] tz_hour [11] tz_minute if (match[9]) { tz_hour = +(match[10]); tz_minute = +(match[11] || 0); delta = (tz_hour * 60 + tz_minute) * 60000; // delta in mili-seconds if (match[9] === '-') delta = -delta; } date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction)); if (delta) date.setTime(date.getTime() - delta); return date; } function representYamlTimestamp(object /*, style*/) { return object.toISOString(); } module.exports = new Type('tag:yaml.org,2002:timestamp', { kind: 'scalar', resolve: resolveYamlTimestamp, construct: constructYamlTimestamp, instanceOf: Date, represent: representYamlTimestamp }); /***/ }), /* 113 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var Type = __webpack_require__(5); function resolveYamlMerge(data) { return data === '<<' || data === null; } module.exports = new Type('tag:yaml.org,2002:merge', { kind: 'scalar', resolve: resolveYamlMerge }); /***/ }), /* 114 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var require; /*eslint-disable no-bitwise*/ var NodeBuffer; try { // A trick for browserified version, to not include `Buffer` shim var _require = require; NodeBuffer = __webpack_require__(50).Buffer; } catch (__) {} var Type = __webpack_require__(5); // [ 64, 65, 66 ] -> [ padding, CR, LF ] var BASE64_MAP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r'; function resolveYamlBinary(data) { if (data === null) return false; var code, idx, bitlen = 0, max = data.length, map = BASE64_MAP; // Convert one by one. for (idx = 0; idx < max; idx++) { code = map.indexOf(data.charAt(idx)); // Skip CR/LF if (code > 64) continue; // Fail on illegal characters if (code < 0) return false; bitlen += 6; } // If there are any bits left, source was corrupted return (bitlen % 8) === 0; } function constructYamlBinary(data) { var idx, tailbits, input = data.replace(/[\r\n=]/g, ''), // remove CR/LF & padding to simplify scan max = input.length, map = BASE64_MAP, bits = 0, result = []; // Collect by 6*4 bits (3 bytes) for (idx = 0; idx < max; idx++) { if ((idx % 4 === 0) && idx) { result.push((bits >> 16) & 0xFF); result.push((bits >> 8) & 0xFF); result.push(bits & 0xFF); } bits = (bits << 6) | map.indexOf(input.charAt(idx)); } // Dump tail tailbits = (max % 4) * 6; if (tailbits === 0) { result.push((bits >> 16) & 0xFF); result.push((bits >> 8) & 0xFF); result.push(bits & 0xFF); } else if (tailbits === 18) { result.push((bits >> 10) & 0xFF); result.push((bits >> 2) & 0xFF); } else if (tailbits === 12) { result.push((bits >> 4) & 0xFF); } // Wrap into Buffer for NodeJS and leave Array for browser if (NodeBuffer) { // Support node 6.+ Buffer API when available return NodeBuffer.from ? NodeBuffer.from(result) : new NodeBuffer(result); } return result; } function representYamlBinary(object /*, style*/) { var result = '', bits = 0, idx, tail, max = object.length, map = BASE64_MAP; // Convert every three bytes to 4 ASCII characters. for (idx = 0; idx < max; idx++) { if ((idx % 3 === 0) && idx) { result += map[(bits >> 18) & 0x3F]; result += map[(bits >> 12) & 0x3F]; result += map[(bits >> 6) & 0x3F]; result += map[bits & 0x3F]; } bits = (bits << 8) + object[idx]; } // Dump tail tail = max % 3; if (tail === 0) { result += map[(bits >> 18) & 0x3F]; result += map[(bits >> 12) & 0x3F]; result += map[(bits >> 6) & 0x3F]; result += map[bits & 0x3F]; } else if (tail === 2) { result += map[(bits >> 10) & 0x3F]; result += map[(bits >> 4) & 0x3F]; result += map[(bits << 2) & 0x3F]; result += map[64]; } else if (tail === 1) { result += map[(bits >> 2) & 0x3F]; result += map[(bits << 4) & 0x3F]; result += map[64]; result += map[64]; } return result; } function isBinary(object) { return NodeBuffer && NodeBuffer.isBuffer(object); } module.exports = new Type('tag:yaml.org,2002:binary', { kind: 'scalar', resolve: resolveYamlBinary, construct: constructYamlBinary, predicate: isBinary, represent: representYamlBinary }); /***/ }), /* 115 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var Type = __webpack_require__(5); var _hasOwnProperty = Object.prototype.hasOwnProperty; var _toString = Object.prototype.toString; function resolveYamlOmap(data) { if (data === null) return true; var objectKeys = [], index, length, pair, pairKey, pairHasKey, object = data; for (index = 0, length = object.length; index < length; index += 1) { pair = object[index]; pairHasKey = false; if (_toString.call(pair) !== '[object Object]') return false; for (pairKey in pair) { if (_hasOwnProperty.call(pair, pairKey)) { if (!pairHasKey) pairHasKey = true; else return false; } } if (!pairHasKey) return false; if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey); else return false; } return true; } function constructYamlOmap(data) { return data !== null ? data : []; } module.exports = new Type('tag:yaml.org,2002:omap', { kind: 'sequence', resolve: resolveYamlOmap, construct: constructYamlOmap }); /***/ }), /* 116 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var Type = __webpack_require__(5); var _toString = Object.prototype.toString; function resolveYamlPairs(data) { if (data === null) return true; var index, length, pair, keys, result, object = data; result = new Array(object.length); for (index = 0, length = object.length; index < length; index += 1) { pair = object[index]; if (_toString.call(pair) !== '[object Object]') return false; keys = Object.keys(pair); if (keys.length !== 1) return false; result[index] = [ keys[0], pair[keys[0]] ]; } return true; } function constructYamlPairs(data) { if (data === null) return []; var index, length, pair, keys, result, object = data; result = new Array(object.length); for (index = 0, length = object.length; index < length; index += 1) { pair = object[index]; keys = Object.keys(pair); result[index] = [ keys[0], pair[keys[0]] ]; } return result; } module.exports = new Type('tag:yaml.org,2002:pairs', { kind: 'sequence', resolve: resolveYamlPairs, construct: constructYamlPairs }); /***/ }), /* 117 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var Type = __webpack_require__(5); var _hasOwnProperty = Object.prototype.hasOwnProperty; function resolveYamlSet(data) { if (data === null) return true; var key, object = data; for (key in object) { if (_hasOwnProperty.call(object, key)) { if (object[key] !== null) return false; } } return true; } function constructYamlSet(data) { return data !== null ? data : {}; } module.exports = new Type('tag:yaml.org,2002:set', { kind: 'mapping', resolve: resolveYamlSet, construct: constructYamlSet }); /***/ }), /* 118 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var Type = __webpack_require__(5); function resolveJavascriptUndefined() { return true; } function constructJavascriptUndefined() { /*eslint-disable no-undefined*/ return undefined; } function representJavascriptUndefined() { return ''; } function isUndefined(object) { return typeof object === 'undefined'; } module.exports = new Type('tag:yaml.org,2002:js/undefined', { kind: 'scalar', resolve: resolveJavascriptUndefined, construct: constructJavascriptUndefined, predicate: isUndefined, represent: representJavascriptUndefined }); /***/ }), /* 119 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var Type = __webpack_require__(5); function resolveJavascriptRegExp(data) { if (data === null) return false; if (data.length === 0) return false; var regexp = data, tail = /\/([gim]*)$/.exec(data), modifiers = ''; // if regexp starts with '/' it can have modifiers and must be properly closed // `/foo/gim` - modifiers tail can be maximum 3 chars if (regexp[0] === '/') { if (tail) modifiers = tail[1]; if (modifiers.length > 3) return false; // if expression starts with /, is should be properly terminated if (regexp[regexp.length - modifiers.length - 1] !== '/') return false; } return true; } function constructJavascriptRegExp(data) { var regexp = data, tail = /\/([gim]*)$/.exec(data), modifiers = ''; // `/foo/gim` - tail can be maximum 4 chars if (regexp[0] === '/') { if (tail) modifiers = tail[1]; regexp = regexp.slice(1, regexp.length - modifiers.length - 1); } return new RegExp(regexp, modifiers); } function representJavascriptRegExp(object /*, style*/) { var result = '/' + object.source + '/'; if (object.global) result += 'g'; if (object.multiline) result += 'm'; if (object.ignoreCase) result += 'i'; return result; } function isRegExp(object) { return Object.prototype.toString.call(object) === '[object RegExp]'; } module.exports = new Type('tag:yaml.org,2002:js/regexp', { kind: 'scalar', resolve: resolveJavascriptRegExp, construct: constructJavascriptRegExp, predicate: isRegExp, represent: representJavascriptRegExp }); /***/ }), /* 120 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var require; var esprima; // Browserified version does not have esprima // // 1. For node.js just require module as deps // 2. For browser try to require mudule via external AMD system. // If not found - try to fallback to window.esprima. If not // found too - then fail to parse. // try { // workaround to exclude package from browserify list. var _require = require; esprima = __webpack_require__(121); } catch (_) { /*global window */ if (typeof window !== 'undefined') esprima = window.esprima; } var Type = __webpack_require__(5); function resolveJavascriptFunction(data) { if (data === null) return false; try { var source = '(' + data + ')', ast = esprima.parse(source, { range: true }); if (ast.type !== 'Program' || ast.body.length !== 1 || ast.body[0].type !== 'ExpressionStatement' || (ast.body[0].expression.type !== 'ArrowFunctionExpression' && ast.body[0].expression.type !== 'FunctionExpression')) { return false; } return true; } catch (err) { return false; } } function constructJavascriptFunction(data) { /*jslint evil:true*/ var source = '(' + data + ')', ast = esprima.parse(source, { range: true }), params = [], body; if (ast.type !== 'Program' || ast.body.length !== 1 || ast.body[0].type !== 'ExpressionStatement' || (ast.body[0].expression.type !== 'ArrowFunctionExpression' && ast.body[0].expression.type !== 'FunctionExpression')) { throw new Error('Failed to resolve function'); } ast.body[0].expression.params.forEach(function (param) { params.push(param.name); }); body = ast.body[0].expression.body.range; // Esprima's ranges include the first '{' and the last '}' characters on // function expressions. So cut them out. if (ast.body[0].expression.body.type === 'BlockStatement') { /*eslint-disable no-new-func*/ return new Function(params, source.slice(body[0] + 1, body[1] - 1)); } // ES6 arrow functions can omit the BlockStatement. In that case, just return // the body. /*eslint-disable no-new-func*/ return new Function(params, 'return ' + source.slice(body[0], body[1])); } function representJavascriptFunction(object /*, style*/) { return object.toString(); } function isFunction(object) { return Object.prototype.toString.call(object) === '[object Function]'; } module.exports = new Type('tag:yaml.org,2002:js/function', { kind: 'scalar', resolve: resolveJavascriptFunction, construct: constructJavascriptFunction, predicate: isFunction, represent: representJavascriptFunction }); /***/ }), /* 121 */ /***/ (function(module, exports, __webpack_require__) { (function webpackUniversalModuleDefinition(root, factory) { /* istanbul ignore next */ if(true) module.exports = factory(); else {} })(this, function() { return /******/ (function(modules) { // webpackBootstrap /******/ // The module cache /******/ var installedModules = {}; /******/ // The require function /******/ function __webpack_require__(moduleId) { /******/ // Check if module is in cache /* istanbul ignore if */ /******/ 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__) { "use strict"; /* Copyright JS Foundation and other contributors, https://js.foundation/ Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ Object.defineProperty(exports, "__esModule", { value: true }); var comment_handler_1 = __webpack_require__(1); var jsx_parser_1 = __webpack_require__(3); var parser_1 = __webpack_require__(8); var tokenizer_1 = __webpack_require__(15); function parse(code, options, delegate) { var commentHandler = null; var proxyDelegate = function (node, metadata) { if (delegate) { delegate(node, metadata); } if (commentHandler) { commentHandler.visit(node, metadata); } }; var parserDelegate = (typeof delegate === 'function') ? proxyDelegate : null; var collectComment = false; if (options) { collectComment = (typeof options.comment === 'boolean' && options.comment); var attachComment = (typeof options.attachComment === 'boolean' && options.attachComment); if (collectComment || attachComment) { commentHandler = new comment_handler_1.CommentHandler(); commentHandler.attach = attachComment; options.comment = true; parserDelegate = proxyDelegate; } } var isModule = false; if (options && typeof options.sourceType === 'string') { isModule = (options.sourceType === 'module'); } var parser; if (options && typeof options.jsx === 'boolean' && options.jsx) { parser = new jsx_parser_1.JSXParser(code, options, parserDelegate); } else { parser = new parser_1.Parser(code, options, parserDelegate); } var program = isModule ? parser.parseModule() : parser.parseScript(); var ast = program; if (collectComment && commentHandler) { ast.comments = commentHandler.comments; } if (parser.config.tokens) { ast.tokens = parser.tokens; } if (parser.config.tolerant) { ast.errors = parser.errorHandler.errors; } return ast; } exports.parse = parse; function parseModule(code, options, delegate) { var parsingOptions = options || {}; parsingOptions.sourceType = 'module'; return parse(code, parsingOptions, delegate); } exports.parseModule = parseModule; function parseScript(code, options, delegate) { var parsingOptions = options || {}; parsingOptions.sourceType = 'script'; return parse(code, parsingOptions, delegate); } exports.parseScript = parseScript; function tokenize(code, options, delegate) { var tokenizer = new tokenizer_1.Tokenizer(code, options); var tokens; tokens = []; try { while (true) { var token = tokenizer.getNextToken(); if (!token) { break; } if (delegate) { token = delegate(token); } tokens.push(token); } } catch (e) { tokenizer.errorHandler.tolerate(e); } if (tokenizer.errorHandler.tolerant) { tokens.errors = tokenizer.errors(); } return tokens; } exports.tokenize = tokenize; var syntax_1 = __webpack_require__(2); exports.Syntax = syntax_1.Syntax; // Sync with *.json manifests. exports.version = '4.0.1'; /***/ }, /* 1 */ /***/ function(module, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); var syntax_1 = __webpack_require__(2); var CommentHandler = (function () { function CommentHandler() { this.attach = false; this.comments = []; this.stack = []; this.leading = []; this.trailing = []; } CommentHandler.prototype.insertInnerComments = function (node, metadata) { // innnerComments for properties empty block // `function a() {/** comments **\/}` if (node.type === syntax_1.Syntax.BlockStatement && node.body.length === 0) { var innerComments = []; for (var i = this.leading.length - 1; i >= 0; --i) { var entry = this.leading[i]; if (metadata.end.offset >= entry.start) { innerComments.unshift(entry.comment); this.leading.splice(i, 1); this.trailing.splice(i, 1); } } if (innerComments.length) { node.innerComments = innerComments; } } }; CommentHandler.prototype.findTrailingComments = function (metadata) { var trailingComments = []; if (this.trailing.length > 0) { for (var i = this.trailing.length - 1; i >= 0; --i) { var entry_1 = this.trailing[i]; if (entry_1.start >= metadata.end.offset) { trailingComments.unshift(entry_1.comment); } } this.trailing.length = 0; return trailingComments; } var entry = this.stack[this.stack.length - 1]; if (entry && entry.node.trailingComments) { var firstComment = entry.node.trailingComments[0]; if (firstComment && firstComment.range[0] >= metadata.end.offset) { trailingComments = entry.node.trailingComments; delete entry.node.trailingComments; } } return trailingComments; }; CommentHandler.prototype.findLeadingComments = function (metadata) { var leadingComments = []; var target; while (this.stack.length > 0) { var entry = this.stack[this.stack.length - 1]; if (entry && entry.start >= metadata.start.offset) { target = entry.node; this.stack.pop(); } else { break; } } if (target) { var count = target.leadingComments ? target.leadingComments.length : 0; for (var i = count - 1; i >= 0; --i) { var comment = target.leadingComments[i]; if (comment.range[1] <= metadata.start.offset) { leadingComments.unshift(comment); target.leadingComments.splice(i, 1); } } if (target.leadingComments && target.leadingComments.length === 0) { delete target.leadingComments; } return leadingComments; } for (var i = this.leading.length - 1; i >= 0; --i) { var entry = this.leading[i]; if (entry.start <= metadata.start.offset) { leadingComments.unshift(entry.comment); this.leading.splice(i, 1); } } return leadingComments; }; CommentHandler.prototype.visitNode = function (node, metadata) { if (node.type === syntax_1.Syntax.Program && node.body.length > 0) { return; } this.insertInnerComments(node, metadata); var trailingComments = this.findTrailingComments(metadata); var leadingComments = this.findLeadingComments(metadata); if (leadingComments.length > 0) { node.leadingComments = leadingComments; } if (trailingComments.length > 0) { node.trailingComments = trailingComments; } this.stack.push({ node: node, start: metadata.start.offset }); }; CommentHandler.prototype.visitComment = function (node, metadata) { var type = (node.type[0] === 'L') ? 'Line' : 'Block'; var comment = { type: type, value: node.value }; if (node.range) { comment.range = node.range; } if (node.loc) { comment.loc = node.loc; } this.comments.push(comment); if (this.attach) { var entry = { comment: { type: type, value: node.value, range: [metadata.start.offset, metadata.end.offset] }, start: metadata.start.offset }; if (node.loc) { entry.comment.loc = node.loc; } node.type = type; this.leading.push(entry); this.trailing.push(entry); } }; CommentHandler.prototype.visit = function (node, metadata) { if (node.type === 'LineComment') { this.visitComment(node, metadata); } else if (node.type === 'BlockComment') { this.visitComment(node, metadata); } else if (this.attach) { this.visitNode(node, metadata); } }; return CommentHandler; }()); exports.CommentHandler = CommentHandler; /***/ }, /* 2 */ /***/ function(module, exports) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.Syntax = { AssignmentExpression: 'AssignmentExpression', AssignmentPattern: 'AssignmentPattern', ArrayExpression: 'ArrayExpression', ArrayPattern: 'ArrayPattern', ArrowFunctionExpression: 'ArrowFunctionExpression', AwaitExpression: 'AwaitExpression', BlockStatement: 'BlockStatement', BinaryExpression: 'BinaryExpression', BreakStatement: 'BreakStatement', CallExpression: 'CallExpression', CatchClause: 'CatchClause', ClassBody: 'ClassBody', ClassDeclaration: 'ClassDeclaration', ClassExpression: 'ClassExpression', ConditionalExpression: 'ConditionalExpression', ContinueStatement: 'ContinueStatement', DoWhileStatement: 'DoWhileStatement', DebuggerStatement: 'DebuggerStatement', EmptyStatement: 'EmptyStatement', ExportAllDeclaration: 'ExportAllDeclaration', ExportDefaultDeclaration: 'ExportDefaultDeclaration', ExportNamedDeclaration: 'ExportNamedDeclaration', ExportSpecifier: 'ExportSpecifier', ExpressionStatement: 'ExpressionStatement', ForStatement: 'ForStatement', ForOfStatement: 'ForOfStatement', ForInStatement: 'ForInStatement', FunctionDeclaration: 'FunctionDeclaration', FunctionExpression: 'FunctionExpression', Identifier: 'Identifier', IfStatement: 'IfStatement', ImportDeclaration: 'ImportDeclaration', ImportDefaultSpecifier: 'ImportDefaultSpecifier', ImportNamespaceSpecifier: 'ImportNamespaceSpecifier', ImportSpecifier: 'ImportSpecifier', Literal: 'Literal', LabeledStatement: 'LabeledStatement', LogicalExpression: 'LogicalExpression', MemberExpression: 'MemberExpression', MetaProperty: 'MetaProperty', MethodDefinition: 'MethodDefinition', NewExpression: 'NewExpression', ObjectExpression: 'ObjectExpression', ObjectPattern: 'ObjectPattern', Program: 'Program', Property: 'Property', RestElement: 'RestElement', ReturnStatement: 'ReturnStatement', SequenceExpression: 'SequenceExpression', SpreadElement: 'SpreadElement', Super: 'Super', SwitchCase: 'SwitchCase', SwitchStatement: 'SwitchStatement', TaggedTemplateExpression: 'TaggedTemplateExpression', TemplateElement: 'TemplateElement', TemplateLiteral: 'TemplateLiteral', ThisExpression: 'ThisExpression', ThrowStatement: 'ThrowStatement', TryStatement: 'TryStatement', UnaryExpression: 'UnaryExpression', UpdateExpression: 'UpdateExpression', VariableDeclaration: 'VariableDeclaration', VariableDeclarator: 'VariableDeclarator', WhileStatement: 'WhileStatement', WithStatement: 'WithStatement', YieldExpression: 'YieldExpression' }; /***/ }, /* 3 */ /***/ function(module, exports, __webpack_require__) { "use strict"; /* istanbul ignore next */ var __extends = (this && this.__extends) || (function () { var extendStatics = Object.setPrototypeOf || ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; return function (d, b) { extendStatics(d, b); function __() { this.constructor = d; } d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); }; })(); Object.defineProperty(exports, "__esModule", { value: true }); var character_1 = __webpack_require__(4); var JSXNode = __webpack_require__(5); var jsx_syntax_1 = __webpack_require__(6); var Node = __webpack_require__(7); var parser_1 = __webpack_require__(8); var token_1 = __webpack_require__(13); var xhtml_entities_1 = __webpack_require__(14); token_1.TokenName[100 /* Identifier */] = 'JSXIdentifier'; token_1.TokenName[101 /* Text */] = 'JSXText'; // Fully qualified element name, e.g. returns "svg:path" function getQualifiedElementName(elementName) { var qualifiedName; switch (elementName.type) { case jsx_syntax_1.JSXSyntax.JSXIdentifier: var id = elementName; qualifiedName = id.name; break; case jsx_syntax_1.JSXSyntax.JSXNamespacedName: var ns = elementName; qualifiedName = getQualifiedElementName(ns.namespace) + ':' + getQualifiedElementName(ns.name); break; case jsx_syntax_1.JSXSyntax.JSXMemberExpression: var expr = elementName; qualifiedName = getQualifiedElementName(expr.object) + '.' + getQualifiedElementName(expr.property); break; /* istanbul ignore next */ default: break; } return qualifiedName; } var JSXParser = (function (_super) { __extends(JSXParser, _super); function JSXParser(code, options, delegate) { return _super.call(this, code, options, delegate) || this; } JSXParser.prototype.parsePrimaryExpression = function () { return this.match('<') ? this.parseJSXRoot() : _super.prototype.parsePrimaryExpression.call(this); }; JSXParser.prototype.startJSX = function () { // Unwind the scanner before the lookahead token. this.scanner.index = this.startMarker.index; this.scanner.lineNumber = this.startMarker.line; this.scanner.lineStart = this.startMarker.index - this.startMarker.column; }; JSXParser.prototype.finishJSX = function () { // Prime the next lookahead. this.nextToken(); }; JSXParser.prototype.reenterJSX = function () { this.startJSX(); this.expectJSX('}'); // Pop the closing '}' added from the lookahead. if (this.config.tokens) { this.tokens.pop(); } }; JSXParser.prototype.createJSXNode = function () { this.collectComments(); return { index: this.scanner.index, line: this.scanner.lineNumber, column: this.scanner.index - this.scanner.lineStart }; }; JSXParser.prototype.createJSXChildNode = function () { return { index: this.scanner.index, line: this.scanner.lineNumber, column: this.scanner.index - this.scanner.lineStart }; }; JSXParser.prototype.scanXHTMLEntity = function (quote) { var result = '&'; var valid = true; var terminated = false; var numeric = false; var hex = false; while (!this.scanner.eof() && valid && !terminated) { var ch = this.scanner.source[this.scanner.index]; if (ch === quote) { break; } terminated = (ch === ';'); result += ch; ++this.scanner.index; if (!terminated) { switch (result.length) { case 2: // e.g. '{' numeric = (ch === '#'); break; case 3: if (numeric) { // e.g. 'A' hex = (ch === 'x'); valid = hex || character_1.Character.isDecimalDigit(ch.charCodeAt(0)); numeric = numeric && !hex; } break; default: valid = valid && !(numeric && !character_1.Character.isDecimalDigit(ch.charCodeAt(0))); valid = valid && !(hex && !character_1.Character.isHexDigit(ch.charCodeAt(0))); break; } } } if (valid && terminated && result.length > 2) { // e.g. 'A' becomes just '#x41' var str = result.substr(1, result.length - 2); if (numeric && str.length > 1) { result = String.fromCharCode(parseInt(str.substr(1), 10)); } else if (hex && str.length > 2) { result = String.fromCharCode(parseInt('0' + str.substr(1), 16)); } else if (!numeric && !hex && xhtml_entities_1.XHTMLEntities[str]) { result = xhtml_entities_1.XHTMLEntities[str]; } } return result; }; // Scan the next JSX token. This replaces Scanner#lex when in JSX mode. JSXParser.prototype.lexJSX = function () { var cp = this.scanner.source.charCodeAt(this.scanner.index); // < > / : = { } if (cp === 60 || cp === 62 || cp === 47 || cp === 58 || cp === 61 || cp === 123 || cp === 125) { var value = this.scanner.source[this.scanner.index++]; return { type: 7 /* Punctuator */, value: value, lineNumber: this.scanner.lineNumber, lineStart: this.scanner.lineStart, start: this.scanner.index - 1, end: this.scanner.index }; } // " ' if (cp === 34 || cp === 39) { var start = this.scanner.index; var quote = this.scanner.source[this.scanner.index++]; var str = ''; while (!this.scanner.eof()) { var ch = this.scanner.source[this.scanner.index++]; if (ch === quote) { break; } else if (ch === '&') { str += this.scanXHTMLEntity(quote); } else { str += ch; } } return { type: 8 /* StringLiteral */, value: str, lineNumber: this.scanner.lineNumber, lineStart: this.scanner.lineStart, start: start, end: this.scanner.index }; } // ... or . if (cp === 46) { var n1 = this.scanner.source.charCodeAt(this.scanner.index + 1); var n2 = this.scanner.source.charCodeAt(this.scanner.index + 2); var value = (n1 === 46 && n2 === 46) ? '...' : '.'; var start = this.scanner.index; this.scanner.index += value.length; return { type: 7 /* Punctuator */, value: value, lineNumber: this.scanner.lineNumber, lineStart: this.scanner.lineStart, start: start, end: this.scanner.index }; } // ` if (cp === 96) { // Only placeholder, since it will be rescanned as a real assignment expression. return { type: 10 /* Template */, value: '', lineNumber: this.scanner.lineNumber, lineStart: this.scanner.lineStart, start: this.scanner.index, end: this.scanner.index }; } // Identifer can not contain backslash (char code 92). if (character_1.Character.isIdentifierStart(cp) && (cp !== 92)) { var start = this.scanner.index; ++this.scanner.index; while (!this.scanner.eof()) { var ch = this.scanner.source.charCodeAt(this.scanner.index); if (character_1.Character.isIdentifierPart(ch) && (ch !== 92)) { ++this.scanner.index; } else if (ch === 45) { // Hyphen (char code 45) can be part of an identifier. ++this.scanner.index; } else { break; } } var id = this.scanner.source.slice(start, this.scanner.index); return { type: 100 /* Identifier */, value: id, lineNumber: this.scanner.lineNumber, lineStart: this.scanner.lineStart, start: start, end: this.scanner.index }; } return this.scanner.lex(); }; JSXParser.prototype.nextJSXToken = function () { this.collectComments(); this.startMarker.index = this.scanner.index; this.startMarker.line = this.scanner.lineNumber; this.startMarker.column = this.scanner.index - this.scanner.lineStart; var token = this.lexJSX(); this.lastMarker.index = this.scanner.index; this.lastMarker.line = this.scanner.lineNumber; this.lastMarker.column = this.scanner.index - this.scanner.lineStart; if (this.config.tokens) { this.tokens.push(this.convertToken(token)); } return token; }; JSXParser.prototype.nextJSXText = function () { this.startMarker.index = this.scanner.index; this.startMarker.line = this.scanner.lineNumber; this.startMarker.column = this.scanner.index - this.scanner.lineStart; var start = this.scanner.index; var text = ''; while (!this.scanner.eof()) { var ch = this.scanner.source[this.scanner.index]; if (ch === '{' || ch === '<') { break; } ++this.scanner.index; text += ch; if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) { ++this.scanner.lineNumber; if (ch === '\r' && this.scanner.source[this.scanner.index] === '\n') { ++this.scanner.index; } this.scanner.lineStart = this.scanner.index; } } this.lastMarker.index = this.scanner.index; this.lastMarker.line = this.scanner.lineNumber; this.lastMarker.column = this.scanner.index - this.scanner.lineStart; var token = { type: 101 /* Text */, value: text, lineNumber: this.scanner.lineNumber, lineStart: this.scanner.lineStart, start: start, end: this.scanner.index }; if ((text.length > 0) && this.config.tokens) { this.tokens.push(this.convertToken(token)); } return token; }; JSXParser.prototype.peekJSXToken = function () { var state = this.scanner.saveState(); this.scanner.scanComments(); var next = this.lexJSX(); this.scanner.restoreState(state); return next; }; // Expect the next JSX token to match the specified punctuator. // If not, an exception will be thrown. JSXParser.prototype.expectJSX = function (value) { var token = this.nextJSXToken(); if (token.type !== 7 /* Punctuator */ || token.value !== value) { this.throwUnexpectedToken(token); } }; // Return true if the next JSX token matches the specified punctuator. JSXParser.prototype.matchJSX = function (value) { var next = this.peekJSXToken(); return next.type === 7 /* Punctuator */ && next.value === value; }; JSXParser.prototype.parseJSXIdentifier = function () { var node = this.createJSXNode(); var token = this.nextJSXToken(); if (token.type !== 100 /* Identifier */) { this.throwUnexpectedToken(token); } return this.finalize(node, new JSXNode.JSXIdentifier(token.value)); }; JSXParser.prototype.parseJSXElementName = function () { var node = this.createJSXNode(); var elementName = this.parseJSXIdentifier(); if (this.matchJSX(':')) { var namespace = elementName; this.expectJSX(':'); var name_1 = this.parseJSXIdentifier(); elementName = this.finalize(node, new JSXNode.JSXNamespacedName(namespace, name_1)); } else if (this.matchJSX('.')) { while (this.matchJSX('.')) { var object = elementName; this.expectJSX('.'); var property = this.parseJSXIdentifier(); elementName = this.finalize(node, new JSXNode.JSXMemberExpression(object, property)); } } return elementName; }; JSXParser.prototype.parseJSXAttributeName = function () { var node = this.createJSXNode(); var attributeName; var identifier = this.parseJSXIdentifier(); if (this.matchJSX(':')) { var namespace = identifier; this.expectJSX(':'); var name_2 = this.parseJSXIdentifier(); attributeName = this.finalize(node, new JSXNode.JSXNamespacedName(namespace, name_2)); } else { attributeName = identifier; } return attributeName; }; JSXParser.prototype.parseJSXStringLiteralAttribute = function () { var node = this.createJSXNode(); var token = this.nextJSXToken(); if (token.type !== 8 /* StringLiteral */) { this.throwUnexpectedToken(token); } var raw = this.getTokenRaw(token); return this.finalize(node, new Node.Literal(token.value, raw)); }; JSXParser.prototype.parseJSXExpressionAttribute = function () { var node = this.createJSXNode(); this.expectJSX('{'); this.finishJSX(); if (this.match('}')) { this.tolerateError('JSX attributes must only be assigned a non-empty expression'); } var expression = this.parseAssignmentExpression(); this.reenterJSX(); return this.finalize(node, new JSXNode.JSXExpressionContainer(expression)); }; JSXParser.prototype.parseJSXAttributeValue = function () { return this.matchJSX('{') ? this.parseJSXExpressionAttribute() : this.matchJSX('<') ? this.parseJSXElement() : this.parseJSXStringLiteralAttribute(); }; JSXParser.prototype.parseJSXNameValueAttribute = function () { var node = this.createJSXNode(); var name = this.parseJSXAttributeName(); var value = null; if (this.matchJSX('=')) { this.expectJSX('='); value = this.parseJSXAttributeValue(); } return this.finalize(node, new JSXNode.JSXAttribute(name, value)); }; JSXParser.prototype.parseJSXSpreadAttribute = function () { var node = this.createJSXNode(); this.expectJSX('{'); this.expectJSX('...'); this.finishJSX(); var argument = this.parseAssignmentExpression(); this.reenterJSX(); return this.finalize(node, new JSXNode.JSXSpreadAttribute(argument)); }; JSXParser.prototype.parseJSXAttributes = function () { var attributes = []; while (!this.matchJSX('/') && !this.matchJSX('>')) { var attribute = this.matchJSX('{') ? this.parseJSXSpreadAttribute() : this.parseJSXNameValueAttribute(); attributes.push(attribute); } return attributes; }; JSXParser.prototype.parseJSXOpeningElement = function () { var node = this.createJSXNode(); this.expectJSX('<'); var name = this.parseJSXElementName(); var attributes = this.parseJSXAttributes(); var selfClosing = this.matchJSX('/'); if (selfClosing) { this.expectJSX('/'); } this.expectJSX('>'); return this.finalize(node, new JSXNode.JSXOpeningElement(name, selfClosing, attributes)); }; JSXParser.prototype.parseJSXBoundaryElement = function () { var node = this.createJSXNode(); this.expectJSX('<'); if (this.matchJSX('/')) { this.expectJSX('/'); var name_3 = this.parseJSXElementName(); this.expectJSX('>'); return this.finalize(node, new JSXNode.JSXClosingElement(name_3)); } var name = this.parseJSXElementName(); var attributes = this.parseJSXAttributes(); var selfClosing = this.matchJSX('/'); if (selfClosing) { this.expectJSX('/'); } this.expectJSX('>'); return this.finalize(node, new JSXNode.JSXOpeningElement(name, selfClosing, attributes)); }; JSXParser.prototype.parseJSXEmptyExpression = function () { var node = this.createJSXChildNode(); this.collectComments(); this.lastMarker.index = this.scanner.index; this.lastMarker.line = this.scanner.lineNumber; this.lastMarker.column = this.scanner.index - this.scanner.lineStart; return this.finalize(node, new JSXNode.JSXEmptyExpression()); }; JSXParser.prototype.parseJSXExpressionContainer = function () { var node = this.createJSXNode(); this.expectJSX('{'); var expression; if (this.matchJSX('}')) { expression = this.parseJSXEmptyExpression(); this.expectJSX('}'); } else { this.finishJSX(); expression = this.parseAssignmentExpression(); this.reenterJSX(); } return this.finalize(node, new JSXNode.JSXExpressionContainer(expression)); }; JSXParser.prototype.parseJSXChildren = function () { var children = []; while (!this.scanner.eof()) { var node = this.createJSXChildNode(); var token = this.nextJSXText(); if (token.start < token.end) { var raw = this.getTokenRaw(token); var child = this.finalize(node, new JSXNode.JSXText(token.value, raw)); children.push(child); } if (this.scanner.source[this.scanner.index] === '{') { var container = this.parseJSXExpressionContainer(); children.push(container); } else { break; } } return children; }; JSXParser.prototype.parseComplexJSXElement = function (el) { var stack = []; while (!this.scanner.eof()) { el.children = el.children.concat(this.parseJSXChildren()); var node = this.createJSXChildNode(); var element = this.parseJSXBoundaryElement(); if (element.type === jsx_syntax_1.JSXSyntax.JSXOpeningElement) { var opening = element; if (opening.selfClosing) { var child = this.finalize(node, new JSXNode.JSXElement(opening, [], null)); el.children.push(child); } else { stack.push(el); el = { node: node, opening: opening, closing: null, children: [] }; } } if (element.type === jsx_syntax_1.JSXSyntax.JSXClosingElement) { el.closing = element; var open_1 = getQualifiedElementName(el.opening.name); var close_1 = getQualifiedElementName(el.closing.name); if (open_1 !== close_1) { this.tolerateError('Expected corresponding JSX closing tag for %0', open_1); } if (stack.length > 0) { var child = this.finalize(el.node, new JSXNode.JSXElement(el.opening, el.children, el.closing)); el = stack[stack.length - 1]; el.children.push(child); stack.pop(); } else { break; } } } return el; }; JSXParser.prototype.parseJSXElement = function () { var node = this.createJSXNode(); var opening = this.parseJSXOpeningElement(); var children = []; var closing = null; if (!opening.selfClosing) { var el = this.parseComplexJSXElement({ node: node, opening: opening, closing: closing, children: children }); children = el.children; closing = el.closing; } return this.finalize(node, new JSXNode.JSXElement(opening, children, closing)); }; JSXParser.prototype.parseJSXRoot = function () { // Pop the opening '<' added from the lookahead. if (this.config.tokens) { this.tokens.pop(); } this.startJSX(); var element = this.parseJSXElement(); this.finishJSX(); return element; }; JSXParser.prototype.isStartOfExpression = function () { return _super.prototype.isStartOfExpression.call(this) || this.match('<'); }; return JSXParser; }(parser_1.Parser)); exports.JSXParser = JSXParser; /***/ }, /* 4 */ /***/ function(module, exports) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); // See also tools/generate-unicode-regex.js. var Regex = { // Unicode v8.0.0 NonAsciiIdentifierStart: NonAsciiIdentifierStart: /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B4\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309B-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDF00-\uDF19]|\uD806[\uDCA0-\uDCDF\uDCFF\uDEC0-\uDEF8]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50\uDF93-\uDF9F]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD83A[\uDC00-\uDCC4]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1]|\uD87E[\uDC00-\uDE1D]/, // Unicode v8.0.0 NonAsciiIdentifierPart: NonAsciiIdentifierPart: /[\xAA\xB5\xB7\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0-\u08B4\u08E3-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0AF9\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D01-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D57\u0D5F-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1369-\u1371\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19DA\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1CD0-\u1CD2\u1CD4-\u1CF6\u1CF8\u1CF9\u1D00-\u1DF5\u1DFC-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C4\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA8FD\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDDFD\uDE80-\uDE9C\uDEA0-\uDED0\uDEE0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF7A\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00-\uDE03\uDE05\uDE06\uDE0C-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE38-\uDE3A\uDE3F\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE6\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC00-\uDC46\uDC66-\uDC6F\uDC7F-\uDCBA\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD00-\uDD34\uDD36-\uDD3F\uDD50-\uDD73\uDD76\uDD80-\uDDC4\uDDCA-\uDDCC\uDDD0-\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE37\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEEA\uDEF0-\uDEF9\uDF00-\uDF03\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3C-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF50\uDF57\uDF5D-\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC80-\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDB5\uDDB8-\uDDC0\uDDD8-\uDDDD\uDE00-\uDE40\uDE44\uDE50-\uDE59\uDE80-\uDEB7\uDEC0-\uDEC9\uDF00-\uDF19\uDF1D-\uDF2B\uDF30-\uDF39]|\uD806[\uDCA0-\uDCE9\uDCFF\uDEC0-\uDEF8]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDED0-\uDEED\uDEF0-\uDEF4\uDF00-\uDF36\uDF40-\uDF43\uDF50-\uDF59\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50-\uDF7E\uDF8F-\uDF9F]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD83A[\uDC00-\uDCC4\uDCD0-\uDCD6]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1]|\uD87E[\uDC00-\uDE1D]|\uDB40[\uDD00-\uDDEF]/ }; exports.Character = { /* tslint:disable:no-bitwise */ fromCodePoint: function (cp) { return (cp < 0x10000) ? String.fromCharCode(cp) : String.fromCharCode(0xD800 + ((cp - 0x10000) >> 10)) + String.fromCharCode(0xDC00 + ((cp - 0x10000) & 1023)); }, // https://tc39.github.io/ecma262/#sec-white-space isWhiteSpace: function (cp) { return (cp === 0x20) || (cp === 0x09) || (cp === 0x0B) || (cp === 0x0C) || (cp === 0xA0) || (cp >= 0x1680 && [0x1680, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200A, 0x202F, 0x205F, 0x3000, 0xFEFF].indexOf(cp) >= 0); }, // https://tc39.github.io/ecma262/#sec-line-terminators isLineTerminator: function (cp) { return (cp === 0x0A) || (cp === 0x0D) || (cp === 0x2028) || (cp === 0x2029); }, // https://tc39.github.io/ecma262/#sec-names-and-keywords isIdentifierStart: function (cp) { return (cp === 0x24) || (cp === 0x5F) || (cp >= 0x41 && cp <= 0x5A) || (cp >= 0x61 && cp <= 0x7A) || (cp === 0x5C) || ((cp >= 0x80) && Regex.NonAsciiIdentifierStart.test(exports.Character.fromCodePoint(cp))); }, isIdentifierPart: function (cp) { return (cp === 0x24) || (cp === 0x5F) || (cp >= 0x41 && cp <= 0x5A) || (cp >= 0x61 && cp <= 0x7A) || (cp >= 0x30 && cp <= 0x39) || (cp === 0x5C) || ((cp >= 0x80) && Regex.NonAsciiIdentifierPart.test(exports.Character.fromCodePoint(cp))); }, // https://tc39.github.io/ecma262/#sec-literals-numeric-literals isDecimalDigit: function (cp) { return (cp >= 0x30 && cp <= 0x39); // 0..9 }, isHexDigit: function (cp) { return (cp >= 0x30 && cp <= 0x39) || (cp >= 0x41 && cp <= 0x46) || (cp >= 0x61 && cp <= 0x66); // a..f }, isOctalDigit: function (cp) { return (cp >= 0x30 && cp <= 0x37); // 0..7 } }; /***/ }, /* 5 */ /***/ function(module, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); var jsx_syntax_1 = __webpack_require__(6); /* tslint:disable:max-classes-per-file */ var JSXClosingElement = (function () { function JSXClosingElement(name) { this.type = jsx_syntax_1.JSXSyntax.JSXClosingElement; this.name = name; } return JSXClosingElement; }()); exports.JSXClosingElement = JSXClosingElement; var JSXElement = (function () { function JSXElement(openingElement, children, closingElement) { this.type = jsx_syntax_1.JSXSyntax.JSXElement; this.openingElement = openingElement; this.children = children; this.closingElement = closingElement; } return JSXElement; }()); exports.JSXElement = JSXElement; var JSXEmptyExpression = (function () { function JSXEmptyExpression() { this.type = jsx_syntax_1.JSXSyntax.JSXEmptyExpression; } return JSXEmptyExpression; }()); exports.JSXEmptyExpression = JSXEmptyExpression; var JSXExpressionContainer = (function () { function JSXExpressionContainer(expression) { this.type = jsx_syntax_1.JSXSyntax.JSXExpressionContainer; this.expression = expression; } return JSXExpressionContainer; }()); exports.JSXExpressionContainer = JSXExpressionContainer; var JSXIdentifier = (function () { function JSXIdentifier(name) { this.type = jsx_syntax_1.JSXSyntax.JSXIdentifier; this.name = name; } return JSXIdentifier; }()); exports.JSXIdentifier = JSXIdentifier; var JSXMemberExpression = (function () { function JSXMemberExpression(object, property) { this.type = jsx_syntax_1.JSXSyntax.JSXMemberExpression; this.object = object; this.property = property; } return JSXMemberExpression; }()); exports.JSXMemberExpression = JSXMemberExpression; var JSXAttribute = (function () { function JSXAttribute(name, value) { this.type = jsx_syntax_1.JSXSyntax.JSXAttribute; this.name = name; this.value = value; } return JSXAttribute; }()); exports.JSXAttribute = JSXAttribute; var JSXNamespacedName = (function () { function JSXNamespacedName(namespace, name) { this.type = jsx_syntax_1.JSXSyntax.JSXNamespacedName; this.namespace = namespace; this.name = name; } return JSXNamespacedName; }()); exports.JSXNamespacedName = JSXNamespacedName; var JSXOpeningElement = (function () { function JSXOpeningElement(name, selfClosing, attributes) { this.type = jsx_syntax_1.JSXSyntax.JSXOpeningElement; this.name = name; this.selfClosing = selfClosing; this.attributes = attributes; } return JSXOpeningElement; }()); exports.JSXOpeningElement = JSXOpeningElement; var JSXSpreadAttribute = (function () { function JSXSpreadAttribute(argument) { this.type = jsx_syntax_1.JSXSyntax.JSXSpreadAttribute; this.argument = argument; } return JSXSpreadAttribute; }()); exports.JSXSpreadAttribute = JSXSpreadAttribute; var JSXText = (function () { function JSXText(value, raw) { this.type = jsx_syntax_1.JSXSyntax.JSXText; this.value = value; this.raw = raw; } return JSXText; }()); exports.JSXText = JSXText; /***/ }, /* 6 */ /***/ function(module, exports) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.JSXSyntax = { JSXAttribute: 'JSXAttribute', JSXClosingElement: 'JSXClosingElement', JSXElement: 'JSXElement', JSXEmptyExpression: 'JSXEmptyExpression', JSXExpressionContainer: 'JSXExpressionContainer', JSXIdentifier: 'JSXIdentifier', JSXMemberExpression: 'JSXMemberExpression', JSXNamespacedName: 'JSXNamespacedName', JSXOpeningElement: 'JSXOpeningElement', JSXSpreadAttribute: 'JSXSpreadAttribute', JSXText: 'JSXText' }; /***/ }, /* 7 */ /***/ function(module, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); var syntax_1 = __webpack_require__(2); /* tslint:disable:max-classes-per-file */ var ArrayExpression = (function () { function ArrayExpression(elements) { this.type = syntax_1.Syntax.ArrayExpression; this.elements = elements; } return ArrayExpression; }()); exports.ArrayExpression = ArrayExpression; var ArrayPattern = (function () { function ArrayPattern(elements) { this.type = syntax_1.Syntax.ArrayPattern; this.elements = elements; } return ArrayPattern; }()); exports.ArrayPattern = ArrayPattern; var ArrowFunctionExpression = (function () { function ArrowFunctionExpression(params, body, expression) { this.type = syntax_1.Syntax.ArrowFunctionExpression; this.id = null; this.params = params; this.body = body; this.generator = false; this.expression = expression; this.async = false; } return ArrowFunctionExpression; }()); exports.ArrowFunctionExpression = ArrowFunctionExpression; var AssignmentExpression = (function () { function AssignmentExpression(operator, left, right) { this.type = syntax_1.Syntax.AssignmentExpression; this.operator = operator; this.left = left; this.right = right; } return AssignmentExpression; }()); exports.AssignmentExpression = AssignmentExpression; var AssignmentPattern = (function () { function AssignmentPattern(left, right) { this.type = syntax_1.Syntax.AssignmentPattern; this.left = left; this.right = right; } return AssignmentPattern; }()); exports.AssignmentPattern = AssignmentPattern; var AsyncArrowFunctionExpression = (function () { function AsyncArrowFunctionExpression(params, body, expression) { this.type = syntax_1.Syntax.ArrowFunctionExpression; this.id = null; this.params = params; this.body = body; this.generator = false; this.expression = expression; this.async = true; } return AsyncArrowFunctionExpression; }()); exports.AsyncArrowFunctionExpression = AsyncArrowFunctionExpression; var AsyncFunctionDeclaration = (function () { function AsyncFunctionDeclaration(id, params, body) { this.type = syntax_1.Syntax.FunctionDeclaration; this.id = id; this.params = params; this.body = body; this.generator = false; this.expression = false; this.async = true; } return AsyncFunctionDeclaration; }()); exports.AsyncFunctionDeclaration = AsyncFunctionDeclaration; var AsyncFunctionExpression = (function () { function AsyncFunctionExpression(id, params, body) { this.type = syntax_1.Syntax.FunctionExpression; this.id = id; this.params = params; this.body = body; this.generator = false; this.expression = false; this.async = true; } return AsyncFunctionExpression; }()); exports.AsyncFunctionExpression = AsyncFunctionExpression; var AwaitExpression = (function () { function AwaitExpression(argument) { this.type = syntax_1.Syntax.AwaitExpression; this.argument = argument; } return AwaitExpression; }()); exports.AwaitExpression = AwaitExpression; var BinaryExpression = (function () { function BinaryExpression(operator, left, right) { var logical = (operator === '||' || operator === '&&'); this.type = logical ? syntax_1.Syntax.LogicalExpression : syntax_1.Syntax.BinaryExpression; this.operator = operator; this.left = left; this.right = right; } return BinaryExpression; }()); exports.BinaryExpression = BinaryExpression; var BlockStatement = (function () { function BlockStatement(body) { this.type = syntax_1.Syntax.BlockStatement; this.body = body; } return BlockStatement; }()); exports.BlockStatement = BlockStatement; var BreakStatement = (function () { function BreakStatement(label) { this.type = syntax_1.Syntax.BreakStatement; this.label = label; } return BreakStatement; }()); exports.BreakStatement = BreakStatement; var CallExpression = (function () { function CallExpression(callee, args) { this.type = syntax_1.Syntax.CallExpression; this.callee = callee; this.arguments = args; } return CallExpression; }()); exports.CallExpression = CallExpression; var CatchClause = (function () { function CatchClause(param, body) { this.type = syntax_1.Syntax.CatchClause; this.param = param; this.body = body; } return CatchClause; }()); exports.CatchClause = CatchClause; var ClassBody = (function () { function ClassBody(body) { this.type = syntax_1.Syntax.ClassBody; this.body = body; } return ClassBody; }()); exports.ClassBody = ClassBody; var ClassDeclaration = (function () { function ClassDeclaration(id, superClass, body) { this.type = syntax_1.Syntax.ClassDeclaration; this.id = id; this.superClass = superClass; this.body = body; } return ClassDeclaration; }()); exports.ClassDeclaration = ClassDeclaration; var ClassExpression = (function () { function ClassExpression(id, superClass, body) { this.type = syntax_1.Syntax.ClassExpression; this.id = id; this.superClass = superClass; this.body = body; } return ClassExpression; }()); exports.ClassExpression = ClassExpression; var ComputedMemberExpression = (function () { function ComputedMemberExpression(object, property) { this.type = syntax_1.Syntax.MemberExpression; this.computed = true; this.object = object; this.property = property; } return ComputedMemberExpression; }()); exports.ComputedMemberExpression = ComputedMemberExpression; var ConditionalExpression = (function () { function ConditionalExpression(test, consequent, alternate) { this.type = syntax_1.Syntax.ConditionalExpression; this.test = test; this.consequent = consequent; this.alternate = alternate; } return ConditionalExpression; }()); exports.ConditionalExpression = ConditionalExpression; var ContinueStatement = (function () { function ContinueStatement(label) { this.type = syntax_1.Syntax.ContinueStatement; this.label = label; } return ContinueStatement; }()); exports.ContinueStatement = ContinueStatement; var DebuggerStatement = (function () { function DebuggerStatement() { this.type = syntax_1.Syntax.DebuggerStatement; } return DebuggerStatement; }()); exports.DebuggerStatement = DebuggerStatement; var Directive = (function () { function Directive(expression, directive) { this.type = syntax_1.Syntax.ExpressionStatement; this.expression = expression; this.directive = directive; } return Directive; }()); exports.Directive = Directive; var DoWhileStatement = (function () { function DoWhileStatement(body, test) { this.type = syntax_1.Syntax.DoWhileStatement; this.body = body; this.test = test; } return DoWhileStatement; }()); exports.DoWhileStatement = DoWhileStatement; var EmptyStatement = (function () { function EmptyStatement() { this.type = syntax_1.Syntax.EmptyStatement; } return EmptyStatement; }()); exports.EmptyStatement = EmptyStatement; var ExportAllDeclaration = (function () { function ExportAllDeclaration(source) { this.type = syntax_1.Syntax.ExportAllDeclaration; this.source = source; } return ExportAllDeclaration; }()); exports.ExportAllDeclaration = ExportAllDeclaration; var ExportDefaultDeclaration = (function () { function ExportDefaultDeclaration(declaration) { this.type = syntax_1.Syntax.ExportDefaultDeclaration; this.declaration = declaration; } return ExportDefaultDeclaration; }()); exports.ExportDefaultDeclaration = ExportDefaultDeclaration; var ExportNamedDeclaration = (function () { function ExportNamedDeclaration(declaration, specifiers, source) { this.type = syntax_1.Syntax.ExportNamedDeclaration; this.declaration = declaration; this.specifiers = specifiers; this.source = source; } return ExportNamedDeclaration; }()); exports.ExportNamedDeclaration = ExportNamedDeclaration; var ExportSpecifier = (function () { function ExportSpecifier(local, exported) { this.type = syntax_1.Syntax.ExportSpecifier; this.exported = exported; this.local = local; } return ExportSpecifier; }()); exports.ExportSpecifier = ExportSpecifier; var ExpressionStatement = (function () { function ExpressionStatement(expression) { this.type = syntax_1.Syntax.ExpressionStatement; this.expression = expression; } return ExpressionStatement; }()); exports.ExpressionStatement = ExpressionStatement; var ForInStatement = (function () { function ForInStatement(left, right, body) { this.type = syntax_1.Syntax.ForInStatement; this.left = left; this.right = right; this.body = body; this.each = false; } return ForInStatement; }()); exports.ForInStatement = ForInStatement; var ForOfStatement = (function () { function ForOfStatement(left, right, body) { this.type = syntax_1.Syntax.ForOfStatement; this.left = left; this.right = right; this.body = body; } return ForOfStatement; }()); exports.ForOfStatement = ForOfStatement; var ForStatement = (function () { function ForStatement(init, test, update, body) { this.type = syntax_1.Syntax.ForStatement; this.init = init; this.test = test; this.update = update; this.body = body; } return ForStatement; }()); exports.ForStatement = ForStatement; var FunctionDeclaration = (function () { function FunctionDeclaration(id, params, body, generator) { this.type = syntax_1.Syntax.FunctionDeclaration; this.id = id; this.params = params; this.body = body; this.generator = generator; this.expression = false; this.async = false; } return FunctionDeclaration; }()); exports.FunctionDeclaration = FunctionDeclaration; var FunctionExpression = (function () { function FunctionExpression(id, params, body, generator) { this.type = syntax_1.Syntax.FunctionExpression; this.id = id; this.params = params; this.body = body; this.generator = generator; this.expression = false; this.async = false; } return FunctionExpression; }()); exports.FunctionExpression = FunctionExpression; var Identifier = (function () { function Identifier(name) { this.type = syntax_1.Syntax.Identifier; this.name = name; } return Identifier; }()); exports.Identifier = Identifier; var IfStatement = (function () { function IfStatement(test, consequent, alternate) { this.type = syntax_1.Syntax.IfStatement; this.test = test; this.consequent = consequent; this.alternate = alternate; } return IfStatement; }()); exports.IfStatement = IfStatement; var ImportDeclaration = (function () { function ImportDeclaration(specifiers, source) { this.type = syntax_1.Syntax.ImportDeclaration; this.specifiers = specifiers; this.source = source; } return ImportDeclaration; }()); exports.ImportDeclaration = ImportDeclaration; var ImportDefaultSpecifier = (function () { function ImportDefaultSpecifier(local) { this.type = syntax_1.Syntax.ImportDefaultSpecifier; this.local = local; } return ImportDefaultSpecifier; }()); exports.ImportDefaultSpecifier = ImportDefaultSpecifier; var ImportNamespaceSpecifier = (function () { function ImportNamespaceSpecifier(local) { this.type = syntax_1.Syntax.ImportNamespaceSpecifier; this.local = local; } return ImportNamespaceSpecifier; }()); exports.ImportNamespaceSpecifier = ImportNamespaceSpecifier; var ImportSpecifier = (function () { function ImportSpecifier(local, imported) { this.type = syntax_1.Syntax.ImportSpecifier; this.local = local; this.imported = imported; } return ImportSpecifier; }()); exports.ImportSpecifier = ImportSpecifier; var LabeledStatement = (function () { function LabeledStatement(label, body) { this.type = syntax_1.Syntax.LabeledStatement; this.label = label; this.body = body; } return LabeledStatement; }()); exports.LabeledStatement = LabeledStatement; var Literal = (function () { function Literal(value, raw) { this.type = syntax_1.Syntax.Literal; this.value = value; this.raw = raw; } return Literal; }()); exports.Literal = Literal; var MetaProperty = (function () { function MetaProperty(meta, property) { this.type = syntax_1.Syntax.MetaProperty; this.meta = meta; this.property = property; } return MetaProperty; }()); exports.MetaProperty = MetaProperty; var MethodDefinition = (function () { function MethodDefinition(key, computed, value, kind, isStatic) { this.type = syntax_1.Syntax.MethodDefinition; this.key = key; this.computed = computed; this.value = value; this.kind = kind; this.static = isStatic; } return MethodDefinition; }()); exports.MethodDefinition = MethodDefinition; var Module = (function () { function Module(body) { this.type = syntax_1.Syntax.Program; this.body = body; this.sourceType = 'module'; } return Module; }()); exports.Module = Module; var NewExpression = (function () { function NewExpression(callee, args) { this.type = syntax_1.Syntax.NewExpression; this.callee = callee; this.arguments = args; } return NewExpression; }()); exports.NewExpression = NewExpression; var ObjectExpression = (function () { function ObjectExpression(properties) { this.type = syntax_1.Syntax.ObjectExpression; this.properties = properties; } return ObjectExpression; }()); exports.ObjectExpression = ObjectExpression; var ObjectPattern = (function () { function ObjectPattern(properties) { this.type = syntax_1.Syntax.ObjectPattern; this.properties = properties; } return ObjectPattern; }()); exports.ObjectPattern = ObjectPattern; var Property = (function () { function Property(kind, key, computed, value, method, shorthand) { this.type = syntax_1.Syntax.Property; this.key = key; this.computed = computed; this.value = value; this.kind = kind; this.method = method; this.shorthand = shorthand; } return Property; }()); exports.Property = Property; var RegexLiteral = (function () { function RegexLiteral(value, raw, pattern, flags) { this.type = syntax_1.Syntax.Literal; this.value = value; this.raw = raw; this.regex = { pattern: pattern, flags: flags }; } return RegexLiteral; }()); exports.RegexLiteral = RegexLiteral; var RestElement = (function () { function RestElement(argument) { this.type = syntax_1.Syntax.RestElement; this.argument = argument; } return RestElement; }()); exports.RestElement = RestElement; var ReturnStatement = (function () { function ReturnStatement(argument) { this.type = syntax_1.Syntax.ReturnStatement; this.argument = argument; } return ReturnStatement; }()); exports.ReturnStatement = ReturnStatement; var Script = (function () { function Script(body) { this.type = syntax_1.Syntax.Program; this.body = body; this.sourceType = 'script'; } return Script; }()); exports.Script = Script; var SequenceExpression = (function () { function SequenceExpression(expressions) { this.type = syntax_1.Syntax.SequenceExpression; this.expressions = expressions; } return SequenceExpression; }()); exports.SequenceExpression = SequenceExpression; var SpreadElement = (function () { function SpreadElement(argument) { this.type = syntax_1.Syntax.SpreadElement; this.argument = argument; } return SpreadElement; }()); exports.SpreadElement = SpreadElement; var StaticMemberExpression = (function () { function StaticMemberExpression(object, property) { this.type = syntax_1.Syntax.MemberExpression; this.computed = false; this.object = object; this.property = property; } return StaticMemberExpression; }()); exports.StaticMemberExpression = StaticMemberExpression; var Super = (function () { function Super() { this.type = syntax_1.Syntax.Super; } return Super; }()); exports.Super = Super; var SwitchCase = (function () { function SwitchCase(test, consequent) { this.type = syntax_1.Syntax.SwitchCase; this.test = test; this.consequent = consequent; } return SwitchCase; }()); exports.SwitchCase = SwitchCase; var SwitchStatement = (function () { function SwitchStatement(discriminant, cases) { this.type = syntax_1.Syntax.SwitchStatement; this.discriminant = discriminant; this.cases = cases; } return SwitchStatement; }()); exports.SwitchStatement = SwitchStatement; var TaggedTemplateExpression = (function () { function TaggedTemplateExpression(tag, quasi) { this.type = syntax_1.Syntax.TaggedTemplateExpression; this.tag = tag; this.quasi = quasi; } return TaggedTemplateExpression; }()); exports.TaggedTemplateExpression = TaggedTemplateExpression; var TemplateElement = (function () { function TemplateElement(value, tail) { this.type = syntax_1.Syntax.TemplateElement; this.value = value; this.tail = tail; } return TemplateElement; }()); exports.TemplateElement = TemplateElement; var TemplateLiteral = (function () { function TemplateLiteral(quasis, expressions) { this.type = syntax_1.Syntax.TemplateLiteral; this.quasis = quasis; this.expressions = expressions; } return TemplateLiteral; }()); exports.TemplateLiteral = TemplateLiteral; var ThisExpression = (function () { function ThisExpression() { this.type = syntax_1.Syntax.ThisExpression; } return ThisExpression; }()); exports.ThisExpression = ThisExpression; var ThrowStatement = (function () { function ThrowStatement(argument) { this.type = syntax_1.Syntax.ThrowStatement; this.argument = argument; } return ThrowStatement; }()); exports.ThrowStatement = ThrowStatement; var TryStatement = (function () { function TryStatement(block, handler, finalizer) { this.type = syntax_1.Syntax.TryStatement; this.block = block; this.handler = handler; this.finalizer = finalizer; } return TryStatement; }()); exports.TryStatement = TryStatement; var UnaryExpression = (function () { function UnaryExpression(operator, argument) { this.type = syntax_1.Syntax.UnaryExpression; this.operator = operator; this.argument = argument; this.prefix = true; } return UnaryExpression; }()); exports.UnaryExpression = UnaryExpression; var UpdateExpression = (function () { function UpdateExpression(operator, argument, prefix) { this.type = syntax_1.Syntax.UpdateExpression; this.operator = operator; this.argument = argument; this.prefix = prefix; } return UpdateExpression; }()); exports.UpdateExpression = UpdateExpression; var VariableDeclaration = (function () { function VariableDeclaration(declarations, kind) { this.type = syntax_1.Syntax.VariableDeclaration; this.declarations = declarations; this.kind = kind; } return VariableDeclaration; }()); exports.VariableDeclaration = VariableDeclaration; var VariableDeclarator = (function () { function VariableDeclarator(id, init) { this.type = syntax_1.Syntax.VariableDeclarator; this.id = id; this.init = init; } return VariableDeclarator; }()); exports.VariableDeclarator = VariableDeclarator; var WhileStatement = (function () { function WhileStatement(test, body) { this.type = syntax_1.Syntax.WhileStatement; this.test = test; this.body = body; } return WhileStatement; }()); exports.WhileStatement = WhileStatement; var WithStatement = (function () { function WithStatement(object, body) { this.type = syntax_1.Syntax.WithStatement; this.object = object; this.body = body; } return WithStatement; }()); exports.WithStatement = WithStatement; var YieldExpression = (function () { function YieldExpression(argument, delegate) { this.type = syntax_1.Syntax.YieldExpression; this.argument = argument; this.delegate = delegate; } return YieldExpression; }()); exports.YieldExpression = YieldExpression; /***/ }, /* 8 */ /***/ function(module, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); var assert_1 = __webpack_require__(9); var error_handler_1 = __webpack_require__(10); var messages_1 = __webpack_require__(11); var Node = __webpack_require__(7); var scanner_1 = __webpack_require__(12); var syntax_1 = __webpack_require__(2); var token_1 = __webpack_require__(13); var ArrowParameterPlaceHolder = 'ArrowParameterPlaceHolder'; var Parser = (function () { function Parser(code, options, delegate) { if (options === void 0) { options = {}; } this.config = { range: (typeof options.range === 'boolean') && options.range, loc: (typeof options.loc === 'boolean') && options.loc, source: null, tokens: (typeof options.tokens === 'boolean') && options.tokens, comment: (typeof options.comment === 'boolean') && options.comment, tolerant: (typeof options.tolerant === 'boolean') && options.tolerant }; if (this.config.loc && options.source && options.source !== null) { this.config.source = String(options.source); } this.delegate = delegate; this.errorHandler = new error_handler_1.ErrorHandler(); this.errorHandler.tolerant = this.config.tolerant; this.scanner = new scanner_1.Scanner(code, this.errorHandler); this.scanner.trackComment = this.config.comment; this.operatorPrecedence = { ')': 0, ';': 0, ',': 0, '=': 0, ']': 0, '||': 1, '&&': 2, '|': 3, '^': 4, '&': 5, '==': 6, '!=': 6, '===': 6, '!==': 6, '<': 7, '>': 7, '<=': 7, '>=': 7, '<<': 8, '>>': 8, '>>>': 8, '+': 9, '-': 9, '*': 11, '/': 11, '%': 11 }; this.lookahead = { type: 2 /* EOF */, value: '', lineNumber: this.scanner.lineNumber, lineStart: 0, start: 0, end: 0 }; this.hasLineTerminator = false; this.context = { isModule: false, await: false, allowIn: true, allowStrictDirective: true, allowYield: true, firstCoverInitializedNameError: null, isAssignmentTarget: false, isBindingElement: false, inFunctionBody: false, inIteration: false, inSwitch: false, labelSet: {}, strict: false }; this.tokens = []; this.startMarker = { index: 0, line: this.scanner.lineNumber, column: 0 }; this.lastMarker = { index: 0, line: this.scanner.lineNumber, column: 0 }; this.nextToken(); this.lastMarker = { index: this.scanner.index, line: this.scanner.lineNumber, column: this.scanner.index - this.scanner.lineStart }; } Parser.prototype.throwError = function (messageFormat) { var values = []; for (var _i = 1; _i < arguments.length; _i++) { values[_i - 1] = arguments[_i]; } var args = Array.prototype.slice.call(arguments, 1); var msg = messageFormat.replace(/%(\d)/g, function (whole, idx) { assert_1.assert(idx < args.length, 'Message reference must be in range'); return args[idx]; }); var index = this.lastMarker.index; var line = this.lastMarker.line; var column = this.lastMarker.column + 1; throw this.errorHandler.createError(index, line, column, msg); }; Parser.prototype.tolerateError = function (messageFormat) { var values = []; for (var _i = 1; _i < arguments.length; _i++) { values[_i - 1] = arguments[_i]; } var args = Array.prototype.slice.call(arguments, 1); var msg = messageFormat.replace(/%(\d)/g, function (whole, idx) { assert_1.assert(idx < args.length, 'Message reference must be in range'); return args[idx]; }); var index = this.lastMarker.index; var line = this.scanner.lineNumber; var column = this.lastMarker.column + 1; this.errorHandler.tolerateError(index, line, column, msg); }; // Throw an exception because of the token. Parser.prototype.unexpectedTokenError = function (token, message) { var msg = message || messages_1.Messages.UnexpectedToken; var value; if (token) { if (!message) { msg = (token.type === 2 /* EOF */) ? messages_1.Messages.UnexpectedEOS : (token.type === 3 /* Identifier */) ? messages_1.Messages.UnexpectedIdentifier : (token.type === 6 /* NumericLiteral */) ? messages_1.Messages.UnexpectedNumber : (token.type === 8 /* StringLiteral */) ? messages_1.Messages.UnexpectedString : (token.type === 10 /* Template */) ? messages_1.Messages.UnexpectedTemplate : messages_1.Messages.UnexpectedToken; if (token.type === 4 /* Keyword */) { if (this.scanner.isFutureReservedWord(token.value)) { msg = messages_1.Messages.UnexpectedReserved; } else if (this.context.strict && this.scanner.isStrictModeReservedWord(token.value)) { msg = messages_1.Messages.StrictReservedWord; } } } value = token.value; } else { value = 'ILLEGAL'; } msg = msg.replace('%0', value); if (token && typeof token.lineNumber === 'number') { var index = token.start; var line = token.lineNumber; var lastMarkerLineStart = this.lastMarker.index - this.lastMarker.column; var column = token.start - lastMarkerLineStart + 1; return this.errorHandler.createError(index, line, column, msg); } else { var index = this.lastMarker.index; var line = this.lastMarker.line; var column = this.lastMarker.column + 1; return this.errorHandler.createError(index, line, column, msg); } }; Parser.prototype.throwUnexpectedToken = function (token, message) { throw this.unexpectedTokenError(token, message); }; Parser.prototype.tolerateUnexpectedToken = function (token, message) { this.errorHandler.tolerate(this.unexpectedTokenError(token, message)); }; Parser.prototype.collectComments = function () { if (!this.config.comment) { this.scanner.scanComments(); } else { var comments = this.scanner.scanComments(); if (comments.length > 0 && this.delegate) { for (var i = 0; i < comments.length; ++i) { var e = comments[i]; var node = void 0; node = { type: e.multiLine ? 'BlockComment' : 'LineComment', value: this.scanner.source.slice(e.slice[0], e.slice[1]) }; if (this.config.range) { node.range = e.range; } if (this.config.loc) { node.loc = e.loc; } var metadata = { start: { line: e.loc.start.line, column: e.loc.start.column, offset: e.range[0] }, end: { line: e.loc.end.line, column: e.loc.end.column, offset: e.range[1] } }; this.delegate(node, metadata); } } } }; // From internal representation to an external structure Parser.prototype.getTokenRaw = function (token) { return this.scanner.source.slice(token.start, token.end); }; Parser.prototype.convertToken = function (token) { var t = { type: token_1.TokenName[token.type], value: this.getTokenRaw(token) }; if (this.config.range) { t.range = [token.start, token.end]; } if (this.config.loc) { t.loc = { start: { line: this.startMarker.line, column: this.startMarker.column }, end: { line: this.scanner.lineNumber, column: this.scanner.index - this.scanner.lineStart } }; } if (token.type === 9 /* RegularExpression */) { var pattern = token.pattern; var flags = token.flags; t.regex = { pattern: pattern, flags: flags }; } return t; }; Parser.prototype.nextToken = function () { var token = this.lookahead; this.lastMarker.index = this.scanner.index; this.lastMarker.line = this.scanner.lineNumber; this.lastMarker.column = this.scanner.index - this.scanner.lineStart; this.collectComments(); if (this.scanner.index !== this.startMarker.index) { this.startMarker.index = this.scanner.index; this.startMarker.line = this.scanner.lineNumber; this.startMarker.column = this.scanner.index - this.scanner.lineStart; } var next = this.scanner.lex(); this.hasLineTerminator = (token.lineNumber !== next.lineNumber); if (next && this.context.strict && next.type === 3 /* Identifier */) { if (this.scanner.isStrictModeReservedWord(next.value)) { next.type = 4 /* Keyword */; } } this.lookahead = next; if (this.config.tokens && next.type !== 2 /* EOF */) { this.tokens.push(this.convertToken(next)); } return token; }; Parser.prototype.nextRegexToken = function () { this.collectComments(); var token = this.scanner.scanRegExp(); if (this.config.tokens) { // Pop the previous token, '/' or '/=' // This is added from the lookahead token. this.tokens.pop(); this.tokens.push(this.convertToken(token)); } // Prime the next lookahead. this.lookahead = token; this.nextToken(); return token; }; Parser.prototype.createNode = function () { return { index: this.startMarker.index, line: this.startMarker.line, column: this.startMarker.column }; }; Parser.prototype.startNode = function (token, lastLineStart) { if (lastLineStart === void 0) { lastLineStart = 0; } var column = token.start - token.lineStart; var line = token.lineNumber; if (column < 0) { column += lastLineStart; line--; } return { index: token.start, line: line, column: column }; }; Parser.prototype.finalize = function (marker, node) { if (this.config.range) { node.range = [marker.index, this.lastMarker.index]; } if (this.config.loc) { node.loc = { start: { line: marker.line, column: marker.column, }, end: { line: this.lastMarker.line, column: this.lastMarker.column } }; if (this.config.source) { node.loc.source = this.config.source; } } if (this.delegate) { var metadata = { start: { line: marker.line, column: marker.column, offset: marker.index }, end: { line: this.lastMarker.line, column: this.lastMarker.column, offset: this.lastMarker.index } }; this.delegate(node, metadata); } return node; }; // Expect the next token to match the specified punctuator. // If not, an exception will be thrown. Parser.prototype.expect = function (value) { var token = this.nextToken(); if (token.type !== 7 /* Punctuator */ || token.value !== value) { this.throwUnexpectedToken(token); } }; // Quietly expect a comma when in tolerant mode, otherwise delegates to expect(). Parser.prototype.expectCommaSeparator = function () { if (this.config.tolerant) { var token = this.lookahead; if (token.type === 7 /* Punctuator */ && token.value === ',') { this.nextToken(); } else if (token.type === 7 /* Punctuator */ && token.value === ';') { this.nextToken(); this.tolerateUnexpectedToken(token); } else { this.tolerateUnexpectedToken(token, messages_1.Messages.UnexpectedToken); } } else { this.expect(','); } }; // Expect the next token to match the specified keyword. // If not, an exception will be thrown. Parser.prototype.expectKeyword = function (keyword) { var token = this.nextToken(); if (token.type !== 4 /* Keyword */ || token.value !== keyword) { this.throwUnexpectedToken(token); } }; // Return true if the next token matches the specified punctuator. Parser.prototype.match = function (value) { return this.lookahead.type === 7 /* Punctuator */ && this.lookahead.value === value; }; // Return true if the next token matches the specified keyword Parser.prototype.matchKeyword = function (keyword) { return this.lookahead.type === 4 /* Keyword */ && this.lookahead.value === keyword; }; // Return true if the next token matches the specified contextual keyword // (where an identifier is sometimes a keyword depending on the context) Parser.prototype.matchContextualKeyword = function (keyword) { return this.lookahead.type === 3 /* Identifier */ && this.lookahead.value === keyword; }; // Return true if the next token is an assignment operator Parser.prototype.matchAssign = function () { if (this.lookahead.type !== 7 /* Punctuator */) { return false; } var op = this.lookahead.value; return op === '=' || op === '*=' || op === '**=' || op === '/=' || op === '%=' || op === '+=' || op === '-=' || op === '<<=' || op === '>>=' || op === '>>>=' || op === '&=' || op === '^=' || op === '|='; }; // Cover grammar support. // // When an assignment expression position starts with an left parenthesis, the determination of the type // of the syntax is to be deferred arbitrarily long until the end of the parentheses pair (plus a lookahead) // or the first comma. This situation also defers the determination of all the expressions nested in the pair. // // There are three productions that can be parsed in a parentheses pair that needs to be determined // after the outermost pair is closed. They are: // // 1. AssignmentExpression // 2. BindingElements // 3. AssignmentTargets // // In order to avoid exponential backtracking, we use two flags to denote if the production can be // binding element or assignment target. // // The three productions have the relationship: // // BindingElements ⊆ AssignmentTargets ⊆ AssignmentExpression // // with a single exception that CoverInitializedName when used directly in an Expression, generates // an early error. Therefore, we need the third state, firstCoverInitializedNameError, to track the // first usage of CoverInitializedName and report it when we reached the end of the parentheses pair. // // isolateCoverGrammar function runs the given parser function with a new cover grammar context, and it does not // effect the current flags. This means the production the parser parses is only used as an expression. Therefore // the CoverInitializedName check is conducted. // // inheritCoverGrammar function runs the given parse function with a new cover grammar context, and it propagates // the flags outside of the parser. This means the production the parser parses is used as a part of a potential // pattern. The CoverInitializedName check is deferred. Parser.prototype.isolateCoverGrammar = function (parseFunction) { var previousIsBindingElement = this.context.isBindingElement; var previousIsAssignmentTarget = this.context.isAssignmentTarget; var previousFirstCoverInitializedNameError = this.context.firstCoverInitializedNameError; this.context.isBindingElement = true; this.context.isAssignmentTarget = true; this.context.firstCoverInitializedNameError = null; var result = parseFunction.call(this); if (this.context.firstCoverInitializedNameError !== null) { this.throwUnexpectedToken(this.context.firstCoverInitializedNameError); } this.context.isBindingElement = previousIsBindingElement; this.context.isAssignmentTarget = previousIsAssignmentTarget; this.context.firstCoverInitializedNameError = previousFirstCoverInitializedNameError; return result; }; Parser.prototype.inheritCoverGrammar = function (parseFunction) { var previousIsBindingElement = this.context.isBindingElement; var previousIsAssignmentTarget = this.context.isAssignmentTarget; var previousFirstCoverInitializedNameError = this.context.firstCoverInitializedNameError; this.context.isBindingElement = true; this.context.isAssignmentTarget = true; this.context.firstCoverInitializedNameError = null; var result = parseFunction.call(this); this.context.isBindingElement = this.context.isBindingElement && previousIsBindingElement; this.context.isAssignmentTarget = this.context.isAssignmentTarget && previousIsAssignmentTarget; this.context.firstCoverInitializedNameError = previousFirstCoverInitializedNameError || this.context.firstCoverInitializedNameError; return result; }; Parser.prototype.consumeSemicolon = function () { if (this.match(';')) { this.nextToken(); } else if (!this.hasLineTerminator) { if (this.lookahead.type !== 2 /* EOF */ && !this.match('}')) { this.throwUnexpectedToken(this.lookahead); } this.lastMarker.index = this.startMarker.index; this.lastMarker.line = this.startMarker.line; this.lastMarker.column = this.startMarker.column; } }; // https://tc39.github.io/ecma262/#sec-primary-expression Parser.prototype.parsePrimaryExpression = function () { var node = this.createNode(); var expr; var token, raw; switch (this.lookahead.type) { case 3 /* Identifier */: if ((this.context.isModule || this.context.await) && this.lookahead.value === 'await') { this.tolerateUnexpectedToken(this.lookahead); } expr = this.matchAsyncFunction() ? this.parseFunctionExpression() : this.finalize(node, new Node.Identifier(this.nextToken().value)); break; case 6 /* NumericLiteral */: case 8 /* StringLiteral */: if (this.context.strict && this.lookahead.octal) { this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.StrictOctalLiteral); } this.context.isAssignmentTarget = false; this.context.isBindingElement = false; token = this.nextToken(); raw = this.getTokenRaw(token); expr = this.finalize(node, new Node.Literal(token.value, raw)); break; case 1 /* BooleanLiteral */: this.context.isAssignmentTarget = false; this.context.isBindingElement = false; token = this.nextToken(); raw = this.getTokenRaw(token); expr = this.finalize(node, new Node.Literal(token.value === 'true', raw)); break; case 5 /* NullLiteral */: this.context.isAssignmentTarget = false; this.context.isBindingElement = false; token = this.nextToken(); raw = this.getTokenRaw(token); expr = this.finalize(node, new Node.Literal(null, raw)); break; case 10 /* Template */: expr = this.parseTemplateLiteral(); break; case 7 /* Punctuator */: switch (this.lookahead.value) { case '(': this.context.isBindingElement = false; expr = this.inheritCoverGrammar(this.parseGroupExpression); break; case '[': expr = this.inheritCoverGrammar(this.parseArrayInitializer); break; case '{': expr = this.inheritCoverGrammar(this.parseObjectInitializer); break; case '/': case '/=': this.context.isAssignmentTarget = false; this.context.isBindingElement = false; this.scanner.index = this.startMarker.index; token = this.nextRegexToken(); raw = this.getTokenRaw(token); expr = this.finalize(node, new Node.RegexLiteral(token.regex, raw, token.pattern, token.flags)); break; default: expr = this.throwUnexpectedToken(this.nextToken()); } break; case 4 /* Keyword */: if (!this.context.strict && this.context.allowYield && this.matchKeyword('yield')) { expr = this.parseIdentifierName(); } else if (!this.context.strict && this.matchKeyword('let')) { expr = this.finalize(node, new Node.Identifier(this.nextToken().value)); } else { this.context.isAssignmentTarget = false; this.context.isBindingElement = false; if (this.matchKeyword('function')) { expr = this.parseFunctionExpression(); } else if (this.matchKeyword('this')) { this.nextToken(); expr = this.finalize(node, new Node.ThisExpression()); } else if (this.matchKeyword('class')) { expr = this.parseClassExpression(); } else { expr = this.throwUnexpectedToken(this.nextToken()); } } break; default: expr = this.throwUnexpectedToken(this.nextToken()); } return expr; }; // https://tc39.github.io/ecma262/#sec-array-initializer Parser.prototype.parseSpreadElement = function () { var node = this.createNode(); this.expect('...'); var arg = this.inheritCoverGrammar(this.parseAssignmentExpression); return this.finalize(node, new Node.SpreadElement(arg)); }; Parser.prototype.parseArrayInitializer = function () { var node = this.createNode(); var elements = []; this.expect('['); while (!this.match(']')) { if (this.match(',')) { this.nextToken(); elements.push(null); } else if (this.match('...')) { var element = this.parseSpreadElement(); if (!this.match(']')) { this.context.isAssignmentTarget = false; this.context.isBindingElement = false; this.expect(','); } elements.push(element); } else { elements.push(this.inheritCoverGrammar(this.parseAssignmentExpression)); if (!this.match(']')) { this.expect(','); } } } this.expect(']'); return this.finalize(node, new Node.ArrayExpression(elements)); }; // https://tc39.github.io/ecma262/#sec-object-initializer Parser.prototype.parsePropertyMethod = function (params) { this.context.isAssignmentTarget = false; this.context.isBindingElement = false; var previousStrict = this.context.strict; var previousAllowStrictDirective = this.context.allowStrictDirective; this.context.allowStrictDirective = params.simple; var body = this.isolateCoverGrammar(this.parseFunctionSourceElements); if (this.context.strict && params.firstRestricted) { this.tolerateUnexpectedToken(params.firstRestricted, params.message); } if (this.context.strict && params.stricted) { this.tolerateUnexpectedToken(params.stricted, params.message); } this.context.strict = previousStrict; this.context.allowStrictDirective = previousAllowStrictDirective; return body; }; Parser.prototype.parsePropertyMethodFunction = function () { var isGenerator = false; var node = this.createNode(); var previousAllowYield = this.context.allowYield; this.context.allowYield = true; var params = this.parseFormalParameters(); var method = this.parsePropertyMethod(params); this.context.allowYield = previousAllowYield; return this.finalize(node, new Node.FunctionExpression(null, params.params, method, isGenerator)); }; Parser.prototype.parsePropertyMethodAsyncFunction = function () { var node = this.createNode(); var previousAllowYield = this.context.allowYield; var previousAwait = this.context.await; this.context.allowYield = false; this.context.await = true; var params = this.parseFormalParameters(); var method = this.parsePropertyMethod(params); this.context.allowYield = previousAllowYield; this.context.await = previousAwait; return this.finalize(node, new Node.AsyncFunctionExpression(null, params.params, method)); }; Parser.prototype.parseObjectPropertyKey = function () { var node = this.createNode(); var token = this.nextToken(); var key; switch (token.type) { case 8 /* StringLiteral */: case 6 /* NumericLiteral */: if (this.context.strict && token.octal) { this.tolerateUnexpectedToken(token, messages_1.Messages.StrictOctalLiteral); } var raw = this.getTokenRaw(token); key = this.finalize(node, new Node.Literal(token.value, raw)); break; case 3 /* Identifier */: case 1 /* BooleanLiteral */: case 5 /* NullLiteral */: case 4 /* Keyword */: key = this.finalize(node, new Node.Identifier(token.value)); break; case 7 /* Punctuator */: if (token.value === '[') { key = this.isolateCoverGrammar(this.parseAssignmentExpression); this.expect(']'); } else { key = this.throwUnexpectedToken(token); } break; default: key = this.throwUnexpectedToken(token); } return key; }; Parser.prototype.isPropertyKey = function (key, value) { return (key.type === syntax_1.Syntax.Identifier && key.name === value) || (key.type === syntax_1.Syntax.Literal && key.value === value); }; Parser.prototype.parseObjectProperty = function (hasProto) { var node = this.createNode(); var token = this.lookahead; var kind; var key = null; var value = null; var computed = false; var method = false; var shorthand = false; var isAsync = false; if (token.type === 3 /* Identifier */) { var id = token.value; this.nextToken(); computed = this.match('['); isAsync = !this.hasLineTerminator && (id === 'async') && !this.match(':') && !this.match('(') && !this.match('*') && !this.match(','); key = isAsync ? this.parseObjectPropertyKey() : this.finalize(node, new Node.Identifier(id)); } else if (this.match('*')) { this.nextToken(); } else { computed = this.match('['); key = this.parseObjectPropertyKey(); } var lookaheadPropertyKey = this.qualifiedPropertyName(this.lookahead); if (token.type === 3 /* Identifier */ && !isAsync && token.value === 'get' && lookaheadPropertyKey) { kind = 'get'; computed = this.match('['); key = this.parseObjectPropertyKey(); this.context.allowYield = false; value = this.parseGetterMethod(); } else if (token.type === 3 /* Identifier */ && !isAsync && token.value === 'set' && lookaheadPropertyKey) { kind = 'set'; computed = this.match('['); key = this.parseObjectPropertyKey(); value = this.parseSetterMethod(); } else if (token.type === 7 /* Punctuator */ && token.value === '*' && lookaheadPropertyKey) { kind = 'init'; computed = this.match('['); key = this.parseObjectPropertyKey(); value = this.parseGeneratorMethod(); method = true; } else { if (!key) { this.throwUnexpectedToken(this.lookahead); } kind = 'init'; if (this.match(':') && !isAsync) { if (!computed && this.isPropertyKey(key, '__proto__')) { if (hasProto.value) { this.tolerateError(messages_1.Messages.DuplicateProtoProperty); } hasProto.value = true; } this.nextToken(); value = this.inheritCoverGrammar(this.parseAssignmentExpression); } else if (this.match('(')) { value = isAsync ? this.parsePropertyMethodAsyncFunction() : this.parsePropertyMethodFunction(); method = true; } else if (token.type === 3 /* Identifier */) { var id = this.finalize(node, new Node.Identifier(token.value)); if (this.match('=')) { this.context.firstCoverInitializedNameError = this.lookahead; this.nextToken(); shorthand = true; var init = this.isolateCoverGrammar(this.parseAssignmentExpression); value = this.finalize(node, new Node.AssignmentPattern(id, init)); } else { shorthand = true; value = id; } } else { this.throwUnexpectedToken(this.nextToken()); } } return this.finalize(node, new Node.Property(kind, key, computed, value, method, shorthand)); }; Parser.prototype.parseObjectInitializer = function () { var node = this.createNode(); this.expect('{'); var properties = []; var hasProto = { value: false }; while (!this.match('}')) { properties.push(this.parseObjectProperty(hasProto)); if (!this.match('}')) { this.expectCommaSeparator(); } } this.expect('}'); return this.finalize(node, new Node.ObjectExpression(properties)); }; // https://tc39.github.io/ecma262/#sec-template-literals Parser.prototype.parseTemplateHead = function () { assert_1.assert(this.lookahead.head, 'Template literal must start with a template head'); var node = this.createNode(); var token = this.nextToken(); var raw = token.value; var cooked = token.cooked; return this.finalize(node, new Node.TemplateElement({ raw: raw, cooked: cooked }, token.tail)); }; Parser.prototype.parseTemplateElement = function () { if (this.lookahead.type !== 10 /* Template */) { this.throwUnexpectedToken(); } var node = this.createNode(); var token = this.nextToken(); var raw = token.value; var cooked = token.cooked; return this.finalize(node, new Node.TemplateElement({ raw: raw, cooked: cooked }, token.tail)); }; Parser.prototype.parseTemplateLiteral = function () { var node = this.createNode(); var expressions = []; var quasis = []; var quasi = this.parseTemplateHead(); quasis.push(quasi); while (!quasi.tail) { expressions.push(this.parseExpression()); quasi = this.parseTemplateElement(); quasis.push(quasi); } return this.finalize(node, new Node.TemplateLiteral(quasis, expressions)); }; // https://tc39.github.io/ecma262/#sec-grouping-operator Parser.prototype.reinterpretExpressionAsPattern = function (expr) { switch (expr.type) { case syntax_1.Syntax.Identifier: case syntax_1.Syntax.MemberExpression: case syntax_1.Syntax.RestElement: case syntax_1.Syntax.AssignmentPattern: break; case syntax_1.Syntax.SpreadElement: expr.type = syntax_1.Syntax.RestElement; this.reinterpretExpressionAsPattern(expr.argument); break; case syntax_1.Syntax.ArrayExpression: expr.type = syntax_1.Syntax.ArrayPattern; for (var i = 0; i < expr.elements.length; i++) { if (expr.elements[i] !== null) { this.reinterpretExpressionAsPattern(expr.elements[i]); } } break; case syntax_1.Syntax.ObjectExpression: expr.type = syntax_1.Syntax.ObjectPattern; for (var i = 0; i < expr.properties.length; i++) { this.reinterpretExpressionAsPattern(expr.properties[i].value); } break; case syntax_1.Syntax.AssignmentExpression: expr.type = syntax_1.Syntax.AssignmentPattern; delete expr.operator; this.reinterpretExpressionAsPattern(expr.left); break; default: // Allow other node type for tolerant parsing. break; } }; Parser.prototype.parseGroupExpression = function () { var expr; this.expect('('); if (this.match(')')) { this.nextToken(); if (!this.match('=>')) { this.expect('=>'); } expr = { type: ArrowParameterPlaceHolder, params: [], async: false }; } else { var startToken = this.lookahead; var params = []; if (this.match('...')) { expr = this.parseRestElement(params); this.expect(')'); if (!this.match('=>')) { this.expect('=>'); } expr = { type: ArrowParameterPlaceHolder, params: [expr], async: false }; } else { var arrow = false; this.context.isBindingElement = true; expr = this.inheritCoverGrammar(this.parseAssignmentExpression); if (this.match(',')) { var expressions = []; this.context.isAssignmentTarget = false; expressions.push(expr); while (this.lookahead.type !== 2 /* EOF */) { if (!this.match(',')) { break; } this.nextToken(); if (this.match(')')) { this.nextToken(); for (var i = 0; i < expressions.length; i++) { this.reinterpretExpressionAsPattern(expressions[i]); } arrow = true; expr = { type: ArrowParameterPlaceHolder, params: expressions, async: false }; } else if (this.match('...')) { if (!this.context.isBindingElement) { this.throwUnexpectedToken(this.lookahead); } expressions.push(this.parseRestElement(params)); this.expect(')'); if (!this.match('=>')) { this.expect('=>'); } this.context.isBindingElement = false; for (var i = 0; i < expressions.length; i++) { this.reinterpretExpressionAsPattern(expressions[i]); } arrow = true; expr = { type: ArrowParameterPlaceHolder, params: expressions, async: false }; } else { expressions.push(this.inheritCoverGrammar(this.parseAssignmentExpression)); } if (arrow) { break; } } if (!arrow) { expr = this.finalize(this.startNode(startToken), new Node.SequenceExpression(expressions)); } } if (!arrow) { this.expect(')'); if (this.match('=>')) { if (expr.type === syntax_1.Syntax.Identifier && expr.name === 'yield') { arrow = true; expr = { type: ArrowParameterPlaceHolder, params: [expr], async: false }; } if (!arrow) { if (!this.context.isBindingElement) { this.throwUnexpectedToken(this.lookahead); } if (expr.type === syntax_1.Syntax.SequenceExpression) { for (var i = 0; i < expr.expressions.length; i++) { this.reinterpretExpressionAsPattern(expr.expressions[i]); } } else { this.reinterpretExpressionAsPattern(expr); } var parameters = (expr.type === syntax_1.Syntax.SequenceExpression ? expr.expressions : [expr]); expr = { type: ArrowParameterPlaceHolder, params: parameters, async: false }; } } this.context.isBindingElement = false; } } } return expr; }; // https://tc39.github.io/ecma262/#sec-left-hand-side-expressions Parser.prototype.parseArguments = function () { this.expect('('); var args = []; if (!this.match(')')) { while (true) { var expr = this.match('...') ? this.parseSpreadElement() : this.isolateCoverGrammar(this.parseAssignmentExpression); args.push(expr); if (this.match(')')) { break; } this.expectCommaSeparator(); if (this.match(')')) { break; } } } this.expect(')'); return args; }; Parser.prototype.isIdentifierName = function (token) { return token.type === 3 /* Identifier */ || token.type === 4 /* Keyword */ || token.type === 1 /* BooleanLiteral */ || token.type === 5 /* NullLiteral */; }; Parser.prototype.parseIdentifierName = function () { var node = this.createNode(); var token = this.nextToken(); if (!this.isIdentifierName(token)) { this.throwUnexpectedToken(token); } return this.finalize(node, new Node.Identifier(token.value)); }; Parser.prototype.parseNewExpression = function () { var node = this.createNode(); var id = this.parseIdentifierName(); assert_1.assert(id.name === 'new', 'New expression must start with `new`'); var expr; if (this.match('.')) { this.nextToken(); if (this.lookahead.type === 3 /* Identifier */ && this.context.inFunctionBody && this.lookahead.value === 'target') { var property = this.parseIdentifierName(); expr = new Node.MetaProperty(id, property); } else { this.throwUnexpectedToken(this.lookahead); } } else { var callee = this.isolateCoverGrammar(this.parseLeftHandSideExpression); var args = this.match('(') ? this.parseArguments() : []; expr = new Node.NewExpression(callee, args); this.context.isAssignmentTarget = false; this.context.isBindingElement = false; } return this.finalize(node, expr); }; Parser.prototype.parseAsyncArgument = function () { var arg = this.parseAssignmentExpression(); this.context.firstCoverInitializedNameError = null; return arg; }; Parser.prototype.parseAsyncArguments = function () { this.expect('('); var args = []; if (!this.match(')')) { while (true) { var expr = this.match('...') ? this.parseSpreadElement() : this.isolateCoverGrammar(this.parseAsyncArgument); args.push(expr); if (this.match(')')) { break; } this.expectCommaSeparator(); if (this.match(')')) { break; } } } this.expect(')'); return args; }; Parser.prototype.parseLeftHandSideExpressionAllowCall = function () { var startToken = this.lookahead; var maybeAsync = this.matchContextualKeyword('async'); var previousAllowIn = this.context.allowIn; this.context.allowIn = true; var expr; if (this.matchKeyword('super') && this.context.inFunctionBody) { expr = this.createNode(); this.nextToken(); expr = this.finalize(expr, new Node.Super()); if (!this.match('(') && !this.match('.') && !this.match('[')) { this.throwUnexpectedToken(this.lookahead); } } else { expr = this.inheritCoverGrammar(this.matchKeyword('new') ? this.parseNewExpression : this.parsePrimaryExpression); } while (true) { if (this.match('.')) { this.context.isBindingElement = false; this.context.isAssignmentTarget = true; this.expect('.'); var property = this.parseIdentifierName(); expr = this.finalize(this.startNode(startToken), new Node.StaticMemberExpression(expr, property)); } else if (this.match('(')) { var asyncArrow = maybeAsync && (startToken.lineNumber === this.lookahead.lineNumber); this.context.isBindingElement = false; this.context.isAssignmentTarget = false; var args = asyncArrow ? this.parseAsyncArguments() : this.parseArguments(); expr = this.finalize(this.startNode(startToken), new Node.CallExpression(expr, args)); if (asyncArrow && this.match('=>')) { for (var i = 0; i < args.length; ++i) { this.reinterpretExpressionAsPattern(args[i]); } expr = { type: ArrowParameterPlaceHolder, params: args, async: true }; } } else if (this.match('[')) { this.context.isBindingElement = false; this.context.isAssignmentTarget = true; this.expect('['); var property = this.isolateCoverGrammar(this.parseExpression); this.expect(']'); expr = this.finalize(this.startNode(startToken), new Node.ComputedMemberExpression(expr, property)); } else if (this.lookahead.type === 10 /* Template */ && this.lookahead.head) { var quasi = this.parseTemplateLiteral(); expr = this.finalize(this.startNode(startToken), new Node.TaggedTemplateExpression(expr, quasi)); } else { break; } } this.context.allowIn = previousAllowIn; return expr; }; Parser.prototype.parseSuper = function () { var node = this.createNode(); this.expectKeyword('super'); if (!this.match('[') && !this.match('.')) { this.throwUnexpectedToken(this.lookahead); } return this.finalize(node, new Node.Super()); }; Parser.prototype.parseLeftHandSideExpression = function () { assert_1.assert(this.context.allowIn, 'callee of new expression always allow in keyword.'); var node = this.startNode(this.lookahead); var expr = (this.matchKeyword('super') && this.context.inFunctionBody) ? this.parseSuper() : this.inheritCoverGrammar(this.matchKeyword('new') ? this.parseNewExpression : this.parsePrimaryExpression); while (true) { if (this.match('[')) { this.context.isBindingElement = false; this.context.isAssignmentTarget = true; this.expect('['); var property = this.isolateCoverGrammar(this.parseExpression); this.expect(']'); expr = this.finalize(node, new Node.ComputedMemberExpression(expr, property)); } else if (this.match('.')) { this.context.isBindingElement = false; this.context.isAssignmentTarget = true; this.expect('.'); var property = this.parseIdentifierName(); expr = this.finalize(node, new Node.StaticMemberExpression(expr, property)); } else if (this.lookahead.type === 10 /* Template */ && this.lookahead.head) { var quasi = this.parseTemplateLiteral(); expr = this.finalize(node, new Node.TaggedTemplateExpression(expr, quasi)); } else { break; } } return expr; }; // https://tc39.github.io/ecma262/#sec-update-expressions Parser.prototype.parseUpdateExpression = function () { var expr; var startToken = this.lookahead; if (this.match('++') || this.match('--')) { var node = this.startNode(startToken); var token = this.nextToken(); expr = this.inheritCoverGrammar(this.parseUnaryExpression); if (this.context.strict && expr.type === syntax_1.Syntax.Identifier && this.scanner.isRestrictedWord(expr.name)) { this.tolerateError(messages_1.Messages.StrictLHSPrefix); } if (!this.context.isAssignmentTarget) { this.tolerateError(messages_1.Messages.InvalidLHSInAssignment); } var prefix = true; expr = this.finalize(node, new Node.UpdateExpression(token.value, expr, prefix)); this.context.isAssignmentTarget = false; this.context.isBindingElement = false; } else { expr = this.inheritCoverGrammar(this.parseLeftHandSideExpressionAllowCall); if (!this.hasLineTerminator && this.lookahead.type === 7 /* Punctuator */) { if (this.match('++') || this.match('--')) { if (this.context.strict && expr.type === syntax_1.Syntax.Identifier && this.scanner.isRestrictedWord(expr.name)) { this.tolerateError(messages_1.Messages.StrictLHSPostfix); } if (!this.context.isAssignmentTarget) { this.tolerateError(messages_1.Messages.InvalidLHSInAssignment); } this.context.isAssignmentTarget = false; this.context.isBindingElement = false; var operator = this.nextToken().value; var prefix = false; expr = this.finalize(this.startNode(startToken), new Node.UpdateExpression(operator, expr, prefix)); } } } return expr; }; // https://tc39.github.io/ecma262/#sec-unary-operators Parser.prototype.parseAwaitExpression = function () { var node = this.createNode(); this.nextToken(); var argument = this.parseUnaryExpression(); return this.finalize(node, new Node.AwaitExpression(argument)); }; Parser.prototype.parseUnaryExpression = function () { var expr; if (this.match('+') || this.match('-') || this.match('~') || this.match('!') || this.matchKeyword('delete') || this.matchKeyword('void') || this.matchKeyword('typeof')) { var node = this.startNode(this.lookahead); var token = this.nextToken(); expr = this.inheritCoverGrammar(this.parseUnaryExpression); expr = this.finalize(node, new Node.UnaryExpression(token.value, expr)); if (this.context.strict && expr.operator === 'delete' && expr.argument.type === syntax_1.Syntax.Identifier) { this.tolerateError(messages_1.Messages.StrictDelete); } this.context.isAssignmentTarget = false; this.context.isBindingElement = false; } else if (this.context.await && this.matchContextualKeyword('await')) { expr = this.parseAwaitExpression(); } else { expr = this.parseUpdateExpression(); } return expr; }; Parser.prototype.parseExponentiationExpression = function () { var startToken = this.lookahead; var expr = this.inheritCoverGrammar(this.parseUnaryExpression); if (expr.type !== syntax_1.Syntax.UnaryExpression && this.match('**')) { this.nextToken(); this.context.isAssignmentTarget = false; this.context.isBindingElement = false; var left = expr; var right = this.isolateCoverGrammar(this.parseExponentiationExpression); expr = this.finalize(this.startNode(startToken), new Node.BinaryExpression('**', left, right)); } return expr; }; // https://tc39.github.io/ecma262/#sec-exp-operator // https://tc39.github.io/ecma262/#sec-multiplicative-operators // https://tc39.github.io/ecma262/#sec-additive-operators // https://tc39.github.io/ecma262/#sec-bitwise-shift-operators // https://tc39.github.io/ecma262/#sec-relational-operators // https://tc39.github.io/ecma262/#sec-equality-operators // https://tc39.github.io/ecma262/#sec-binary-bitwise-operators // https://tc39.github.io/ecma262/#sec-binary-logical-operators Parser.prototype.binaryPrecedence = function (token) { var op = token.value; var precedence; if (token.type === 7 /* Punctuator */) { precedence = this.operatorPrecedence[op] || 0; } else if (token.type === 4 /* Keyword */) { precedence = (op === 'instanceof' || (this.context.allowIn && op === 'in')) ? 7 : 0; } else { precedence = 0; } return precedence; }; Parser.prototype.parseBinaryExpression = function () { var startToken = this.lookahead; var expr = this.inheritCoverGrammar(this.parseExponentiationExpression); var token = this.lookahead; var prec = this.binaryPrecedence(token); if (prec > 0) { this.nextToken(); this.context.isAssignmentTarget = false; this.context.isBindingElement = false; var markers = [startToken, this.lookahead]; var left = expr; var right = this.isolateCoverGrammar(this.parseExponentiationExpression); var stack = [left, token.value, right]; var precedences = [prec]; while (true) { prec = this.binaryPrecedence(this.lookahead); if (prec <= 0) { break; } // Reduce: make a binary expression from the three topmost entries. while ((stack.length > 2) && (prec <= precedences[precedences.length - 1])) { right = stack.pop(); var operator = stack.pop(); precedences.pop(); left = stack.pop(); markers.pop(); var node = this.startNode(markers[markers.length - 1]); stack.push(this.finalize(node, new Node.BinaryExpression(operator, left, right))); } // Shift. stack.push(this.nextToken().value); precedences.push(prec); markers.push(this.lookahead); stack.push(this.isolateCoverGrammar(this.parseExponentiationExpression)); } // Final reduce to clean-up the stack. var i = stack.length - 1; expr = stack[i]; var lastMarker = markers.pop(); while (i > 1) { var marker = markers.pop(); var lastLineStart = lastMarker && lastMarker.lineStart; var node = this.startNode(marker, lastLineStart); var operator = stack[i - 1]; expr = this.finalize(node, new Node.BinaryExpression(operator, stack[i - 2], expr)); i -= 2; lastMarker = marker; } } return expr; }; // https://tc39.github.io/ecma262/#sec-conditional-operator Parser.prototype.parseConditionalExpression = function () { var startToken = this.lookahead; var expr = this.inheritCoverGrammar(this.parseBinaryExpression); if (this.match('?')) { this.nextToken(); var previousAllowIn = this.context.allowIn; this.context.allowIn = true; var consequent = this.isolateCoverGrammar(this.parseAssignmentExpression); this.context.allowIn = previousAllowIn; this.expect(':'); var alternate = this.isolateCoverGrammar(this.parseAssignmentExpression); expr = this.finalize(this.startNode(startToken), new Node.ConditionalExpression(expr, consequent, alternate)); this.context.isAssignmentTarget = false; this.context.isBindingElement = false; } return expr; }; // https://tc39.github.io/ecma262/#sec-assignment-operators Parser.prototype.checkPatternParam = function (options, param) { switch (param.type) { case syntax_1.Syntax.Identifier: this.validateParam(options, param, param.name); break; case syntax_1.Syntax.RestElement: this.checkPatternParam(options, param.argument); break; case syntax_1.Syntax.AssignmentPattern: this.checkPatternParam(options, param.left); break; case syntax_1.Syntax.ArrayPattern: for (var i = 0; i < param.elements.length; i++) { if (param.elements[i] !== null) { this.checkPatternParam(options, param.elements[i]); } } break; case syntax_1.Syntax.ObjectPattern: for (var i = 0; i < param.properties.length; i++) { this.checkPatternParam(options, param.properties[i].value); } break; default: break; } options.simple = options.simple && (param instanceof Node.Identifier); }; Parser.prototype.reinterpretAsCoverFormalsList = function (expr) { var params = [expr]; var options; var asyncArrow = false; switch (expr.type) { case syntax_1.Syntax.Identifier: break; case ArrowParameterPlaceHolder: params = expr.params; asyncArrow = expr.async; break; default: return null; } options = { simple: true, paramSet: {} }; for (var i = 0; i < params.length; ++i) { var param = params[i]; if (param.type === syntax_1.Syntax.AssignmentPattern) { if (param.right.type === syntax_1.Syntax.YieldExpression) { if (param.right.argument) { this.throwUnexpectedToken(this.lookahead); } param.right.type = syntax_1.Syntax.Identifier; param.right.name = 'yield'; delete param.right.argument; delete param.right.delegate; } } else if (asyncArrow && param.type === syntax_1.Syntax.Identifier && param.name === 'await') { this.throwUnexpectedToken(this.lookahead); } this.checkPatternParam(options, param); params[i] = param; } if (this.context.strict || !this.context.allowYield) { for (var i = 0; i < params.length; ++i) { var param = params[i]; if (param.type === syntax_1.Syntax.YieldExpression) { this.throwUnexpectedToken(this.lookahead); } } } if (options.message === messages_1.Messages.StrictParamDupe) { var token = this.context.strict ? options.stricted : options.firstRestricted; this.throwUnexpectedToken(token, options.message); } return { simple: options.simple, params: params, stricted: options.stricted, firstRestricted: options.firstRestricted, message: options.message }; }; Parser.prototype.parseAssignmentExpression = function () { var expr; if (!this.context.allowYield && this.matchKeyword('yield')) { expr = this.parseYieldExpression(); } else { var startToken = this.lookahead; var token = startToken; expr = this.parseConditionalExpression(); if (token.type === 3 /* Identifier */ && (token.lineNumber === this.lookahead.lineNumber) && token.value === 'async') { if (this.lookahead.type === 3 /* Identifier */ || this.matchKeyword('yield')) { var arg = this.parsePrimaryExpression(); this.reinterpretExpressionAsPattern(arg); expr = { type: ArrowParameterPlaceHolder, params: [arg], async: true }; } } if (expr.type === ArrowParameterPlaceHolder || this.match('=>')) { // https://tc39.github.io/ecma262/#sec-arrow-function-definitions this.context.isAssignmentTarget = false; this.context.isBindingElement = false; var isAsync = expr.async; var list = this.reinterpretAsCoverFormalsList(expr); if (list) { if (this.hasLineTerminator) { this.tolerateUnexpectedToken(this.lookahead); } this.context.firstCoverInitializedNameError = null; var previousStrict = this.context.strict; var previousAllowStrictDirective = this.context.allowStrictDirective; this.context.allowStrictDirective = list.simple; var previousAllowYield = this.context.allowYield; var previousAwait = this.context.await; this.context.allowYield = true; this.context.await = isAsync; var node = this.startNode(startToken); this.expect('=>'); var body = void 0; if (this.match('{')) { var previousAllowIn = this.context.allowIn; this.context.allowIn = true; body = this.parseFunctionSourceElements(); this.context.allowIn = previousAllowIn; } else { body = this.isolateCoverGrammar(this.parseAssignmentExpression); } var expression = body.type !== syntax_1.Syntax.BlockStatement; if (this.context.strict && list.firstRestricted) { this.throwUnexpectedToken(list.firstRestricted, list.message); } if (this.context.strict && list.stricted) { this.tolerateUnexpectedToken(list.stricted, list.message); } expr = isAsync ? this.finalize(node, new Node.AsyncArrowFunctionExpression(list.params, body, expression)) : this.finalize(node, new Node.ArrowFunctionExpression(list.params, body, expression)); this.context.strict = previousStrict; this.context.allowStrictDirective = previousAllowStrictDirective; this.context.allowYield = previousAllowYield; this.context.await = previousAwait; } } else { if (this.matchAssign()) { if (!this.context.isAssignmentTarget) { this.tolerateError(messages_1.Messages.InvalidLHSInAssignment); } if (this.context.strict && expr.type === syntax_1.Syntax.Identifier) { var id = expr; if (this.scanner.isRestrictedWord(id.name)) { this.tolerateUnexpectedToken(token, messages_1.Messages.StrictLHSAssignment); } if (this.scanner.isStrictModeReservedWord(id.name)) { this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord); } } if (!this.match('=')) { this.context.isAssignmentTarget = false; this.context.isBindingElement = false; } else { this.reinterpretExpressionAsPattern(expr); } token = this.nextToken(); var operator = token.value; var right = this.isolateCoverGrammar(this.parseAssignmentExpression); expr = this.finalize(this.startNode(startToken), new Node.AssignmentExpression(operator, expr, right)); this.context.firstCoverInitializedNameError = null; } } } return expr; }; // https://tc39.github.io/ecma262/#sec-comma-operator Parser.prototype.parseExpression = function () { var startToken = this.lookahead; var expr = this.isolateCoverGrammar(this.parseAssignmentExpression); if (this.match(',')) { var expressions = []; expressions.push(expr); while (this.lookahead.type !== 2 /* EOF */) { if (!this.match(',')) { break; } this.nextToken(); expressions.push(this.isolateCoverGrammar(this.parseAssignmentExpression)); } expr = this.finalize(this.startNode(startToken), new Node.SequenceExpression(expressions)); } return expr; }; // https://tc39.github.io/ecma262/#sec-block Parser.prototype.parseStatementListItem = function () { var statement; this.context.isAssignmentTarget = true; this.context.isBindingElement = true; if (this.lookahead.type === 4 /* Keyword */) { switch (this.lookahead.value) { case 'export': if (!this.context.isModule) { this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.IllegalExportDeclaration); } statement = this.parseExportDeclaration(); break; case 'import': if (!this.context.isModule) { this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.IllegalImportDeclaration); } statement = this.parseImportDeclaration(); break; case 'const': statement = this.parseLexicalDeclaration({ inFor: false }); break; case 'function': statement = this.parseFunctionDeclaration(); break; case 'class': statement = this.parseClassDeclaration(); break; case 'let': statement = this.isLexicalDeclaration() ? this.parseLexicalDeclaration({ inFor: false }) : this.parseStatement(); break; default: statement = this.parseStatement(); break; } } else { statement = this.parseStatement(); } return statement; }; Parser.prototype.parseBlock = function () { var node = this.createNode(); this.expect('{'); var block = []; while (true) { if (this.match('}')) { break; } block.push(this.parseStatementListItem()); } this.expect('}'); return this.finalize(node, new Node.BlockStatement(block)); }; // https://tc39.github.io/ecma262/#sec-let-and-const-declarations Parser.prototype.parseLexicalBinding = function (kind, options) { var node = this.createNode(); var params = []; var id = this.parsePattern(params, kind); if (this.context.strict && id.type === syntax_1.Syntax.Identifier) { if (this.scanner.isRestrictedWord(id.name)) { this.tolerateError(messages_1.Messages.StrictVarName); } } var init = null; if (kind === 'const') { if (!this.matchKeyword('in') && !this.matchContextualKeyword('of')) { if (this.match('=')) { this.nextToken(); init = this.isolateCoverGrammar(this.parseAssignmentExpression); } else { this.throwError(messages_1.Messages.DeclarationMissingInitializer, 'const'); } } } else if ((!options.inFor && id.type !== syntax_1.Syntax.Identifier) || this.match('=')) { this.expect('='); init = this.isolateCoverGrammar(this.parseAssignmentExpression); } return this.finalize(node, new Node.VariableDeclarator(id, init)); }; Parser.prototype.parseBindingList = function (kind, options) { var list = [this.parseLexicalBinding(kind, options)]; while (this.match(',')) { this.nextToken(); list.push(this.parseLexicalBinding(kind, options)); } return list; }; Parser.prototype.isLexicalDeclaration = function () { var state = this.scanner.saveState(); this.scanner.scanComments(); var next = this.scanner.lex(); this.scanner.restoreState(state); return (next.type === 3 /* Identifier */) || (next.type === 7 /* Punctuator */ && next.value === '[') || (next.type === 7 /* Punctuator */ && next.value === '{') || (next.type === 4 /* Keyword */ && next.value === 'let') || (next.type === 4 /* Keyword */ && next.value === 'yield'); }; Parser.prototype.parseLexicalDeclaration = function (options) { var node = this.createNode(); var kind = this.nextToken().value; assert_1.assert(kind === 'let' || kind === 'const', 'Lexical declaration must be either let or const'); var declarations = this.parseBindingList(kind, options); this.consumeSemicolon(); return this.finalize(node, new Node.VariableDeclaration(declarations, kind)); }; // https://tc39.github.io/ecma262/#sec-destructuring-binding-patterns Parser.prototype.parseBindingRestElement = function (params, kind) { var node = this.createNode(); this.expect('...'); var arg = this.parsePattern(params, kind); return this.finalize(node, new Node.RestElement(arg)); }; Parser.prototype.parseArrayPattern = function (params, kind) { var node = this.createNode(); this.expect('['); var elements = []; while (!this.match(']')) { if (this.match(',')) { this.nextToken(); elements.push(null); } else { if (this.match('...')) { elements.push(this.parseBindingRestElement(params, kind)); break; } else { elements.push(this.parsePatternWithDefault(params, kind)); } if (!this.match(']')) { this.expect(','); } } } this.expect(']'); return this.finalize(node, new Node.ArrayPattern(elements)); }; Parser.prototype.parsePropertyPattern = function (params, kind) { var node = this.createNode(); var computed = false; var shorthand = false; var method = false; var key; var value; if (this.lookahead.type === 3 /* Identifier */) { var keyToken = this.lookahead; key = this.parseVariableIdentifier(); var init = this.finalize(node, new Node.Identifier(keyToken.value)); if (this.match('=')) { params.push(keyToken); shorthand = true; this.nextToken(); var expr = this.parseAssignmentExpression(); value = this.finalize(this.startNode(keyToken), new Node.AssignmentPattern(init, expr)); } else if (!this.match(':')) { params.push(keyToken); shorthand = true; value = init; } else { this.expect(':'); value = this.parsePatternWithDefault(params, kind); } } else { computed = this.match('['); key = this.parseObjectPropertyKey(); this.expect(':'); value = this.parsePatternWithDefault(params, kind); } return this.finalize(node, new Node.Property('init', key, computed, value, method, shorthand)); }; Parser.prototype.parseObjectPattern = function (params, kind) { var node = this.createNode(); var properties = []; this.expect('{'); while (!this.match('}')) { properties.push(this.parsePropertyPattern(params, kind)); if (!this.match('}')) { this.expect(','); } } this.expect('}'); return this.finalize(node, new Node.ObjectPattern(properties)); }; Parser.prototype.parsePattern = function (params, kind) { var pattern; if (this.match('[')) { pattern = this.parseArrayPattern(params, kind); } else if (this.match('{')) { pattern = this.parseObjectPattern(params, kind); } else { if (this.matchKeyword('let') && (kind === 'const' || kind === 'let')) { this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.LetInLexicalBinding); } params.push(this.lookahead); pattern = this.parseVariableIdentifier(kind); } return pattern; }; Parser.prototype.parsePatternWithDefault = function (params, kind) { var startToken = this.lookahead; var pattern = this.parsePattern(params, kind); if (this.match('=')) { this.nextToken(); var previousAllowYield = this.context.allowYield; this.context.allowYield = true; var right = this.isolateCoverGrammar(this.parseAssignmentExpression); this.context.allowYield = previousAllowYield; pattern = this.finalize(this.startNode(startToken), new Node.AssignmentPattern(pattern, right)); } return pattern; }; // https://tc39.github.io/ecma262/#sec-variable-statement Parser.prototype.parseVariableIdentifier = function (kind) { var node = this.createNode(); var token = this.nextToken(); if (token.type === 4 /* Keyword */ && token.value === 'yield') { if (this.context.strict) { this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord); } else if (!this.context.allowYield) { this.throwUnexpectedToken(token); } } else if (token.type !== 3 /* Identifier */) { if (this.context.strict && token.type === 4 /* Keyword */ && this.scanner.isStrictModeReservedWord(token.value)) { this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord); } else { if (this.context.strict || token.value !== 'let' || kind !== 'var') { this.throwUnexpectedToken(token); } } } else if ((this.context.isModule || this.context.await) && token.type === 3 /* Identifier */ && token.value === 'await') { this.tolerateUnexpectedToken(token); } return this.finalize(node, new Node.Identifier(token.value)); }; Parser.prototype.parseVariableDeclaration = function (options) { var node = this.createNode(); var params = []; var id = this.parsePattern(params, 'var'); if (this.context.strict && id.type === syntax_1.Syntax.Identifier) { if (this.scanner.isRestrictedWord(id.name)) { this.tolerateError(messages_1.Messages.StrictVarName); } } var init = null; if (this.match('=')) { this.nextToken(); init = this.isolateCoverGrammar(this.parseAssignmentExpression); } else if (id.type !== syntax_1.Syntax.Identifier && !options.inFor) { this.expect('='); } return this.finalize(node, new Node.VariableDeclarator(id, init)); }; Parser.prototype.parseVariableDeclarationList = function (options) { var opt = { inFor: options.inFor }; var list = []; list.push(this.parseVariableDeclaration(opt)); while (this.match(',')) { this.nextToken(); list.push(this.parseVariableDeclaration(opt)); } return list; }; Parser.prototype.parseVariableStatement = function () { var node = this.createNode(); this.expectKeyword('var'); var declarations = this.parseVariableDeclarationList({ inFor: false }); this.consumeSemicolon(); return this.finalize(node, new Node.VariableDeclaration(declarations, 'var')); }; // https://tc39.github.io/ecma262/#sec-empty-statement Parser.prototype.parseEmptyStatement = function () { var node = this.createNode(); this.expect(';'); return this.finalize(node, new Node.EmptyStatement()); }; // https://tc39.github.io/ecma262/#sec-expression-statement Parser.prototype.parseExpressionStatement = function () { var node = this.createNode(); var expr = this.parseExpression(); this.consumeSemicolon(); return this.finalize(node, new Node.ExpressionStatement(expr)); }; // https://tc39.github.io/ecma262/#sec-if-statement Parser.prototype.parseIfClause = function () { if (this.context.strict && this.matchKeyword('function')) { this.tolerateError(messages_1.Messages.StrictFunction); } return this.parseStatement(); }; Parser.prototype.parseIfStatement = function () { var node = this.createNode(); var consequent; var alternate = null; this.expectKeyword('if'); this.expect('('); var test = this.parseExpression(); if (!this.match(')') && this.config.tolerant) { this.tolerateUnexpectedToken(this.nextToken()); consequent = this.finalize(this.createNode(), new Node.EmptyStatement()); } else { this.expect(')'); consequent = this.parseIfClause(); if (this.matchKeyword('else')) { this.nextToken(); alternate = this.parseIfClause(); } } return this.finalize(node, new Node.IfStatement(test, consequent, alternate)); }; // https://tc39.github.io/ecma262/#sec-do-while-statement Parser.prototype.parseDoWhileStatement = function () { var node = this.createNode(); this.expectKeyword('do'); var previousInIteration = this.context.inIteration; this.context.inIteration = true; var body = this.parseStatement(); this.context.inIteration = previousInIteration; this.expectKeyword('while'); this.expect('('); var test = this.parseExpression(); if (!this.match(')') && this.config.tolerant) { this.tolerateUnexpectedToken(this.nextToken()); } else { this.expect(')'); if (this.match(';')) { this.nextToken(); } } return this.finalize(node, new Node.DoWhileStatement(body, test)); }; // https://tc39.github.io/ecma262/#sec-while-statement Parser.prototype.parseWhileStatement = function () { var node = this.createNode(); var body; this.expectKeyword('while'); this.expect('('); var test = this.parseExpression(); if (!this.match(')') && this.config.tolerant) { this.tolerateUnexpectedToken(this.nextToken()); body = this.finalize(this.createNode(), new Node.EmptyStatement()); } else { this.expect(')'); var previousInIteration = this.context.inIteration; this.context.inIteration = true; body = this.parseStatement(); this.context.inIteration = previousInIteration; } return this.finalize(node, new Node.WhileStatement(test, body)); }; // https://tc39.github.io/ecma262/#sec-for-statement // https://tc39.github.io/ecma262/#sec-for-in-and-for-of-statements Parser.prototype.parseForStatement = function () { var init = null; var test = null; var update = null; var forIn = true; var left, right; var node = this.createNode(); this.expectKeyword('for'); this.expect('('); if (this.match(';')) { this.nextToken(); } else { if (this.matchKeyword('var')) { init = this.createNode(); this.nextToken(); var previousAllowIn = this.context.allowIn; this.context.allowIn = false; var declarations = this.parseVariableDeclarationList({ inFor: true }); this.context.allowIn = previousAllowIn; if (declarations.length === 1 && this.matchKeyword('in')) { var decl = declarations[0]; if (decl.init && (decl.id.type === syntax_1.Syntax.ArrayPattern || decl.id.type === syntax_1.Syntax.ObjectPattern || this.context.strict)) { this.tolerateError(messages_1.Messages.ForInOfLoopInitializer, 'for-in'); } init = this.finalize(init, new Node.VariableDeclaration(declarations, 'var')); this.nextToken(); left = init; right = this.parseExpression(); init = null; } else if (declarations.length === 1 && declarations[0].init === null && this.matchContextualKeyword('of')) { init = this.finalize(init, new Node.VariableDeclaration(declarations, 'var')); this.nextToken(); left = init; right = this.parseAssignmentExpression(); init = null; forIn = false; } else { init = this.finalize(init, new Node.VariableDeclaration(declarations, 'var')); this.expect(';'); } } else if (this.matchKeyword('const') || this.matchKeyword('let')) { init = this.createNode(); var kind = this.nextToken().value; if (!this.context.strict && this.lookahead.value === 'in') { init = this.finalize(init, new Node.Identifier(kind)); this.nextToken(); left = init; right = this.parseExpression(); init = null; } else { var previousAllowIn = this.context.allowIn; this.context.allowIn = false; var declarations = this.parseBindingList(kind, { inFor: true }); this.context.allowIn = previousAllowIn; if (declarations.length === 1 && declarations[0].init === null && this.matchKeyword('in')) { init = this.finalize(init, new Node.VariableDeclaration(declarations, kind)); this.nextToken(); left = init; right = this.parseExpression(); init = null; } else if (declarations.length === 1 && declarations[0].init === null && this.matchContextualKeyword('of')) { init = this.finalize(init, new Node.VariableDeclaration(declarations, kind)); this.nextToken(); left = init; right = this.parseAssignmentExpression(); init = null; forIn = false; } else { this.consumeSemicolon(); init = this.finalize(init, new Node.VariableDeclaration(declarations, kind)); } } } else { var initStartToken = this.lookahead; var previousAllowIn = this.context.allowIn; this.context.allowIn = false; init = this.inheritCoverGrammar(this.parseAssignmentExpression); this.context.allowIn = previousAllowIn; if (this.matchKeyword('in')) { if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) { this.tolerateError(messages_1.Messages.InvalidLHSInForIn); } this.nextToken(); this.reinterpretExpressionAsPattern(init); left = init; right = this.parseExpression(); init = null; } else if (this.matchContextualKeyword('of')) { if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) { this.tolerateError(messages_1.Messages.InvalidLHSInForLoop); } this.nextToken(); this.reinterpretExpressionAsPattern(init); left = init; right = this.parseAssignmentExpression(); init = null; forIn = false; } else { if (this.match(',')) { var initSeq = [init]; while (this.match(',')) { this.nextToken(); initSeq.push(this.isolateCoverGrammar(this.parseAssignmentExpression)); } init = this.finalize(this.startNode(initStartToken), new Node.SequenceExpression(initSeq)); } this.expect(';'); } } } if (typeof left === 'undefined') { if (!this.match(';')) { test = this.parseExpression(); } this.expect(';'); if (!this.match(')')) { update = this.parseExpression(); } } var body; if (!this.match(')') && this.config.tolerant) { this.tolerateUnexpectedToken(this.nextToken()); body = this.finalize(this.createNode(), new Node.EmptyStatement()); } else { this.expect(')'); var previousInIteration = this.context.inIteration; this.context.inIteration = true; body = this.isolateCoverGrammar(this.parseStatement); this.context.inIteration = previousInIteration; } return (typeof left === 'undefined') ? this.finalize(node, new Node.ForStatement(init, test, update, body)) : forIn ? this.finalize(node, new Node.ForInStatement(left, right, body)) : this.finalize(node, new Node.ForOfStatement(left, right, body)); }; // https://tc39.github.io/ecma262/#sec-continue-statement Parser.prototype.parseContinueStatement = function () { var node = this.createNode(); this.expectKeyword('continue'); var label = null; if (this.lookahead.type === 3 /* Identifier */ && !this.hasLineTerminator) { var id = this.parseVariableIdentifier(); label = id; var key = '$' + id.name; if (!Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) { this.throwError(messages_1.Messages.UnknownLabel, id.name); } } this.consumeSemicolon(); if (label === null && !this.context.inIteration) { this.throwError(messages_1.Messages.IllegalContinue); } return this.finalize(node, new Node.ContinueStatement(label)); }; // https://tc39.github.io/ecma262/#sec-break-statement Parser.prototype.parseBreakStatement = function () { var node = this.createNode(); this.expectKeyword('break'); var label = null; if (this.lookahead.type === 3 /* Identifier */ && !this.hasLineTerminator) { var id = this.parseVariableIdentifier(); var key = '$' + id.name; if (!Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) { this.throwError(messages_1.Messages.UnknownLabel, id.name); } label = id; } this.consumeSemicolon(); if (label === null && !this.context.inIteration && !this.context.inSwitch) { this.throwError(messages_1.Messages.IllegalBreak); } return this.finalize(node, new Node.BreakStatement(label)); }; // https://tc39.github.io/ecma262/#sec-return-statement Parser.prototype.parseReturnStatement = function () { if (!this.context.inFunctionBody) { this.tolerateError(messages_1.Messages.IllegalReturn); } var node = this.createNode(); this.expectKeyword('return'); var hasArgument = (!this.match(';') && !this.match('}') && !this.hasLineTerminator && this.lookahead.type !== 2 /* EOF */) || this.lookahead.type === 8 /* StringLiteral */ || this.lookahead.type === 10 /* Template */; var argument = hasArgument ? this.parseExpression() : null; this.consumeSemicolon(); return this.finalize(node, new Node.ReturnStatement(argument)); }; // https://tc39.github.io/ecma262/#sec-with-statement Parser.prototype.parseWithStatement = function () { if (this.context.strict) { this.tolerateError(messages_1.Messages.StrictModeWith); } var node = this.createNode(); var body; this.expectKeyword('with'); this.expect('('); var object = this.parseExpression(); if (!this.match(')') && this.config.tolerant) { this.tolerateUnexpectedToken(this.nextToken()); body = this.finalize(this.createNode(), new Node.EmptyStatement()); } else { this.expect(')'); body = this.parseStatement(); } return this.finalize(node, new Node.WithStatement(object, body)); }; // https://tc39.github.io/ecma262/#sec-switch-statement Parser.prototype.parseSwitchCase = function () { var node = this.createNode(); var test; if (this.matchKeyword('default')) { this.nextToken(); test = null; } else { this.expectKeyword('case'); test = this.parseExpression(); } this.expect(':'); var consequent = []; while (true) { if (this.match('}') || this.matchKeyword('default') || this.matchKeyword('case')) { break; } consequent.push(this.parseStatementListItem()); } return this.finalize(node, new Node.SwitchCase(test, consequent)); }; Parser.prototype.parseSwitchStatement = function () { var node = this.createNode(); this.expectKeyword('switch'); this.expect('('); var discriminant = this.parseExpression(); this.expect(')'); var previousInSwitch = this.context.inSwitch; this.context.inSwitch = true; var cases = []; var defaultFound = false; this.expect('{'); while (true) { if (this.match('}')) { break; } var clause = this.parseSwitchCase(); if (clause.test === null) { if (defaultFound) { this.throwError(messages_1.Messages.MultipleDefaultsInSwitch); } defaultFound = true; } cases.push(clause); } this.expect('}'); this.context.inSwitch = previousInSwitch; return this.finalize(node, new Node.SwitchStatement(discriminant, cases)); }; // https://tc39.github.io/ecma262/#sec-labelled-statements Parser.prototype.parseLabelledStatement = function () { var node = this.createNode(); var expr = this.parseExpression(); var statement; if ((expr.type === syntax_1.Syntax.Identifier) && this.match(':')) { this.nextToken(); var id = expr; var key = '$' + id.name; if (Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) { this.throwError(messages_1.Messages.Redeclaration, 'Label', id.name); } this.context.labelSet[key] = true; var body = void 0; if (this.matchKeyword('class')) { this.tolerateUnexpectedToken(this.lookahead); body = this.parseClassDeclaration(); } else if (this.matchKeyword('function')) { var token = this.lookahead; var declaration = this.parseFunctionDeclaration(); if (this.context.strict) { this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunction); } else if (declaration.generator) { this.tolerateUnexpectedToken(token, messages_1.Messages.GeneratorInLegacyContext); } body = declaration; } else { body = this.parseStatement(); } delete this.context.labelSet[key]; statement = new Node.LabeledStatement(id, body); } else { this.consumeSemicolon(); statement = new Node.ExpressionStatement(expr); } return this.finalize(node, statement); }; // https://tc39.github.io/ecma262/#sec-throw-statement Parser.prototype.parseThrowStatement = function () { var node = this.createNode(); this.expectKeyword('throw'); if (this.hasLineTerminator) { this.throwError(messages_1.Messages.NewlineAfterThrow); } var argument = this.parseExpression(); this.consumeSemicolon(); return this.finalize(node, new Node.ThrowStatement(argument)); }; // https://tc39.github.io/ecma262/#sec-try-statement Parser.prototype.parseCatchClause = function () { var node = this.createNode(); this.expectKeyword('catch'); this.expect('('); if (this.match(')')) { this.throwUnexpectedToken(this.lookahead); } var params = []; var param = this.parsePattern(params); var paramMap = {}; for (var i = 0; i < params.length; i++) { var key = '$' + params[i].value; if (Object.prototype.hasOwnProperty.call(paramMap, key)) { this.tolerateError(messages_1.Messages.DuplicateBinding, params[i].value); } paramMap[key] = true; } if (this.context.strict && param.type === syntax_1.Syntax.Identifier) { if (this.scanner.isRestrictedWord(param.name)) { this.tolerateError(messages_1.Messages.StrictCatchVariable); } } this.expect(')'); var body = this.parseBlock(); return this.finalize(node, new Node.CatchClause(param, body)); }; Parser.prototype.parseFinallyClause = function () { this.expectKeyword('finally'); return this.parseBlock(); }; Parser.prototype.parseTryStatement = function () { var node = this.createNode(); this.expectKeyword('try'); var block = this.parseBlock(); var handler = this.matchKeyword('catch') ? this.parseCatchClause() : null; var finalizer = this.matchKeyword('finally') ? this.parseFinallyClause() : null; if (!handler && !finalizer) { this.throwError(messages_1.Messages.NoCatchOrFinally); } return this.finalize(node, new Node.TryStatement(block, handler, finalizer)); }; // https://tc39.github.io/ecma262/#sec-debugger-statement Parser.prototype.parseDebuggerStatement = function () { var node = this.createNode(); this.expectKeyword('debugger'); this.consumeSemicolon(); return this.finalize(node, new Node.DebuggerStatement()); }; // https://tc39.github.io/ecma262/#sec-ecmascript-language-statements-and-declarations Parser.prototype.parseStatement = function () { var statement; switch (this.lookahead.type) { case 1 /* BooleanLiteral */: case 5 /* NullLiteral */: case 6 /* NumericLiteral */: case 8 /* StringLiteral */: case 10 /* Template */: case 9 /* RegularExpression */: statement = this.parseExpressionStatement(); break; case 7 /* Punctuator */: var value = this.lookahead.value; if (value === '{') { statement = this.parseBlock(); } else if (value === '(') { statement = this.parseExpressionStatement(); } else if (value === ';') { statement = this.parseEmptyStatement(); } else { statement = this.parseExpressionStatement(); } break; case 3 /* Identifier */: statement = this.matchAsyncFunction() ? this.parseFunctionDeclaration() : this.parseLabelledStatement(); break; case 4 /* Keyword */: switch (this.lookahead.value) { case 'break': statement = this.parseBreakStatement(); break; case 'continue': statement = this.parseContinueStatement(); break; case 'debugger': statement = this.parseDebuggerStatement(); break; case 'do': statement = this.parseDoWhileStatement(); break; case 'for': statement = this.parseForStatement(); break; case 'function': statement = this.parseFunctionDeclaration(); break; case 'if': statement = this.parseIfStatement(); break; case 'return': statement = this.parseReturnStatement(); break; case 'switch': statement = this.parseSwitchStatement(); break; case 'throw': statement = this.parseThrowStatement(); break; case 'try': statement = this.parseTryStatement(); break; case 'var': statement = this.parseVariableStatement(); break; case 'while': statement = this.parseWhileStatement(); break; case 'with': statement = this.parseWithStatement(); break; default: statement = this.parseExpressionStatement(); break; } break; default: statement = this.throwUnexpectedToken(this.lookahead); } return statement; }; // https://tc39.github.io/ecma262/#sec-function-definitions Parser.prototype.parseFunctionSourceElements = function () { var node = this.createNode(); this.expect('{'); var body = this.parseDirectivePrologues(); var previousLabelSet = this.context.labelSet; var previousInIteration = this.context.inIteration; var previousInSwitch = this.context.inSwitch; var previousInFunctionBody = this.context.inFunctionBody; this.context.labelSet = {}; this.context.inIteration = false; this.context.inSwitch = false; this.context.inFunctionBody = true; while (this.lookahead.type !== 2 /* EOF */) { if (this.match('}')) { break; } body.push(this.parseStatementListItem()); } this.expect('}'); this.context.labelSet = previousLabelSet; this.context.inIteration = previousInIteration; this.context.inSwitch = previousInSwitch; this.context.inFunctionBody = previousInFunctionBody; return this.finalize(node, new Node.BlockStatement(body)); }; Parser.prototype.validateParam = function (options, param, name) { var key = '$' + name; if (this.context.strict) { if (this.scanner.isRestrictedWord(name)) { options.stricted = param; options.message = messages_1.Messages.StrictParamName; } if (Object.prototype.hasOwnProperty.call(options.paramSet, key)) { options.stricted = param; options.message = messages_1.Messages.StrictParamDupe; } } else if (!options.firstRestricted) { if (this.scanner.isRestrictedWord(name)) { options.firstRestricted = param; options.message = messages_1.Messages.StrictParamName; } else if (this.scanner.isStrictModeReservedWord(name)) { options.firstRestricted = param; options.message = messages_1.Messages.StrictReservedWord; } else if (Object.prototype.hasOwnProperty.call(options.paramSet, key)) { options.stricted = param; options.message = messages_1.Messages.StrictParamDupe; } } /* istanbul ignore next */ if (typeof Object.defineProperty === 'function') { Object.defineProperty(options.paramSet, key, { value: true, enumerable: true, writable: true, configurable: true }); } else { options.paramSet[key] = true; } }; Parser.prototype.parseRestElement = function (params) { var node = this.createNode(); this.expect('...'); var arg = this.parsePattern(params); if (this.match('=')) { this.throwError(messages_1.Messages.DefaultRestParameter); } if (!this.match(')')) { this.throwError(messages_1.Messages.ParameterAfterRestParameter); } return this.finalize(node, new Node.RestElement(arg)); }; Parser.prototype.parseFormalParameter = function (options) { var params = []; var param = this.match('...') ? this.parseRestElement(params) : this.parsePatternWithDefault(params); for (var i = 0; i < params.length; i++) { this.validateParam(options, params[i], params[i].value); } options.simple = options.simple && (param instanceof Node.Identifier); options.params.push(param); }; Parser.prototype.parseFormalParameters = function (firstRestricted) { var options; options = { simple: true, params: [], firstRestricted: firstRestricted }; this.expect('('); if (!this.match(')')) { options.paramSet = {}; while (this.lookahead.type !== 2 /* EOF */) { this.parseFormalParameter(options); if (this.match(')')) { break; } this.expect(','); if (this.match(')')) { break; } } } this.expect(')'); return { simple: options.simple, params: options.params, stricted: options.stricted, firstRestricted: options.firstRestricted, message: options.message }; }; Parser.prototype.matchAsyncFunction = function () { var match = this.matchContextualKeyword('async'); if (match) { var state = this.scanner.saveState(); this.scanner.scanComments(); var next = this.scanner.lex(); this.scanner.restoreState(state); match = (state.lineNumber === next.lineNumber) && (next.type === 4 /* Keyword */) && (next.value === 'function'); } return match; }; Parser.prototype.parseFunctionDeclaration = function (identifierIsOptional) { var node = this.createNode(); var isAsync = this.matchContextualKeyword('async'); if (isAsync) { this.nextToken(); } this.expectKeyword('function'); var isGenerator = isAsync ? false : this.match('*'); if (isGenerator) { this.nextToken(); } var message; var id = null; var firstRestricted = null; if (!identifierIsOptional || !this.match('(')) { var token = this.lookahead; id = this.parseVariableIdentifier(); if (this.context.strict) { if (this.scanner.isRestrictedWord(token.value)) { this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunctionName); } } else { if (this.scanner.isRestrictedWord(token.value)) { firstRestricted = token; message = messages_1.Messages.StrictFunctionName; } else if (this.scanner.isStrictModeReservedWord(token.value)) { firstRestricted = token; message = messages_1.Messages.StrictReservedWord; } } } var previousAllowAwait = this.context.await; var previousAllowYield = this.context.allowYield; this.context.await = isAsync; this.context.allowYield = !isGenerator; var formalParameters = this.parseFormalParameters(firstRestricted); var params = formalParameters.params; var stricted = formalParameters.stricted; firstRestricted = formalParameters.firstRestricted; if (formalParameters.message) { message = formalParameters.message; } var previousStrict = this.context.strict; var previousAllowStrictDirective = this.context.allowStrictDirective; this.context.allowStrictDirective = formalParameters.simple; var body = this.parseFunctionSourceElements(); if (this.context.strict && firstRestricted) { this.throwUnexpectedToken(firstRestricted, message); } if (this.context.strict && stricted) { this.tolerateUnexpectedToken(stricted, message); } this.context.strict = previousStrict; this.context.allowStrictDirective = previousAllowStrictDirective; this.context.await = previousAllowAwait; this.context.allowYield = previousAllowYield; return isAsync ? this.finalize(node, new Node.AsyncFunctionDeclaration(id, params, body)) : this.finalize(node, new Node.FunctionDeclaration(id, params, body, isGenerator)); }; Parser.prototype.parseFunctionExpression = function () { var node = this.createNode(); var isAsync = this.matchContextualKeyword('async'); if (isAsync) { this.nextToken(); } this.expectKeyword('function'); var isGenerator = isAsync ? false : this.match('*'); if (isGenerator) { this.nextToken(); } var message; var id = null; var firstRestricted; var previousAllowAwait = this.context.await; var previousAllowYield = this.context.allowYield; this.context.await = isAsync; this.context.allowYield = !isGenerator; if (!this.match('(')) { var token = this.lookahead; id = (!this.context.strict && !isGenerator && this.matchKeyword('yield')) ? this.parseIdentifierName() : this.parseVariableIdentifier(); if (this.context.strict) { if (this.scanner.isRestrictedWord(token.value)) { this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunctionName); } } else { if (this.scanner.isRestrictedWord(token.value)) { firstRestricted = token; message = messages_1.Messages.StrictFunctionName; } else if (this.scanner.isStrictModeReservedWord(token.value)) { firstRestricted = token; message = messages_1.Messages.StrictReservedWord; } } } var formalParameters = this.parseFormalParameters(firstRestricted); var params = formalParameters.params; var stricted = formalParameters.stricted; firstRestricted = formalParameters.firstRestricted; if (formalParameters.message) { message = formalParameters.message; } var previousStrict = this.context.strict; var previousAllowStrictDirective = this.context.allowStrictDirective; this.context.allowStrictDirective = formalParameters.simple; var body = this.parseFunctionSourceElements(); if (this.context.strict && firstRestricted) { this.throwUnexpectedToken(firstRestricted, message); } if (this.context.strict && stricted) { this.tolerateUnexpectedToken(stricted, message); } this.context.strict = previousStrict; this.context.allowStrictDirective = previousAllowStrictDirective; this.context.await = previousAllowAwait; this.context.allowYield = previousAllowYield; return isAsync ? this.finalize(node, new Node.AsyncFunctionExpression(id, params, body)) : this.finalize(node, new Node.FunctionExpression(id, params, body, isGenerator)); }; // https://tc39.github.io/ecma262/#sec-directive-prologues-and-the-use-strict-directive Parser.prototype.parseDirective = function () { var token = this.lookahead; var node = this.createNode(); var expr = this.parseExpression(); var directive = (expr.type === syntax_1.Syntax.Literal) ? this.getTokenRaw(token).slice(1, -1) : null; this.consumeSemicolon(); return this.finalize(node, directive ? new Node.Directive(expr, directive) : new Node.ExpressionStatement(expr)); }; Parser.prototype.parseDirectivePrologues = function () { var firstRestricted = null; var body = []; while (true) { var token = this.lookahead; if (token.type !== 8 /* StringLiteral */) { break; } var statement = this.parseDirective(); body.push(statement); var directive = statement.directive; if (typeof directive !== 'string') { break; } if (directive === 'use strict') { this.context.strict = true; if (firstRestricted) { this.tolerateUnexpectedToken(firstRestricted, messages_1.Messages.StrictOctalLiteral); } if (!this.context.allowStrictDirective) { this.tolerateUnexpectedToken(token, messages_1.Messages.IllegalLanguageModeDirective); } } else { if (!firstRestricted && token.octal) { firstRestricted = token; } } } return body; }; // https://tc39.github.io/ecma262/#sec-method-definitions Parser.prototype.qualifiedPropertyName = function (token) { switch (token.type) { case 3 /* Identifier */: case 8 /* StringLiteral */: case 1 /* BooleanLiteral */: case 5 /* NullLiteral */: case 6 /* NumericLiteral */: case 4 /* Keyword */: return true; case 7 /* Punctuator */: return token.value === '['; default: break; } return false; }; Parser.prototype.parseGetterMethod = function () { var node = this.createNode(); var isGenerator = false; var previousAllowYield = this.context.allowYield; this.context.allowYield = !isGenerator; var formalParameters = this.parseFormalParameters(); if (formalParameters.params.length > 0) { this.tolerateError(messages_1.Messages.BadGetterArity); } var method = this.parsePropertyMethod(formalParameters); this.context.allowYield = previousAllowYield; return this.finalize(node, new Node.FunctionExpression(null, formalParameters.params, method, isGenerator)); }; Parser.prototype.parseSetterMethod = function () { var node = this.createNode(); var isGenerator = false; var previousAllowYield = this.context.allowYield; this.context.allowYield = !isGenerator; var formalParameters = this.parseFormalParameters(); if (formalParameters.params.length !== 1) { this.tolerateError(messages_1.Messages.BadSetterArity); } else if (formalParameters.params[0] instanceof Node.RestElement) { this.tolerateError(messages_1.Messages.BadSetterRestParameter); } var method = this.parsePropertyMethod(formalParameters); this.context.allowYield = previousAllowYield; return this.finalize(node, new Node.FunctionExpression(null, formalParameters.params, method, isGenerator)); }; Parser.prototype.parseGeneratorMethod = function () { var node = this.createNode(); var isGenerator = true; var previousAllowYield = this.context.allowYield; this.context.allowYield = true; var params = this.parseFormalParameters(); this.context.allowYield = false; var method = this.parsePropertyMethod(params); this.context.allowYield = previousAllowYield; return this.finalize(node, new Node.FunctionExpression(null, params.params, method, isGenerator)); }; // https://tc39.github.io/ecma262/#sec-generator-function-definitions Parser.prototype.isStartOfExpression = function () { var start = true; var value = this.lookahead.value; switch (this.lookahead.type) { case 7 /* Punctuator */: start = (value === '[') || (value === '(') || (value === '{') || (value === '+') || (value === '-') || (value === '!') || (value === '~') || (value === '++') || (value === '--') || (value === '/') || (value === '/='); // regular expression literal break; case 4 /* Keyword */: start = (value === 'class') || (value === 'delete') || (value === 'function') || (value === 'let') || (value === 'new') || (value === 'super') || (value === 'this') || (value === 'typeof') || (value === 'void') || (value === 'yield'); break; default: break; } return start; }; Parser.prototype.parseYieldExpression = function () { var node = this.createNode(); this.expectKeyword('yield'); var argument = null; var delegate = false; if (!this.hasLineTerminator) { var previousAllowYield = this.context.allowYield; this.context.allowYield = false; delegate = this.match('*'); if (delegate) { this.nextToken(); argument = this.parseAssignmentExpression(); } else if (this.isStartOfExpression()) { argument = this.parseAssignmentExpression(); } this.context.allowYield = previousAllowYield; } return this.finalize(node, new Node.YieldExpression(argument, delegate)); }; // https://tc39.github.io/ecma262/#sec-class-definitions Parser.prototype.parseClassElement = function (hasConstructor) { var token = this.lookahead; var node = this.createNode(); var kind = ''; var key = null; var value = null; var computed = false; var method = false; var isStatic = false; var isAsync = false; if (this.match('*')) { this.nextToken(); } else { computed = this.match('['); key = this.parseObjectPropertyKey(); var id = key; if (id.name === 'static' && (this.qualifiedPropertyName(this.lookahead) || this.match('*'))) { token = this.lookahead; isStatic = true; computed = this.match('['); if (this.match('*')) { this.nextToken(); } else { key = this.parseObjectPropertyKey(); } } if ((token.type === 3 /* Identifier */) && !this.hasLineTerminator && (token.value === 'async')) { var punctuator = this.lookahead.value; if (punctuator !== ':' && punctuator !== '(' && punctuator !== '*') { isAsync = true; token = this.lookahead; key = this.parseObjectPropertyKey(); if (token.type === 3 /* Identifier */ && token.value === 'constructor') { this.tolerateUnexpectedToken(token, messages_1.Messages.ConstructorIsAsync); } } } } var lookaheadPropertyKey = this.qualifiedPropertyName(this.lookahead); if (token.type === 3 /* Identifier */) { if (token.value === 'get' && lookaheadPropertyKey) { kind = 'get'; computed = this.match('['); key = this.parseObjectPropertyKey(); this.context.allowYield = false; value = this.parseGetterMethod(); } else if (token.value === 'set' && lookaheadPropertyKey) { kind = 'set'; computed = this.match('['); key = this.parseObjectPropertyKey(); value = this.parseSetterMethod(); } } else if (token.type === 7 /* Punctuator */ && token.value === '*' && lookaheadPropertyKey) { kind = 'init'; computed = this.match('['); key = this.parseObjectPropertyKey(); value = this.parseGeneratorMethod(); method = true; } if (!kind && key && this.match('(')) { kind = 'init'; value = isAsync ? this.parsePropertyMethodAsyncFunction() : this.parsePropertyMethodFunction(); method = true; } if (!kind) { this.throwUnexpectedToken(this.lookahead); } if (kind === 'init') { kind = 'method'; } if (!computed) { if (isStatic && this.isPropertyKey(key, 'prototype')) { this.throwUnexpectedToken(token, messages_1.Messages.StaticPrototype); } if (!isStatic && this.isPropertyKey(key, 'constructor')) { if (kind !== 'method' || !method || (value && value.generator)) { this.throwUnexpectedToken(token, messages_1.Messages.ConstructorSpecialMethod); } if (hasConstructor.value) { this.throwUnexpectedToken(token, messages_1.Messages.DuplicateConstructor); } else { hasConstructor.value = true; } kind = 'constructor'; } } return this.finalize(node, new Node.MethodDefinition(key, computed, value, kind, isStatic)); }; Parser.prototype.parseClassElementList = function () { var body = []; var hasConstructor = { value: false }; this.expect('{'); while (!this.match('}')) { if (this.match(';')) { this.nextToken(); } else { body.push(this.parseClassElement(hasConstructor)); } } this.expect('}'); return body; }; Parser.prototype.parseClassBody = function () { var node = this.createNode(); var elementList = this.parseClassElementList(); return this.finalize(node, new Node.ClassBody(elementList)); }; Parser.prototype.parseClassDeclaration = function (identifierIsOptional) { var node = this.createNode(); var previousStrict = this.context.strict; this.context.strict = true; this.expectKeyword('class'); var id = (identifierIsOptional && (this.lookahead.type !== 3 /* Identifier */)) ? null : this.parseVariableIdentifier(); var superClass = null; if (this.matchKeyword('extends')) { this.nextToken(); superClass = this.isolateCoverGrammar(this.parseLeftHandSideExpressionAllowCall); } var classBody = this.parseClassBody(); this.context.strict = previousStrict; return this.finalize(node, new Node.ClassDeclaration(id, superClass, classBody)); }; Parser.prototype.parseClassExpression = function () { var node = this.createNode(); var previousStrict = this.context.strict; this.context.strict = true; this.expectKeyword('class'); var id = (this.lookahead.type === 3 /* Identifier */) ? this.parseVariableIdentifier() : null; var superClass = null; if (this.matchKeyword('extends')) { this.nextToken(); superClass = this.isolateCoverGrammar(this.parseLeftHandSideExpressionAllowCall); } var classBody = this.parseClassBody(); this.context.strict = previousStrict; return this.finalize(node, new Node.ClassExpression(id, superClass, classBody)); }; // https://tc39.github.io/ecma262/#sec-scripts // https://tc39.github.io/ecma262/#sec-modules Parser.prototype.parseModule = function () { this.context.strict = true; this.context.isModule = true; this.scanner.isModule = true; var node = this.createNode(); var body = this.parseDirectivePrologues(); while (this.lookahead.type !== 2 /* EOF */) { body.push(this.parseStatementListItem()); } return this.finalize(node, new Node.Module(body)); }; Parser.prototype.parseScript = function () { var node = this.createNode(); var body = this.parseDirectivePrologues(); while (this.lookahead.type !== 2 /* EOF */) { body.push(this.parseStatementListItem()); } return this.finalize(node, new Node.Script(body)); }; // https://tc39.github.io/ecma262/#sec-imports Parser.prototype.parseModuleSpecifier = function () { var node = this.createNode(); if (this.lookahead.type !== 8 /* StringLiteral */) { this.throwError(messages_1.Messages.InvalidModuleSpecifier); } var token = this.nextToken(); var raw = this.getTokenRaw(token); return this.finalize(node, new Node.Literal(token.value, raw)); }; // import {} ...; Parser.prototype.parseImportSpecifier = function () { var node = this.createNode(); var imported; var local; if (this.lookahead.type === 3 /* Identifier */) { imported = this.parseVariableIdentifier(); local = imported; if (this.matchContextualKeyword('as')) { this.nextToken(); local = this.parseVariableIdentifier(); } } else { imported = this.parseIdentifierName(); local = imported; if (this.matchContextualKeyword('as')) { this.nextToken(); local = this.parseVariableIdentifier(); } else { this.throwUnexpectedToken(this.nextToken()); } } return this.finalize(node, new Node.ImportSpecifier(local, imported)); }; // {foo, bar as bas} Parser.prototype.parseNamedImports = function () { this.expect('{'); var specifiers = []; while (!this.match('}')) { specifiers.push(this.parseImportSpecifier()); if (!this.match('}')) { this.expect(','); } } this.expect('}'); return specifiers; }; // import ...; Parser.prototype.parseImportDefaultSpecifier = function () { var node = this.createNode(); var local = this.parseIdentifierName(); return this.finalize(node, new Node.ImportDefaultSpecifier(local)); }; // import <* as foo> ...; Parser.prototype.parseImportNamespaceSpecifier = function () { var node = this.createNode(); this.expect('*'); if (!this.matchContextualKeyword('as')) { this.throwError(messages_1.Messages.NoAsAfterImportNamespace); } this.nextToken(); var local = this.parseIdentifierName(); return this.finalize(node, new Node.ImportNamespaceSpecifier(local)); }; Parser.prototype.parseImportDeclaration = function () { if (this.context.inFunctionBody) { this.throwError(messages_1.Messages.IllegalImportDeclaration); } var node = this.createNode(); this.expectKeyword('import'); var src; var specifiers = []; if (this.lookahead.type === 8 /* StringLiteral */) { // import 'foo'; src = this.parseModuleSpecifier(); } else { if (this.match('{')) { // import {bar} specifiers = specifiers.concat(this.parseNamedImports()); } else if (this.match('*')) { // import * as foo specifiers.push(this.parseImportNamespaceSpecifier()); } else if (this.isIdentifierName(this.lookahead) && !this.matchKeyword('default')) { // import foo specifiers.push(this.parseImportDefaultSpecifier()); if (this.match(',')) { this.nextToken(); if (this.match('*')) { // import foo, * as foo specifiers.push(this.parseImportNamespaceSpecifier()); } else if (this.match('{')) { // import foo, {bar} specifiers = specifiers.concat(this.parseNamedImports()); } else { this.throwUnexpectedToken(this.lookahead); } } } else { this.throwUnexpectedToken(this.nextToken()); } if (!this.matchContextualKeyword('from')) { var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause; this.throwError(message, this.lookahead.value); } this.nextToken(); src = this.parseModuleSpecifier(); } this.consumeSemicolon(); return this.finalize(node, new Node.ImportDeclaration(specifiers, src)); }; // https://tc39.github.io/ecma262/#sec-exports Parser.prototype.parseExportSpecifier = function () { var node = this.createNode(); var local = this.parseIdentifierName(); var exported = local; if (this.matchContextualKeyword('as')) { this.nextToken(); exported = this.parseIdentifierName(); } return this.finalize(node, new Node.ExportSpecifier(local, exported)); }; Parser.prototype.parseExportDeclaration = function () { if (this.context.inFunctionBody) { this.throwError(messages_1.Messages.IllegalExportDeclaration); } var node = this.createNode(); this.expectKeyword('export'); var exportDeclaration; if (this.matchKeyword('default')) { // export default ... this.nextToken(); if (this.matchKeyword('function')) { // export default function foo () {} // export default function () {} var declaration = this.parseFunctionDeclaration(true); exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration)); } else if (this.matchKeyword('class')) { // export default class foo {} var declaration = this.parseClassDeclaration(true); exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration)); } else if (this.matchContextualKeyword('async')) { // export default async function f () {} // export default async function () {} // export default async x => x var declaration = this.matchAsyncFunction() ? this.parseFunctionDeclaration(true) : this.parseAssignmentExpression(); exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration)); } else { if (this.matchContextualKeyword('from')) { this.throwError(messages_1.Messages.UnexpectedToken, this.lookahead.value); } // export default {}; // export default []; // export default (1 + 2); var declaration = this.match('{') ? this.parseObjectInitializer() : this.match('[') ? this.parseArrayInitializer() : this.parseAssignmentExpression(); this.consumeSemicolon(); exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration)); } } else if (this.match('*')) { // export * from 'foo'; this.nextToken(); if (!this.matchContextualKeyword('from')) { var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause; this.throwError(message, this.lookahead.value); } this.nextToken(); var src = this.parseModuleSpecifier(); this.consumeSemicolon(); exportDeclaration = this.finalize(node, new Node.ExportAllDeclaration(src)); } else if (this.lookahead.type === 4 /* Keyword */) { // export var f = 1; var declaration = void 0; switch (this.lookahead.value) { case 'let': case 'const': declaration = this.parseLexicalDeclaration({ inFor: false }); break; case 'var': case 'class': case 'function': declaration = this.parseStatementListItem(); break; default: this.throwUnexpectedToken(this.lookahead); } exportDeclaration = this.finalize(node, new Node.ExportNamedDeclaration(declaration, [], null)); } else if (this.matchAsyncFunction()) { var declaration = this.parseFunctionDeclaration(); exportDeclaration = this.finalize(node, new Node.ExportNamedDeclaration(declaration, [], null)); } else { var specifiers = []; var source = null; var isExportFromIdentifier = false; this.expect('{'); while (!this.match('}')) { isExportFromIdentifier = isExportFromIdentifier || this.matchKeyword('default'); specifiers.push(this.parseExportSpecifier()); if (!this.match('}')) { this.expect(','); } } this.expect('}'); if (this.matchContextualKeyword('from')) { // export {default} from 'foo'; // export {foo} from 'foo'; this.nextToken(); source = this.parseModuleSpecifier(); this.consumeSemicolon(); } else if (isExportFromIdentifier) { // export {default}; // missing fromClause var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause; this.throwError(message, this.lookahead.value); } else { // export {foo}; this.consumeSemicolon(); } exportDeclaration = this.finalize(node, new Node.ExportNamedDeclaration(null, specifiers, source)); } return exportDeclaration; }; return Parser; }()); exports.Parser = Parser; /***/ }, /* 9 */ /***/ function(module, exports) { "use strict"; // Ensure the condition is true, otherwise throw an error. // This is only to have a better contract semantic, i.e. another safety net // to catch a logic error. The condition shall be fulfilled in normal case. // Do NOT use this to enforce a certain condition on any user input. Object.defineProperty(exports, "__esModule", { value: true }); function assert(condition, message) { /* istanbul ignore if */ if (!condition) { throw new Error('ASSERT: ' + message); } } exports.assert = assert; /***/ }, /* 10 */ /***/ function(module, exports) { "use strict"; /* tslint:disable:max-classes-per-file */ Object.defineProperty(exports, "__esModule", { value: true }); var ErrorHandler = (function () { function ErrorHandler() { this.errors = []; this.tolerant = false; } ErrorHandler.prototype.recordError = function (error) { this.errors.push(error); }; ErrorHandler.prototype.tolerate = function (error) { if (this.tolerant) { this.recordError(error); } else { throw error; } }; ErrorHandler.prototype.constructError = function (msg, column) { var error = new Error(msg); try { throw error; } catch (base) { /* istanbul ignore else */ if (Object.create && Object.defineProperty) { error = Object.create(base); Object.defineProperty(error, 'column', { value: column }); } } /* istanbul ignore next */ return error; }; ErrorHandler.prototype.createError = function (index, line, col, description) { var msg = 'Line ' + line + ': ' + description; var error = this.constructError(msg, col); error.index = index; error.lineNumber = line; error.description = description; return error; }; ErrorHandler.prototype.throwError = function (index, line, col, description) { throw this.createError(index, line, col, description); }; ErrorHandler.prototype.tolerateError = function (index, line, col, description) { var error = this.createError(index, line, col, description); if (this.tolerant) { this.recordError(error); } else { throw error; } }; return ErrorHandler; }()); exports.ErrorHandler = ErrorHandler; /***/ }, /* 11 */ /***/ function(module, exports) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); // Error messages should be identical to V8. exports.Messages = { BadGetterArity: 'Getter must not have any formal parameters', BadSetterArity: 'Setter must have exactly one formal parameter', BadSetterRestParameter: 'Setter function argument must not be a rest parameter', ConstructorIsAsync: 'Class constructor may not be an async method', ConstructorSpecialMethod: 'Class constructor may not be an accessor', DeclarationMissingInitializer: 'Missing initializer in %0 declaration', DefaultRestParameter: 'Unexpected token =', DuplicateBinding: 'Duplicate binding %0', DuplicateConstructor: 'A class may only have one constructor', DuplicateProtoProperty: 'Duplicate __proto__ fields are not allowed in object literals', ForInOfLoopInitializer: '%0 loop variable declaration may not have an initializer', GeneratorInLegacyContext: 'Generator declarations are not allowed in legacy contexts', IllegalBreak: 'Illegal break statement', IllegalContinue: 'Illegal continue statement', IllegalExportDeclaration: 'Unexpected token', IllegalImportDeclaration: 'Unexpected token', IllegalLanguageModeDirective: 'Illegal \'use strict\' directive in function with non-simple parameter list', IllegalReturn: 'Illegal return statement', InvalidEscapedReservedWord: 'Keyword must not contain escaped characters', InvalidHexEscapeSequence: 'Invalid hexadecimal escape sequence', InvalidLHSInAssignment: 'Invalid left-hand side in assignment', InvalidLHSInForIn: 'Invalid left-hand side in for-in', InvalidLHSInForLoop: 'Invalid left-hand side in for-loop', InvalidModuleSpecifier: 'Unexpected token', InvalidRegExp: 'Invalid regular expression', LetInLexicalBinding: 'let is disallowed as a lexically bound name', MissingFromClause: 'Unexpected token', MultipleDefaultsInSwitch: 'More than one default clause in switch statement', NewlineAfterThrow: 'Illegal newline after throw', NoAsAfterImportNamespace: 'Unexpected token', NoCatchOrFinally: 'Missing catch or finally after try', ParameterAfterRestParameter: 'Rest parameter must be last formal parameter', Redeclaration: '%0 \'%1\' has already been declared', StaticPrototype: 'Classes may not have static property named prototype', StrictCatchVariable: 'Catch variable may not be eval or arguments in strict mode', StrictDelete: 'Delete of an unqualified identifier in strict mode.', StrictFunction: 'In strict mode code, functions can only be declared at top level or inside a block', StrictFunctionName: 'Function name may not be eval or arguments in strict mode', StrictLHSAssignment: 'Assignment to eval or arguments is not allowed in strict mode', StrictLHSPostfix: 'Postfix increment/decrement may not have eval or arguments operand in strict mode', StrictLHSPrefix: 'Prefix increment/decrement may not have eval or arguments operand in strict mode', StrictModeWith: 'Strict mode code may not include a with statement', StrictOctalLiteral: 'Octal literals are not allowed in strict mode.', StrictParamDupe: 'Strict mode function may not have duplicate parameter names', StrictParamName: 'Parameter name eval or arguments is not allowed in strict mode', StrictReservedWord: 'Use of future reserved word in strict mode', StrictVarName: 'Variable name may not be eval or arguments in strict mode', TemplateOctalLiteral: 'Octal literals are not allowed in template strings.', UnexpectedEOS: 'Unexpected end of input', UnexpectedIdentifier: 'Unexpected identifier', UnexpectedNumber: 'Unexpected number', UnexpectedReserved: 'Unexpected reserved word', UnexpectedString: 'Unexpected string', UnexpectedTemplate: 'Unexpected quasi %0', UnexpectedToken: 'Unexpected token %0', UnexpectedTokenIllegal: 'Unexpected token ILLEGAL', UnknownLabel: 'Undefined label \'%0\'', UnterminatedRegExp: 'Invalid regular expression: missing /' }; /***/ }, /* 12 */ /***/ function(module, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); var assert_1 = __webpack_require__(9); var character_1 = __webpack_require__(4); var messages_1 = __webpack_require__(11); function hexValue(ch) { return '0123456789abcdef'.indexOf(ch.toLowerCase()); } function octalValue(ch) { return '01234567'.indexOf(ch); } var Scanner = (function () { function Scanner(code, handler) { this.source = code; this.errorHandler = handler; this.trackComment = false; this.isModule = false; this.length = code.length; this.index = 0; this.lineNumber = (code.length > 0) ? 1 : 0; this.lineStart = 0; this.curlyStack = []; } Scanner.prototype.saveState = function () { return { index: this.index, lineNumber: this.lineNumber, lineStart: this.lineStart }; }; Scanner.prototype.restoreState = function (state) { this.index = state.index; this.lineNumber = state.lineNumber; this.lineStart = state.lineStart; }; Scanner.prototype.eof = function () { return this.index >= this.length; }; Scanner.prototype.throwUnexpectedToken = function (message) { if (message === void 0) { message = messages_1.Messages.UnexpectedTokenIllegal; } return this.errorHandler.throwError(this.index, this.lineNumber, this.index - this.lineStart + 1, message); }; Scanner.prototype.tolerateUnexpectedToken = function (message) { if (message === void 0) { message = messages_1.Messages.UnexpectedTokenIllegal; } this.errorHandler.tolerateError(this.index, this.lineNumber, this.index - this.lineStart + 1, message); }; // https://tc39.github.io/ecma262/#sec-comments Scanner.prototype.skipSingleLineComment = function (offset) { var comments = []; var start, loc; if (this.trackComment) { comments = []; start = this.index - offset; loc = { start: { line: this.lineNumber, column: this.index - this.lineStart - offset }, end: {} }; } while (!this.eof()) { var ch = this.source.charCodeAt(this.index); ++this.index; if (character_1.Character.isLineTerminator(ch)) { if (this.trackComment) { loc.end = { line: this.lineNumber, column: this.index - this.lineStart - 1 }; var entry = { multiLine: false, slice: [start + offset, this.index - 1], range: [start, this.index - 1], loc: loc }; comments.push(entry); } if (ch === 13 && this.source.charCodeAt(this.index) === 10) { ++this.index; } ++this.lineNumber; this.lineStart = this.index; return comments; } } if (this.trackComment) { loc.end = { line: this.lineNumber, column: this.index - this.lineStart }; var entry = { multiLine: false, slice: [start + offset, this.index], range: [start, this.index], loc: loc }; comments.push(entry); } return comments; }; Scanner.prototype.skipMultiLineComment = function () { var comments = []; var start, loc; if (this.trackComment) { comments = []; start = this.index - 2; loc = { start: { line: this.lineNumber, column: this.index - this.lineStart - 2 }, end: {} }; } while (!this.eof()) { var ch = this.source.charCodeAt(this.index); if (character_1.Character.isLineTerminator(ch)) { if (ch === 0x0D && this.source.charCodeAt(this.index + 1) === 0x0A) { ++this.index; } ++this.lineNumber; ++this.index; this.lineStart = this.index; } else if (ch === 0x2A) { // Block comment ends with '*/'. if (this.source.charCodeAt(this.index + 1) === 0x2F) { this.index += 2; if (this.trackComment) { loc.end = { line: this.lineNumber, column: this.index - this.lineStart }; var entry = { multiLine: true, slice: [start + 2, this.index - 2], range: [start, this.index], loc: loc }; comments.push(entry); } return comments; } ++this.index; } else { ++this.index; } } // Ran off the end of the file - the whole thing is a comment if (this.trackComment) { loc.end = { line: this.lineNumber, column: this.index - this.lineStart }; var entry = { multiLine: true, slice: [start + 2, this.index], range: [start, this.index], loc: loc }; comments.push(entry); } this.tolerateUnexpectedToken(); return comments; }; Scanner.prototype.scanComments = function () { var comments; if (this.trackComment) { comments = []; } var start = (this.index === 0); while (!this.eof()) { var ch = this.source.charCodeAt(this.index); if (character_1.Character.isWhiteSpace(ch)) { ++this.index; } else if (character_1.Character.isLineTerminator(ch)) { ++this.index; if (ch === 0x0D && this.source.charCodeAt(this.index) === 0x0A) { ++this.index; } ++this.lineNumber; this.lineStart = this.index; start = true; } else if (ch === 0x2F) { ch = this.source.charCodeAt(this.index + 1); if (ch === 0x2F) { this.index += 2; var comment = this.skipSingleLineComment(2); if (this.trackComment) { comments = comments.concat(comment); } start = true; } else if (ch === 0x2A) { this.index += 2; var comment = this.skipMultiLineComment(); if (this.trackComment) { comments = comments.concat(comment); } } else { break; } } else if (start && ch === 0x2D) { // U+003E is '>' if ((this.source.charCodeAt(this.index + 1) === 0x2D) && (this.source.charCodeAt(this.index + 2) === 0x3E)) { // '-->' is a single-line comment this.index += 3; var comment = this.skipSingleLineComment(3); if (this.trackComment) { comments = comments.concat(comment); } } else { break; } } else if (ch === 0x3C && !this.isModule) { if (this.source.slice(this.index + 1, this.index + 4) === '!--') { this.index += 4; // ` {a:{y:1,b:{x:2}}} // use a filter to return the keys that have to be deleted. Object.keys(out).filter(function (k, _, __) { if (!out[k] || typeof out[k] !== 'object' || Array.isArray(out[k])) { return false } // see if the parent section is also an object. // if so, add it to that, and mark this one for deletion var parts = dotSplit(k) var p = out var l = parts.pop() var nl = l.replace(/\\\./g, '.') parts.forEach(function (part, _, __) { if (!p[part] || typeof p[part] !== 'object') p[part] = {} p = p[part] }) if (p === out && nl === l) { return false } p[nl] = out[k] return true }).forEach(function (del, _, __) { delete out[del] }) return out } function isQuoted (val) { return (val.charAt(0) === '"' && val.slice(-1) === '"') || (val.charAt(0) === "'" && val.slice(-1) === "'") } function safe (val) { return (typeof val !== 'string' || val.match(/[=\r\n]/) || val.match(/^\[/) || (val.length > 1 && isQuoted(val)) || val !== val.trim()) ? JSON.stringify(val) : val.replace(/;/g, '\\;').replace(/#/g, '\\#') } function unsafe (val, doUnesc) { val = (val || '').trim() if (isQuoted(val)) { // remove the single quotes before calling JSON.parse if (val.charAt(0) === "'") { val = val.substr(1, val.length - 2) } try { val = JSON.parse(val) } catch (_) {} } else { // walk the val to find the first not-escaped ; character var esc = false var unesc = '' for (var i = 0, l = val.length; i < l; i++) { var c = val.charAt(i) if (esc) { if ('\\;#'.indexOf(c) !== -1) { unesc += c } else { unesc += '\\' + c } esc = false } else if (';#'.indexOf(c) !== -1) { break } else if (c === '\\') { esc = true } else { unesc += c } } if (esc) { unesc += '\\' } return unesc.trim() } return val } /***/ }), /* 136 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var singleComment = 1; var multiComment = 2; function stripWithoutWhitespace() { return ''; } function stripWithWhitespace(str, start, end) { return str.slice(start, end).replace(/\S/g, ' '); } module.exports = function (str, opts) { opts = opts || {}; var currentChar; var nextChar; var insideString = false; var insideComment = false; var offset = 0; var ret = ''; var strip = opts.whitespace === false ? stripWithoutWhitespace : stripWithWhitespace; for (var i = 0; i < str.length; i++) { currentChar = str[i]; nextChar = str[i + 1]; if (!insideComment && currentChar === '"') { var escaped = str[i - 1] === '\\' && str[i - 2] !== '\\'; if (!escaped) { insideString = !insideString; } } if (insideString) { continue; } if (!insideComment && currentChar + nextChar === '//') { ret += str.slice(offset, i); offset = i; insideComment = singleComment; i++; } else if (insideComment === singleComment && currentChar + nextChar === '\r\n') { i++; insideComment = false; ret += strip(str, offset, i); offset = i; continue; } else if (insideComment === singleComment && currentChar === '\n') { insideComment = false; ret += strip(str, offset, i); offset = i; } else if (!insideComment && currentChar + nextChar === '/*') { ret += str.slice(offset, i); offset = i; insideComment = multiComment; i++; continue; } else if (insideComment === multiComment && currentChar + nextChar === '*/') { i++; insideComment = false; ret += strip(str, offset, i + 1); offset = i + 1; continue; } } return ret + (insideComment ? strip(str.substr(offset)) : str.substr(offset)); }; /***/ }), /* 137 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /*! * @description Recursive object extending * @author Viacheslav Lotsmanov * @license MIT * * The MIT License (MIT) * * Copyright (c) 2013-2018 Viacheslav Lotsmanov * * 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 isSpecificValue(val) { return ( val instanceof Buffer || val instanceof Date || val instanceof RegExp ) ? true : false; } function cloneSpecificValue(val) { if (val instanceof Buffer) { var x = Buffer.alloc ? Buffer.alloc(val.length) : new Buffer(val.length); val.copy(x); return x; } else if (val instanceof Date) { return new Date(val.getTime()); } else if (val instanceof RegExp) { return new RegExp(val); } else { throw new Error('Unexpected situation'); } } /** * Recursive cloning array. */ function deepCloneArray(arr) { var clone = []; arr.forEach(function (item, index) { if (typeof item === 'object' && item !== null) { if (Array.isArray(item)) { clone[index] = deepCloneArray(item); } else if (isSpecificValue(item)) { clone[index] = cloneSpecificValue(item); } else { clone[index] = deepExtend({}, item); } } else { clone[index] = item; } }); return clone; } function safeGetProperty(object, property) { return property === '__proto__' ? undefined : object[property]; } /** * Extening object that entered in first argument. * * Returns extended object or false if have no target object or incorrect type. * * If you wish to clone source object (without modify it), just use empty new * object as first argument, like this: * deepExtend({}, yourObj_1, [yourObj_N]); */ var deepExtend = module.exports = function (/*obj_1, [obj_2], [obj_N]*/) { if (arguments.length < 1 || typeof arguments[0] !== 'object') { return false; } if (arguments.length < 2) { return arguments[0]; } var target = arguments[0]; // convert arguments to array and cut off target object var args = Array.prototype.slice.call(arguments, 1); var val, src, clone; args.forEach(function (obj) { // skip argument if isn't an object, is null, or is an array if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) { return; } Object.keys(obj).forEach(function (key) { src = safeGetProperty(target, key); // source value val = safeGetProperty(obj, key); // new value // recursion prevention if (val === target) { return; /** * if new value isn't object then just overwrite by new value * instead of extending. */ } else if (typeof val !== 'object' || val === null) { target[key] = val; return; // just clone arrays (and recursive clone objects inside) } else if (Array.isArray(val)) { target[key] = deepCloneArray(val); return; // custom cloning and overwrite for specific objects } else if (isSpecificValue(val)) { target[key] = cloneSpecificValue(val); return; // overwrite by new value if source isn't object or array } else if (typeof src !== 'object' || src === null || Array.isArray(src)) { target[key] = deepExtend({}, val); return; // source value and new value is objects both, extending... } else { target[key] = deepExtend(src, val); return; } }); }); return target; }; /***/ }), /* 138 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var osHomedir = __webpack_require__(139); var home = osHomedir(); module.exports = function (str) { if (typeof str !== 'string') { throw new TypeError('Expected a string'); } return home ? str.replace(/^~($|\/|\\)/, home + '$1') : str; }; /***/ }), /* 139 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var os = __webpack_require__(54); function homedir() { var env = process.env; var home = env.HOME; var user = env.LOGNAME || env.USER || env.LNAME || env.USERNAME; if (process.platform === 'win32') { return env.USERPROFILE || env.HOMEDRIVE + env.HOMEPATH || home || null; } if (process.platform === 'darwin') { return home || (user ? '/Users/' + user : null); } if (process.platform === 'linux') { return home || (process.getuid() === 0 ? '/root' : (user ? '/home/' + user : null)); } return home || null; } module.exports = typeof os.homedir === 'function' ? os.homedir : homedir; /***/ }), /* 140 */ /***/ (function(module, exports) { module.exports = function (s, vars) { return s.replace(/(\\*)(\$([_a-z0-9]+)|\${([_a-z0-9]+)})/ig, function (_, escape, varExpression, variable, bracedVariable) { if (!(escape.length % 2)) { return escape.substring(Math.ceil(escape.length / 2)) + (vars[variable || bracedVariable] || ''); } else { return escape.substring(1) + varExpression; } }); }; /***/ }), /* 141 */ /***/ (function(module, exports) { function webpackEmptyContext(req) { try { return require(req) } catch (e) { if (e.code !== 'MODULE_NOT_FOUND') throw e } var e = new Error("Cannot find module '" + req + "'"); e.code = 'MODULE_NOT_FOUND'; throw e; } webpackEmptyContext.keys = function() { return []; }; webpackEmptyContext.resolve = webpackEmptyContext; module.exports = webpackEmptyContext; webpackEmptyContext.id = 141; /***/ }), /* 142 */ /***/ (function(module, exports, __webpack_require__) { // // format - printf-like string formatting for JavaScript // github.com/samsonjs/format // @_sjs // // Copyright 2010 - 2013 Sami Samhuri // // MIT License // http://sjs.mit-license.org // ;(function() { //// Export the API var namespace; // CommonJS / Node module if (true) { namespace = module.exports = format; } // Browsers and other environments else {} namespace.format = format; namespace.vsprintf = vsprintf; if (typeof console !== 'undefined' && typeof console.log === 'function') { namespace.printf = printf; } function printf(/* ... */) { console.log(format.apply(null, arguments)); } function vsprintf(fmt, replacements) { return format.apply(null, [fmt].concat(replacements)); } function format(fmt) { var argIndex = 1 // skip initial format argument , args = [].slice.call(arguments) , i = 0 , n = fmt.length , result = '' , c , escaped = false , arg , tmp , leadingZero = false , precision , nextArg = function() { return args[argIndex++]; } , slurpNumber = function() { var digits = ''; while (/\d/.test(fmt[i])) { digits += fmt[i++]; c = fmt[i]; } return digits.length > 0 ? parseInt(digits) : null; } ; for (; i < n; ++i) { c = fmt[i]; if (escaped) { escaped = false; if (c == '.') { leadingZero = false; c = fmt[++i]; } else if (c == '0' && fmt[i + 1] == '.') { leadingZero = true; i += 2; c = fmt[i]; } else { leadingZero = true; } precision = slurpNumber(); switch (c) { case 'b': // number in binary result += parseInt(nextArg(), 10).toString(2); break; case 'c': // character arg = nextArg(); if (typeof arg === 'string' || arg instanceof String) result += arg; else result += String.fromCharCode(parseInt(arg, 10)); break; case 'd': // number in decimal result += parseInt(nextArg(), 10); break; case 'f': // floating point number tmp = String(parseFloat(nextArg()).toFixed(precision || 6)); result += leadingZero ? tmp : tmp.replace(/^0/, ''); break; case 'j': // JSON result += JSON.stringify(nextArg()); break; case 'o': // number in octal result += '0' + parseInt(nextArg(), 10).toString(8); break; case 's': // string result += nextArg(); break; case 'x': // lowercase hexadecimal result += '0x' + parseInt(nextArg(), 10).toString(16); break; case 'X': // uppercase hexadecimal result += '0x' + parseInt(nextArg(), 10).toString(16).toUpperCase(); break; default: result += c; break; } } else if (c === '%') { escaped = true; } else { result += c; } } return result; } }()); /***/ }), /* 143 */ /***/ (function(module, exports) { function webpackEmptyContext(req) { try { return require(req) } catch (e) { if (e.code !== 'MODULE_NOT_FOUND') throw e } var e = new Error("Cannot find module '" + req + "'"); e.code = 'MODULE_NOT_FOUND'; throw e; } webpackEmptyContext.keys = function() { return []; }; webpackEmptyContext.resolve = webpackEmptyContext; module.exports = webpackEmptyContext; webpackEmptyContext.id = 143; /***/ }), /* 144 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var Ignore = __webpack_require__(145); var find = __webpack_require__(147); module.exports = fileSystem; /* Find files from the file-system. */ function fileSystem(context, settings, next) { var input = context.files; var skip = settings.silentlyIgnore; var ignore = new Ignore({ cwd: settings.cwd, detectIgnore: settings.detectIgnore, ignoreName: settings.ignoreName, ignorePath: settings.ignorePath }); if (input.length === 0) { return next(); } find(input, { cwd: settings.cwd, extensions: settings.extensions, silentlyIgnore: skip, ignore: ignore }, found); function found(err, result) { var output = result.files; /* Sort alphabetically. Everything’s unique so we don’t care * about cases where left and right are equal. */ output.sort(function (left, right) { return left.path < right.path ? -1 : 1; }); /* Mark as given. This allows outputting files, * which can be pretty dangerous, so it’s “hidden”. */ output.forEach(function (file) { file.data.unifiedEngineGiven = true; }); context.files = output; /* If `out` wasn’t set, detect it based on * whether one file was given. */ if (settings.out === null || settings.out === undefined) { settings.out = result.oneFileMode; } next(err); } } /***/ }), /* 145 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var path = __webpack_require__(4); var gitignore = __webpack_require__(146); var FindUp = __webpack_require__(57); module.exports = Ignore; Ignore.prototype.check = check; var dirname = path.dirname; var relative = path.relative; var resolve = path.resolve; function Ignore(options) { this.cwd = options.cwd; this.findUp = new FindUp({ filePath: options.ignorePath, cwd: options.cwd, detect: options.detectIgnore, names: options.ignoreName ? [options.ignoreName] : [], create: create }); } function check(filePath, callback) { var self = this; self.findUp.load(filePath, done); function done(err, ignore) { var normal; if (err) { callback(err); } else if (ignore) { normal = relative(ignore.filePath, resolve(self.cwd, filePath)); callback(null, normal ? ignore.ignores(normal) : false); } else { callback(null, false); } } } function create(buf, filePath) { var ignore = gitignore().add(String(buf)); ignore.filePath = dirname(filePath); return ignore; } /***/ }), /* 146 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var _createClass = 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; }; }(); function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } module.exports = function () { return new IgnoreBase(); }; // A simple implementation of make-array function make_array(subject) { return Array.isArray(subject) ? subject : [subject]; } var REGEX_BLANK_LINE = /^\s+$/; var REGEX_LEADING_EXCAPED_EXCLAMATION = /^\\\!/; var REGEX_LEADING_EXCAPED_HASH = /^\\#/; var SLASH = '/'; var KEY_IGNORE = typeof Symbol !== 'undefined' ? Symbol.for('node-ignore') /* istanbul ignore next */ : 'node-ignore'; var IgnoreBase = function () { function IgnoreBase() { _classCallCheck(this, IgnoreBase); this._rules = []; this[KEY_IGNORE] = true; this._initCache(); } _createClass(IgnoreBase, [{ key: '_initCache', value: function _initCache() { this._cache = {}; } // @param {Array.|string|Ignore} pattern }, { key: 'add', value: function add(pattern) { this._added = false; if (typeof pattern === 'string') { pattern = pattern.split(/\r?\n/g); } make_array(pattern).forEach(this._addPattern, this); // Some rules have just added to the ignore, // making the behavior changed. if (this._added) { this._initCache(); } return this; } // legacy }, { key: 'addPattern', value: function addPattern(pattern) { return this.add(pattern); } }, { key: '_addPattern', value: function _addPattern(pattern) { // #32 if (pattern && pattern[KEY_IGNORE]) { this._rules = this._rules.concat(pattern._rules); this._added = true; return; } if (this._checkPattern(pattern)) { var rule = this._createRule(pattern); this._added = true; this._rules.push(rule); } } }, { key: '_checkPattern', value: function _checkPattern(pattern) { // > A blank line matches no files, so it can serve as a separator for readability. return pattern && typeof pattern === 'string' && !REGEX_BLANK_LINE.test(pattern) // > A line starting with # serves as a comment. && pattern.indexOf('#') !== 0; } }, { key: 'filter', value: function filter(paths) { var _this = this; return make_array(paths).filter(function (path) { return _this._filter(path); }); } }, { key: 'createFilter', value: function createFilter() { var _this2 = this; return function (path) { return _this2._filter(path); }; } }, { key: 'ignores', value: function ignores(path) { return !this._filter(path); } }, { key: '_createRule', value: function _createRule(pattern) { var origin = pattern; var negative = false; // > An optional prefix "!" which negates the pattern; if (pattern.indexOf('!') === 0) { negative = true; pattern = pattern.substr(1); } pattern = pattern // > Put a backslash ("\") in front of the first "!" for patterns that begin with a literal "!", for example, `"\!important!.txt"`. .replace(REGEX_LEADING_EXCAPED_EXCLAMATION, '!') // > Put a backslash ("\") in front of the first hash for patterns that begin with a hash. .replace(REGEX_LEADING_EXCAPED_HASH, '#'); var regex = make_regex(pattern, negative); return { origin: origin, pattern: pattern, negative: negative, regex: regex }; } // @returns `Boolean` true if the `path` is NOT ignored }, { key: '_filter', value: function _filter(path, slices) { if (!path) { return false; } if (path in this._cache) { return this._cache[path]; } if (!slices) { // path/to/a.js // ['path', 'to', 'a.js'] slices = path.split(SLASH); } slices.pop(); return this._cache[path] = slices.length // > It is not possible to re-include a file if a parent directory of that file is excluded. // If the path contains a parent directory, check the parent first ? this._filter(slices.join(SLASH) + SLASH, slices) && this._test(path) // Or only test the path : this._test(path); } // @returns {Boolean} true if a file is NOT ignored }, { key: '_test', value: function _test(path) { // Explicitly define variable type by setting matched to `0` var matched = 0; this._rules.forEach(function (rule) { // if matched = true, then we only test negative rules // if matched = false, then we test non-negative rules if (!(matched ^ rule.negative)) { matched = rule.negative ^ rule.regex.test(path); } }); return !matched; } }]); return IgnoreBase; }(); // > If the pattern ends with a slash, // > it is removed for the purpose of the following description, // > but it would only find a match with a directory. // > In other words, foo/ will match a directory foo and paths underneath it, // > but will not match a regular file or a symbolic link foo // > (this is consistent with the way how pathspec works in general in Git). // '`foo/`' will not match regular file '`foo`' or symbolic link '`foo`' // -> ignore-rules will not deal with it, because it costs extra `fs.stat` call // you could use option `mark: true` with `glob` // '`foo/`' should not continue with the '`..`' var DEFAULT_REPLACER_PREFIX = [ // > Trailing spaces are ignored unless they are quoted with backslash ("\") [ // (a\ ) -> (a ) // (a ) -> (a) // (a \ ) -> (a ) /\\?\s+$/, function (match) { return match.indexOf('\\') === 0 ? ' ' : ''; }], // replace (\ ) with ' ' [/\\\s/g, function () { return ' '; }], // Escape metacharacters // which is written down by users but means special for regular expressions. // > There are 12 characters with special meanings: // > - the backslash \, // > - the caret ^, // > - the dollar sign $, // > - the period or dot ., // > - the vertical bar or pipe symbol |, // > - the question mark ?, // > - the asterisk or star *, // > - the plus sign +, // > - the opening parenthesis (, // > - the closing parenthesis ), // > - and the opening square bracket [, // > - the opening curly brace {, // > These special characters are often called "metacharacters". [/[\\\^$.|?*+()\[{]/g, function (match) { return '\\' + match; }], // leading slash [ // > A leading slash matches the beginning of the pathname. // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c". // A leading slash matches the beginning of the pathname /^\//, function () { return '^'; }], // replace special metacharacter slash after the leading slash [/\//g, function () { return '\\/'; }], [ // > A leading "**" followed by a slash means match in all directories. // > For example, "**/foo" matches file or directory "foo" anywhere, // > the same as pattern "foo". // > "**/foo/bar" matches file or directory "bar" anywhere that is directly under directory "foo". // Notice that the '*'s have been replaced as '\\*' /^\^*\\\*\\\*\\\//, // '**/foo' <-> 'foo' function () { return '^(?:.*\\/)?'; }]]; var DEFAULT_REPLACER_SUFFIX = [ // starting [ // there will be no leading '/' (which has been replaced by section "leading slash") // If starts with '**', adding a '^' to the regular expression also works /^(?=[^\^])/, function () { return !/\/(?!$)/.test(this) // > If the pattern does not contain a slash /, Git treats it as a shell glob pattern // Actually, if there is only a trailing slash, git also treats it as a shell glob pattern ? '(?:^|\\/)' // > Otherwise, Git treats the pattern as a shell glob suitable for consumption by fnmatch(3) : '^'; }], // two globstars [ // Use lookahead assertions so that we could match more than one `'/**'` /\\\/\\\*\\\*(?=\\\/|$)/g, // Zero, one or several directories // should not use '*', or it will be replaced by the next replacer // Check if it is not the last `'/**'` function (match, index, str) { return index + 6 < str.length // case: /**/ // > A slash followed by two consecutive asterisks then a slash matches zero or more directories. // > For example, "a/**/b" matches "a/b", "a/x/b", "a/x/y/b" and so on. // '/**/' ? '(?:\\/[^\\/]+)*' // case: /** // > A trailing `"/**"` matches everything inside. // #21: everything inside but it should not include the current folder : '\\/.+'; }], // intermediate wildcards [ // Never replace escaped '*' // ignore rule '\*' will match the path '*' // 'abc.*/' -> go // 'abc.*' -> skip this rule /(^|[^\\]+)\\\*(?=.+)/g, // '*.js' matches '.js' // '*.js' doesn't match 'abc' function (match, p1) { return p1 + '[^\\/]*'; }], // trailing wildcard [/(\^|\\\/)?\\\*$/, function (match, p1) { return (p1 // '\^': // '/*' does not match '' // '/*' does not match everything // '\\\/': // 'abc/*' does not match 'abc/' ? p1 + '[^/]+' // 'a*' matches 'a' // 'a*' matches 'aa' : '[^/]*') + '(?=$|\\/$)'; }], [ // unescape /\\\\\\/g, function () { return '\\'; }]]; var POSITIVE_REPLACERS = [].concat(DEFAULT_REPLACER_PREFIX, [ // 'f' // matches // - /f(end) // - /f/ // - (start)f(end) // - (start)f/ // doesn't match // - oof // - foo // pseudo: // -> (^|/)f(/|$) // ending [ // 'js' will not match 'js.' // 'ab' will not match 'abc' /(?:[^*\/])$/, // 'js*' will not match 'a.js' // 'js/' will not match 'a.js' // 'js' will match 'a.js' and 'a.js/' function (match) { return match + '(?=$|\\/)'; }]], DEFAULT_REPLACER_SUFFIX); var NEGATIVE_REPLACERS = [].concat(DEFAULT_REPLACER_PREFIX, [ // #24, #38 // The MISSING rule of [gitignore docs](https://git-scm.com/docs/gitignore) // A negative pattern without a trailing wildcard should not // re-include the things inside that directory. // eg: // ['node_modules/*', '!node_modules'] // should ignore `node_modules/a.js` [/(?:[^*])$/, function (match) { return match + '(?=$|\\/$)'; }]], DEFAULT_REPLACER_SUFFIX); // A simple cache, because an ignore rule only has only one certain meaning var cache = {}; // @param {pattern} function make_regex(pattern, negative) { var r = cache[pattern]; if (r) { return r; } var replacers = negative ? NEGATIVE_REPLACERS : POSITIVE_REPLACERS; var source = replacers.reduce(function (prev, current) { return prev.replace(current[0], current[1].bind(pattern)); }, pattern); return cache[pattern] = new RegExp(source, 'i'); } // Windows // -------------------------------------------------------------- /* istanbul ignore if */ if ( // Detect `process` so that it can run in browsers. typeof process !== 'undefined' && (process.env && process.env.IGNORE_TEST_WIN32 || process.platform === 'win32')) { var filter = IgnoreBase.prototype._filter; var make_posix = function make_posix(str) { return (/^\\\\\?\\/.test(str) || /[^\x00-\x80]+/.test(str) ? str : str.replace(/\\/g, '/') ); }; IgnoreBase.prototype._filter = function (path, slices) { path = make_posix(path); return filter.call(this, path, slices); }; } /***/ }), /* 147 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var path = __webpack_require__(4); var fs = __webpack_require__(6); var glob = __webpack_require__(58); var vfile = __webpack_require__(39); var xtend = __webpack_require__(7); var hidden = __webpack_require__(159); var string = __webpack_require__(17); var readdir = fs.readdir; var stat = fs.stat; var join = path.join; var relative = path.relative; var resolve = path.resolve; var basename = path.basename; var extname = path.extname; var magic = glob.hasMagic; module.exports = find; /* Search `patterns`, a mix of globs, paths, and files. */ function find(input, options, callback) { expand(input, options, done); function done(err, result) { /* istanbul ignore if - glob errors are unusual. * other errors are on the vfile results. */ if (err) { callback(err); } else { callback(null, {oneFileMode: oneFileMode(result), files: result.output}); } } } /* Expand the given glob patterns, search given and found * directories, and map to vfiles. */ function expand(input, options, next) { var cwd = options.cwd; var paths = []; var actual = 0; var expected = 0; var failed; input.forEach(each); if (!expected) { search(paths, options, done); } function each(file) { if (string(file)) { if (magic(file)) { expected++; glob(file, {cwd: cwd}, one); } else { /* `relative` to make the paths canonical. */ file = relative(cwd, resolve(cwd, file)) || '.'; paths.push(file); } } else { file.cwd = cwd; file.path = relative(cwd, file.path); file.history = [file.path]; paths.push(file); } } function one(err, files) { /* istanbul ignore if - glob errors are unusual. */ if (failed) { return; } /* istanbul ignore if - glob errors are unusual. */ if (err) { failed = true; done(err); } else { actual++; paths = paths.concat(files); if (actual === expected) { search(paths, options, done); } } } function done(err, files) { /* istanbul ignore if - `search` currently does not give errors. */ if (err) { next(err); } else { next(null, {input: paths, output: files}); } } } /* Search `paths`. */ function search(input, options, next) { var cwd = options.cwd; var silent = options.silentlyIgnore; var nested = options.nested; var extensions = options.extensions; var files = []; var expected = 0; var actual = 0; input.forEach(each); if (!expected) { next(null, files); } return each; function each(file) { var part = base(file); if (nested && (hidden(part) || part === 'node_modules')) { return; } expected++; statAndIgnore(file, options, handle); function handle(err, result) { var ignored = result && result.ignored; var dir = result && result.stats && result.stats.isDirectory(); if (ignored && (nested || silent)) { return one(null, []); } if (!ignored && dir) { return readdir(resolve(cwd, filePath(file)), directory); } if (nested && !dir && extensions.length !== 0 && extensions.indexOf(extname(file)) === -1) { return one(null, []); } file = vfile(file); file.cwd = cwd; if (ignored) { try { file.fail('Cannot process specified file: it’s ignored'); } catch (err) {} } if (err && err.code === 'ENOENT') { try { file.fail(err.syscall === 'stat' ? 'No such file or directory' : err); } catch (err) {} } one(null, [file]); } function directory(err, basenames) { var file; /* istanbul ignore if - Should not happen often: the directory * is `stat`ed first, which was ok, but reading it is not. */ if (err) { file = vfile(filePath(file)); file.cwd = cwd; try { file.fail('Cannot read directory'); } catch (err) {} one(null, [file]); } else { search(basenames.map(concat), xtend(options, {nested: true}), one); } } /* Error is never given. Always given `results`. */ function one(_, results) { /* istanbul ignore else - always given. */ if (results) { files = files.concat(results); } actual++; if (actual === expected) { next(null, files); } } function concat(value) { return join(filePath(file), value); } } } function statAndIgnore(file, options, callback) { var ignore = options.ignore; var fp = resolve(options.cwd, filePath(file)); var expected = 1; var actual = 0; var stats; var ignored; if (!file.contents) { expected++; stat(fp, handleStat); } ignore.check(fp, handleIgnore); function handleStat(err, value) { stats = value; one(err); } function handleIgnore(err, value) { ignored = value; one(err); } function one(err) { actual++; if (err) { callback(err); actual = -1; } else if (actual === expected) { callback(null, {stats: stats, ignored: ignored}); } } } function base(file) { return string(file) ? basename(file) : file.basename; } function filePath(file) { return string(file) ? file : file.path; } function oneFileMode(result) { return result.output.length === 1 && result.input.length === 1 && result.output[0].path === result.input[0]; } /***/ }), /* 148 */ /***/ (function(module, exports, __webpack_require__) { // 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. var pathModule = __webpack_require__(4); var isWindows = process.platform === 'win32'; var fs = __webpack_require__(6); // JavaScript implementation of realpath, ported from node pre-v6 var DEBUG = process.env.NODE_DEBUG && /fs/.test(process.env.NODE_DEBUG); function rethrow() { // Only enable in debug mode. A backtrace uses ~1000 bytes of heap space and // is fairly slow to generate. var callback; if (DEBUG) { var backtrace = new Error; callback = debugCallback; } else callback = missingCallback; return callback; function debugCallback(err) { if (err) { backtrace.message = err.message; err = backtrace; missingCallback(err); } } function missingCallback(err) { if (err) { if (process.throwDeprecation) throw err; // Forgot a callback but don't know where? Use NODE_DEBUG=fs else if (!process.noDeprecation) { var msg = 'fs: missing callback ' + (err.stack || err.message); if (process.traceDeprecation) console.trace(msg); else console.error(msg); } } } } function maybeCallback(cb) { return typeof cb === 'function' ? cb : rethrow(); } var normalize = pathModule.normalize; // Regexp that finds the next partion of a (partial) path // result is [base_with_slash, base], e.g. ['somedir/', 'somedir'] if (isWindows) { var nextPartRe = /(.*?)(?:[\/\\]+|$)/g; } else { var nextPartRe = /(.*?)(?:[\/]+|$)/g; } // Regex to find the device root, including trailing slash. E.g. 'c:\\'. if (isWindows) { var splitRootRe = /^(?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/][^\\\/]+)?[\\\/]*/; } else { var splitRootRe = /^[\/]*/; } exports.realpathSync = function realpathSync(p, cache) { // make p is absolute p = pathModule.resolve(p); if (cache && Object.prototype.hasOwnProperty.call(cache, p)) { return cache[p]; } var original = p, seenLinks = {}, knownHard = {}; // current character position in p var pos; // the partial path so far, including a trailing slash if any var current; // the partial path without a trailing slash (except when pointing at a root) var base; // the partial path scanned in the previous round, with slash var previous; start(); function start() { // Skip over roots var m = splitRootRe.exec(p); pos = m[0].length; current = m[0]; base = m[0]; previous = ''; // On windows, check that the root exists. On unix there is no need. if (isWindows && !knownHard[base]) { fs.lstatSync(base); knownHard[base] = true; } } // walk down the path, swapping out linked pathparts for their real // values // NB: p.length changes. while (pos < p.length) { // find the next part nextPartRe.lastIndex = pos; var result = nextPartRe.exec(p); previous = current; current += result[0]; base = previous + result[1]; pos = nextPartRe.lastIndex; // continue if not a symlink if (knownHard[base] || (cache && cache[base] === base)) { continue; } var resolvedLink; if (cache && Object.prototype.hasOwnProperty.call(cache, base)) { // some known symbolic link. no need to stat again. resolvedLink = cache[base]; } else { var stat = fs.lstatSync(base); if (!stat.isSymbolicLink()) { knownHard[base] = true; if (cache) cache[base] = base; continue; } // read the link if it wasn't read before // dev/ino always return 0 on windows, so skip the check. var linkTarget = null; if (!isWindows) { var id = stat.dev.toString(32) + ':' + stat.ino.toString(32); if (seenLinks.hasOwnProperty(id)) { linkTarget = seenLinks[id]; } } if (linkTarget === null) { fs.statSync(base); linkTarget = fs.readlinkSync(base); } resolvedLink = pathModule.resolve(previous, linkTarget); // track this, if given a cache. if (cache) cache[base] = resolvedLink; if (!isWindows) seenLinks[id] = linkTarget; } // resolve the link, then start over p = pathModule.resolve(resolvedLink, p.slice(pos)); start(); } if (cache) cache[original] = p; return p; }; exports.realpath = function realpath(p, cache, cb) { if (typeof cb !== 'function') { cb = maybeCallback(cache); cache = null; } // make p is absolute p = pathModule.resolve(p); if (cache && Object.prototype.hasOwnProperty.call(cache, p)) { return process.nextTick(cb.bind(null, null, cache[p])); } var original = p, seenLinks = {}, knownHard = {}; // current character position in p var pos; // the partial path so far, including a trailing slash if any var current; // the partial path without a trailing slash (except when pointing at a root) var base; // the partial path scanned in the previous round, with slash var previous; start(); function start() { // Skip over roots var m = splitRootRe.exec(p); pos = m[0].length; current = m[0]; base = m[0]; previous = ''; // On windows, check that the root exists. On unix there is no need. if (isWindows && !knownHard[base]) { fs.lstat(base, function(err) { if (err) return cb(err); knownHard[base] = true; LOOP(); }); } else { process.nextTick(LOOP); } } // walk down the path, swapping out linked pathparts for their real // values function LOOP() { // stop if scanned past end of path if (pos >= p.length) { if (cache) cache[original] = p; return cb(null, p); } // find the next part nextPartRe.lastIndex = pos; var result = nextPartRe.exec(p); previous = current; current += result[0]; base = previous + result[1]; pos = nextPartRe.lastIndex; // continue if not a symlink if (knownHard[base] || (cache && cache[base] === base)) { return process.nextTick(LOOP); } if (cache && Object.prototype.hasOwnProperty.call(cache, base)) { // known symbolic link. no need to stat again. return gotResolvedLink(cache[base]); } return fs.lstat(base, gotStat); } function gotStat(err, stat) { if (err) return cb(err); // if not a symlink, skip to the next path part if (!stat.isSymbolicLink()) { knownHard[base] = true; if (cache) cache[base] = base; return process.nextTick(LOOP); } // stat & read the link if not read before // call gotTarget as soon as the link target is known // dev/ino always return 0 on windows, so skip the check. if (!isWindows) { var id = stat.dev.toString(32) + ':' + stat.ino.toString(32); if (seenLinks.hasOwnProperty(id)) { return gotTarget(null, seenLinks[id], base); } } fs.stat(base, function(err) { if (err) return cb(err); fs.readlink(base, function(err, target) { if (!isWindows) seenLinks[id] = target; gotTarget(err, target); }); }); } function gotTarget(err, target, base) { if (err) return cb(err); var resolvedLink = pathModule.resolve(previous, target); if (cache) cache[base] = resolvedLink; gotResolvedLink(resolvedLink); } function gotResolvedLink(resolvedLink) { // resolve the link, then start over p = pathModule.resolve(resolvedLink, p.slice(pos)); start(); } }; /***/ }), /* 149 */ /***/ (function(module, exports, __webpack_require__) { var concatMap = __webpack_require__(150); var balanced = __webpack_require__(151); module.exports = expandTop; var escSlash = '\0SLASH'+Math.random()+'\0'; var escOpen = '\0OPEN'+Math.random()+'\0'; var escClose = '\0CLOSE'+Math.random()+'\0'; var escComma = '\0COMMA'+Math.random()+'\0'; var escPeriod = '\0PERIOD'+Math.random()+'\0'; function numeric(str) { return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0); } function escapeBraces(str) { return str.split('\\\\').join(escSlash) .split('\\{').join(escOpen) .split('\\}').join(escClose) .split('\\,').join(escComma) .split('\\.').join(escPeriod); } function unescapeBraces(str) { return str.split(escSlash).join('\\') .split(escOpen).join('{') .split(escClose).join('}') .split(escComma).join(',') .split(escPeriod).join('.'); } // Basically just str.split(","), but handling cases // where we have nested braced sections, which should be // treated as individual members, like {a,{b,c},d} function parseCommaParts(str) { if (!str) return ['']; var parts = []; var m = balanced('{', '}', str); if (!m) return str.split(','); var pre = m.pre; var body = m.body; var post = m.post; var p = pre.split(','); p[p.length-1] += '{' + body + '}'; var postParts = parseCommaParts(post); if (post.length) { p[p.length-1] += postParts.shift(); p.push.apply(p, postParts); } parts.push.apply(parts, p); return parts; } function expandTop(str) { if (!str) return []; // I don't know why Bash 4.3 does this, but it does. // Anything starting with {} will have the first two bytes preserved // but *only* at the top level, so {},a}b will not expand to anything, // but a{},b}c will be expanded to [a}c,abc]. // One could argue that this is a bug in Bash, but since the goal of // this module is to match Bash's rules, we escape a leading {} if (str.substr(0, 2) === '{}') { str = '\\{\\}' + str.substr(2); } return expand(escapeBraces(str), true).map(unescapeBraces); } function identity(e) { return e; } function embrace(str) { return '{' + str + '}'; } function isPadded(el) { return /^-?0\d/.test(el); } function lte(i, y) { return i <= y; } function gte(i, y) { return i >= y; } function expand(str, isTop) { var expansions = []; var m = balanced('{', '}', str); if (!m || /\$$/.test(m.pre)) return [str]; var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body); var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body); var isSequence = isNumericSequence || isAlphaSequence; var isOptions = m.body.indexOf(',') >= 0; if (!isSequence && !isOptions) { // {a},b} if (m.post.match(/,.*\}/)) { str = m.pre + '{' + m.body + escClose + m.post; return expand(str); } return [str]; } var n; if (isSequence) { n = m.body.split(/\.\./); } else { n = parseCommaParts(m.body); if (n.length === 1) { // x{{a,b}}y ==> x{a}y x{b}y n = expand(n[0], false).map(embrace); if (n.length === 1) { var post = m.post.length ? expand(m.post, false) : ['']; return post.map(function(p) { return m.pre + n[0] + p; }); } } } // at this point, n is the parts, and we know it's not a comma set // with a single entry. // no need to expand pre, since it is guaranteed to be free of brace-sets var pre = m.pre; var post = m.post.length ? expand(m.post, false) : ['']; var N; if (isSequence) { var x = numeric(n[0]); var y = numeric(n[1]); var width = Math.max(n[0].length, n[1].length) var incr = n.length == 3 ? Math.abs(numeric(n[2])) : 1; var test = lte; var reverse = y < x; if (reverse) { incr *= -1; test = gte; } var pad = n.some(isPadded); N = []; for (var i = x; test(i, y); i += incr) { var c; if (isAlphaSequence) { c = String.fromCharCode(i); if (c === '\\') c = ''; } else { c = String(i); if (pad) { var need = width - c.length; if (need > 0) { var z = new Array(need + 1).join('0'); if (i < 0) c = '-' + z + c.slice(1); else c = z + c; } } } N.push(c); } } else { N = concatMap(n, function(el) { return expand(el, false) }); } for (var j = 0; j < N.length; j++) { for (var k = 0; k < post.length; k++) { var expansion = pre + N[j] + post[k]; if (!isTop || isSequence || expansion) expansions.push(expansion); } } return expansions; } /***/ }), /* 150 */ /***/ (function(module, exports) { module.exports = function (xs, fn) { var res = []; for (var i = 0; i < xs.length; i++) { var x = fn(xs[i], i); if (isArray(x)) res.push.apply(res, x); else res.push(x); } return res; }; var isArray = Array.isArray || function (xs) { return Object.prototype.toString.call(xs) === '[object Array]'; }; /***/ }), /* 151 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = balanced; function balanced(a, b, str) { if (a instanceof RegExp) a = maybeMatch(a, str); if (b instanceof RegExp) b = maybeMatch(b, str); var r = range(a, b, str); return r && { start: r[0], end: r[1], pre: str.slice(0, r[0]), body: str.slice(r[0] + a.length, r[1]), post: str.slice(r[1] + b.length) }; } function maybeMatch(reg, str) { var m = str.match(reg); return m ? m[0] : null; } balanced.range = range; function range(a, b, str) { var begs, beg, left, right, result; var ai = str.indexOf(a); var bi = str.indexOf(b, ai + 1); var i = ai; if (ai >= 0 && bi > 0) { begs = []; left = str.length; while (i >= 0 && !result) { if (i == ai) { begs.push(i); ai = str.indexOf(a, i + 1); } else if (begs.length == 1) { result = [ begs.pop(), bi ]; } else { beg = begs.pop(); if (beg < left) { left = beg; right = bi; } bi = str.indexOf(b, i + 1); } i = ai < bi && ai >= 0 ? ai : bi; } if (begs.length) { result = [ left, right ]; } } return result; } /***/ }), /* 152 */ /***/ (function(module, exports) { if (typeof Object.create === 'function') { // implementation from standard node.js 'util' module module.exports = function inherits(ctor, superCtor) { ctor.super_ = superCtor ctor.prototype = Object.create(superCtor.prototype, { constructor: { value: ctor, enumerable: false, writable: true, configurable: true } }); }; } else { // old school shim for old browsers module.exports = function inherits(ctor, superCtor) { ctor.super_ = superCtor var TempCtor = function () {} TempCtor.prototype = superCtor.prototype ctor.prototype = new TempCtor() ctor.prototype.constructor = ctor } } /***/ }), /* 153 */ /***/ (function(module, exports, __webpack_require__) { module.exports = globSync globSync.GlobSync = GlobSync var fs = __webpack_require__(6) var rp = __webpack_require__(59) var minimatch = __webpack_require__(36) var Minimatch = minimatch.Minimatch var Glob = __webpack_require__(58).Glob var util = __webpack_require__(11) var path = __webpack_require__(4) var assert = __webpack_require__(60) var isAbsolute = __webpack_require__(38) var common = __webpack_require__(61) var alphasort = common.alphasort var alphasorti = common.alphasorti var setopts = common.setopts var ownProp = common.ownProp var childrenIgnored = common.childrenIgnored var isIgnored = common.isIgnored function globSync (pattern, options) { if (typeof options === 'function' || arguments.length === 3) throw new TypeError('callback provided to sync glob\n'+ 'See: https://github.com/isaacs/node-glob/issues/167') return new GlobSync(pattern, options).found } function GlobSync (pattern, options) { if (!pattern) throw new Error('must provide pattern') if (typeof options === 'function' || arguments.length === 3) throw new TypeError('callback provided to sync glob\n'+ 'See: https://github.com/isaacs/node-glob/issues/167') if (!(this instanceof GlobSync)) return new GlobSync(pattern, options) setopts(this, pattern, options) if (this.noprocess) return this var n = this.minimatch.set.length this.matches = new Array(n) for (var i = 0; i < n; i ++) { this._process(this.minimatch.set[i], i, false) } this._finish() } GlobSync.prototype._finish = function () { assert(this instanceof GlobSync) if (this.realpath) { var self = this this.matches.forEach(function (matchset, index) { var set = self.matches[index] = Object.create(null) for (var p in matchset) { try { p = self._makeAbs(p) var real = rp.realpathSync(p, self.realpathCache) set[real] = true } catch (er) { if (er.syscall === 'stat') set[self._makeAbs(p)] = true else throw er } } }) } common.finish(this) } GlobSync.prototype._process = function (pattern, index, inGlobStar) { assert(this instanceof GlobSync) // Get the first [n] parts of pattern that are all strings. var n = 0 while (typeof pattern[n] === 'string') { n ++ } // now n is the index of the first one that is *not* a string. // See if there's anything else var prefix switch (n) { // if not, then this is rather simple case pattern.length: this._processSimple(pattern.join('/'), index) return case 0: // pattern *starts* with some non-trivial item. // going to readdir(cwd), but not include the prefix in matches. prefix = null break default: // pattern has some string bits in the front. // whatever it starts with, whether that's 'absolute' like /foo/bar, // or 'relative' like '../baz' prefix = pattern.slice(0, n).join('/') break } var remain = pattern.slice(n) // get the list of entries. var read if (prefix === null) read = '.' else if (isAbsolute(prefix) || isAbsolute(pattern.join('/'))) { if (!prefix || !isAbsolute(prefix)) prefix = '/' + prefix read = prefix } else read = prefix var abs = this._makeAbs(read) //if ignored, skip processing if (childrenIgnored(this, read)) return var isGlobStar = remain[0] === minimatch.GLOBSTAR if (isGlobStar) this._processGlobStar(prefix, read, abs, remain, index, inGlobStar) else this._processReaddir(prefix, read, abs, remain, index, inGlobStar) } GlobSync.prototype._processReaddir = function (prefix, read, abs, remain, index, inGlobStar) { var entries = this._readdir(abs, inGlobStar) // if the abs isn't a dir, then nothing can match! if (!entries) return // It will only match dot entries if it starts with a dot, or if // dot is set. Stuff like @(.foo|.bar) isn't allowed. var pn = remain[0] var negate = !!this.minimatch.negate var rawGlob = pn._glob var dotOk = this.dot || rawGlob.charAt(0) === '.' var matchedEntries = [] for (var i = 0; i < entries.length; i++) { var e = entries[i] if (e.charAt(0) !== '.' || dotOk) { var m if (negate && !prefix) { m = !e.match(pn) } else { m = e.match(pn) } if (m) matchedEntries.push(e) } } var len = matchedEntries.length // If there are no matched entries, then nothing matches. if (len === 0) return // if this is the last remaining pattern bit, then no need for // an additional stat *unless* the user has specified mark or // stat explicitly. We know they exist, since readdir returned // them. if (remain.length === 1 && !this.mark && !this.stat) { if (!this.matches[index]) this.matches[index] = Object.create(null) for (var i = 0; i < len; i ++) { var e = matchedEntries[i] if (prefix) { if (prefix.slice(-1) !== '/') e = prefix + '/' + e else e = prefix + e } if (e.charAt(0) === '/' && !this.nomount) { e = path.join(this.root, e) } this._emitMatch(index, e) } // This was the last one, and no stats were needed return } // now test all matched entries as stand-ins for that part // of the pattern. remain.shift() for (var i = 0; i < len; i ++) { var e = matchedEntries[i] var newPattern if (prefix) newPattern = [prefix, e] else newPattern = [e] this._process(newPattern.concat(remain), index, inGlobStar) } } GlobSync.prototype._emitMatch = function (index, e) { if (isIgnored(this, e)) return var abs = this._makeAbs(e) if (this.mark) e = this._mark(e) if (this.absolute) { e = abs } if (this.matches[index][e]) return if (this.nodir) { var c = this.cache[abs] if (c === 'DIR' || Array.isArray(c)) return } this.matches[index][e] = true if (this.stat) this._stat(e) } GlobSync.prototype._readdirInGlobStar = function (abs) { // follow all symlinked directories forever // just proceed as if this is a non-globstar situation if (this.follow) return this._readdir(abs, false) var entries var lstat var stat try { lstat = fs.lstatSync(abs) } catch (er) { if (er.code === 'ENOENT') { // lstat failed, doesn't exist return null } } var isSym = lstat && lstat.isSymbolicLink() this.symlinks[abs] = isSym // If it's not a symlink or a dir, then it's definitely a regular file. // don't bother doing a readdir in that case. if (!isSym && lstat && !lstat.isDirectory()) this.cache[abs] = 'FILE' else entries = this._readdir(abs, false) return entries } GlobSync.prototype._readdir = function (abs, inGlobStar) { var entries if (inGlobStar && !ownProp(this.symlinks, abs)) return this._readdirInGlobStar(abs) if (ownProp(this.cache, abs)) { var c = this.cache[abs] if (!c || c === 'FILE') return null if (Array.isArray(c)) return c } try { return this._readdirEntries(abs, fs.readdirSync(abs)) } catch (er) { this._readdirError(abs, er) return null } } GlobSync.prototype._readdirEntries = function (abs, entries) { // if we haven't asked to stat everything, then just // assume that everything in there exists, so we can avoid // having to stat it a second time. if (!this.mark && !this.stat) { for (var i = 0; i < entries.length; i ++) { var e = entries[i] if (abs === '/') e = abs + e else e = abs + '/' + e this.cache[e] = true } } this.cache[abs] = entries // mark and cache dir-ness return entries } GlobSync.prototype._readdirError = function (f, er) { // handle errors, and cache the information switch (er.code) { case 'ENOTSUP': // https://github.com/isaacs/node-glob/issues/205 case 'ENOTDIR': // totally normal. means it *does* exist. var abs = this._makeAbs(f) this.cache[abs] = 'FILE' if (abs === this.cwdAbs) { var error = new Error(er.code + ' invalid cwd ' + this.cwd) error.path = this.cwd error.code = er.code throw error } break case 'ENOENT': // not terribly unusual case 'ELOOP': case 'ENAMETOOLONG': case 'UNKNOWN': this.cache[this._makeAbs(f)] = false break default: // some unusual error. Treat as failure. this.cache[this._makeAbs(f)] = false if (this.strict) throw er if (!this.silent) console.error('glob error', er) break } } GlobSync.prototype._processGlobStar = function (prefix, read, abs, remain, index, inGlobStar) { var entries = this._readdir(abs, inGlobStar) // no entries means not a dir, so it can never have matches // foo.txt/** doesn't match foo.txt if (!entries) return // test without the globstar, and with every child both below // and replacing the globstar. var remainWithoutGlobStar = remain.slice(1) var gspref = prefix ? [ prefix ] : [] var noGlobStar = gspref.concat(remainWithoutGlobStar) // the noGlobStar pattern exits the inGlobStar state this._process(noGlobStar, index, false) var len = entries.length var isSym = this.symlinks[abs] // If it's a symlink, and we're in a globstar, then stop if (isSym && inGlobStar) return for (var i = 0; i < len; i++) { var e = entries[i] if (e.charAt(0) === '.' && !this.dot) continue // these two cases enter the inGlobStar state var instead = gspref.concat(entries[i], remainWithoutGlobStar) this._process(instead, index, true) var below = gspref.concat(entries[i], remain) this._process(below, index, true) } } GlobSync.prototype._processSimple = function (prefix, index) { // XXX review this. Shouldn't it be doing the mounting etc // before doing stat? kinda weird? var exists = this._stat(prefix) if (!this.matches[index]) this.matches[index] = Object.create(null) // If it doesn't exist, then just mark the lack of results if (!exists) return if (prefix && isAbsolute(prefix) && !this.nomount) { var trail = /[\/\\]$/.test(prefix) if (prefix.charAt(0) === '/') { prefix = path.join(this.root, prefix) } else { prefix = path.resolve(this.root, prefix) if (trail) prefix += '/' } } if (process.platform === 'win32') prefix = prefix.replace(/\\/g, '/') // Mark this as a match this._emitMatch(index, prefix) } // Returns either 'DIR', 'FILE', or false GlobSync.prototype._stat = function (f) { var abs = this._makeAbs(f) var needDir = f.slice(-1) === '/' if (f.length > this.maxLength) return false if (!this.stat && ownProp(this.cache, abs)) { var c = this.cache[abs] if (Array.isArray(c)) c = 'DIR' // It exists, but maybe not how we need it if (!needDir || c === 'DIR') return c if (needDir && c === 'FILE') return false // otherwise we have to stat, because maybe c=true // if we know it exists, but not what it is. } var exists var stat = this.statCache[abs] if (!stat) { var lstat try { lstat = fs.lstatSync(abs) } catch (er) { if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) { this.statCache[abs] = false return false } } if (lstat && lstat.isSymbolicLink()) { try { stat = fs.statSync(abs) } catch (er) { stat = lstat } } else { stat = lstat } } this.statCache[abs] = stat var c = true if (stat) c = stat.isDirectory() ? 'DIR' : 'FILE' this.cache[abs] = this.cache[abs] || c if (needDir && c === 'FILE') return false return c } GlobSync.prototype._mark = function (p) { return common.mark(this, p) } GlobSync.prototype._makeAbs = function (f) { return common.makeAbs(this, f) } /***/ }), /* 154 */ /***/ (function(module, exports, __webpack_require__) { var wrappy = __webpack_require__(62) var reqs = Object.create(null) var once = __webpack_require__(63) module.exports = wrappy(inflight) function inflight (key, cb) { if (reqs[key]) { reqs[key].push(cb) return null } else { reqs[key] = [cb] return makeres(key) } } function makeres (key) { return once(function RES () { var cbs = reqs[key] var len = cbs.length var args = slice(arguments) // XXX It's somewhat ambiguous whether a new callback added in this // pass should be queued for later execution if something in the // list of callbacks throws, or if it should just be discarded. // However, it's such an edge case that it hardly matters, and either // choice is likely as surprising as the other. // As it happens, we do go ahead and schedule it for later execution. try { for (var i = 0; i < len; i++) { cbs[i].apply(null, args) } } finally { if (cbs.length > len) { // added more in the interim. // de-zalgo, just in case, but don't call again. cbs.splice(0, len) process.nextTick(function () { RES.apply(null, args) }) } else { delete reqs[key] } } }) } function slice (args) { var length = args.length var array = [] for (var i = 0; i < length; i++) array[i] = args[i] return array } /***/ }), /* 155 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var fs = __webpack_require__(6); var func = __webpack_require__(26); var vfile = __webpack_require__(156); module.exports = vfile; vfile.read = read; vfile.readSync = readSync; vfile.write = write; vfile.writeSync = writeSync; /* Create a virtual file and read it in, asynchronously. */ function read(description, options, callback) { var file = vfile(description); if (!callback && func(options)) { callback = options; options = null; } if (!callback) { return new Promise(executor); } executor(null, callback); function executor(resolve, reject) { fs.readFile(file.path, options, done); function done(err, res) { if (err) { reject(err); } else { file.contents = res; if (resolve) { resolve(file); } else { callback(null, file); } } } } } /* Create a virtual file and read it in, synchronously. */ function readSync(description, options) { var file = vfile(description); file.contents = fs.readFileSync(file.path, options); return file; } /* Create a virtual file and write it out, asynchronously. */ function write(description, options, callback) { var file = vfile(description); /* Weird, right? Otherwise `fs` doesn’t accept it. */ if (!callback && func(options)) { callback = options; options = undefined; } if (!callback) { return new Promise(executor); } executor(null, callback); function executor(resolve, reject) { fs.writeFile(file.path, file.contents || '', options, done); function done(err) { if (err) { reject(err); } else if (resolve) { resolve(); } else { callback(); } } } } /* Create a virtual file and write it out, synchronously. */ function writeSync(description, options) { var file = vfile(description); fs.writeFileSync(file.path, file.contents || '', options); } /***/ }), /* 156 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var buffer = __webpack_require__(64); var vfile = __webpack_require__(157); module.exports = toVFile; /* Create a virtual file from a description. * If `options` is a string or a buffer, it’s used as the * path. In all other cases, the options are passed through * to `vfile()`. */ function toVFile(options) { if (typeof options === 'string' || buffer(options)) { options = {path: String(options)}; } return vfile(options); } /***/ }), /* 157 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var VMessage = __webpack_require__(65); var VFile = __webpack_require__(158); module.exports = VFile; var proto = VFile.prototype; proto.message = message; proto.info = info; proto.fail = fail; /* Slight backwards compatibility. Remove in the future. */ proto.warn = message; /* Create a message with `reason` at `position`. * When an error is passed in as `reason`, copies the stack. */ function message(reason, position, origin) { var filePath = this.path; var message = new VMessage(reason, position, origin); if (filePath) { message.name = filePath + ':' + message.name; message.file = filePath; } message.fatal = false; this.messages.push(message); return message; } /* Fail. Creates a vmessage, associates it with the file, * and throws it. */ function fail() { var message = this.message.apply(this, arguments); message.fatal = true; throw message; } /* Info. Creates a vmessage, associates it with the file, * and marks the fatality as null. */ function info() { var message = this.message.apply(this, arguments); message.fatal = null; return message; } /***/ }), /* 158 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var path = __webpack_require__(4); var replace = __webpack_require__(66); var buffer = __webpack_require__(64); module.exports = VFile; var own = {}.hasOwnProperty; var proto = VFile.prototype; proto.toString = toString; /* Order of setting (least specific to most), we need this because * otherwise `{stem: 'a', path: '~/b.js'}` would throw, as a path * is needed before a stem can be set. */ var order = [ 'history', 'path', 'basename', 'stem', 'extname', 'dirname' ]; /* Construct a new file. */ function VFile(options) { var prop; var index; var length; if (!options) { options = {}; } else if (typeof options === 'string' || buffer(options)) { options = {contents: options}; } else if ('message' in options && 'messages' in options) { return options; } if (!(this instanceof VFile)) { return new VFile(options); } this.data = {}; this.messages = []; this.history = []; this.cwd = process.cwd(); /* Set path related properties in the correct order. */ index = -1; length = order.length; while (++index < length) { prop = order[index]; if (own.call(options, prop)) { this[prop] = options[prop]; } } /* Set non-path related properties. */ for (prop in options) { if (order.indexOf(prop) === -1) { this[prop] = options[prop]; } } } /* Access full path (`~/index.min.js`). */ Object.defineProperty(proto, 'path', { get: function () { return this.history[this.history.length - 1]; }, set: function (path) { assertNonEmpty(path, 'path'); if (path !== this.path) { this.history.push(path); } } }); /* Access parent path (`~`). */ Object.defineProperty(proto, 'dirname', { get: function () { return typeof this.path === 'string' ? path.dirname(this.path) : undefined; }, set: function (dirname) { assertPath(this.path, 'dirname'); this.path = path.join(dirname || '', this.basename); } }); /* Access basename (`index.min.js`). */ Object.defineProperty(proto, 'basename', { get: function () { return typeof this.path === 'string' ? path.basename(this.path) : undefined; }, set: function (basename) { assertNonEmpty(basename, 'basename'); assertPart(basename, 'basename'); this.path = path.join(this.dirname || '', basename); } }); /* Access extname (`.js`). */ Object.defineProperty(proto, 'extname', { get: function () { return typeof this.path === 'string' ? path.extname(this.path) : undefined; }, set: function (extname) { var ext = extname || ''; assertPart(ext, 'extname'); assertPath(this.path, 'extname'); if (ext) { if (ext.charAt(0) !== '.') { throw new Error('`extname` must start with `.`'); } if (ext.indexOf('.', 1) !== -1) { throw new Error('`extname` cannot contain multiple dots'); } } this.path = replace(this.path, ext); } }); /* Access stem (`index.min`). */ Object.defineProperty(proto, 'stem', { get: function () { return typeof this.path === 'string' ? path.basename(this.path, this.extname) : undefined; }, set: function (stem) { assertNonEmpty(stem, 'stem'); assertPart(stem, 'stem'); this.path = path.join(this.dirname || '', stem + (this.extname || '')); } }); /* Get the value of the file. */ function toString(encoding) { var value = this.contents || ''; return buffer(value) ? value.toString(encoding) : String(value); } /* Assert that `part` is not a path (i.e., does * not contain `path.sep`). */ function assertPart(part, name) { if (part.indexOf(path.sep) !== -1) { throw new Error('`' + name + '` cannot be a path: did not expect `' + path.sep + '`'); } } /* Assert that `part` is not empty. */ function assertNonEmpty(part, name) { if (!part) { throw new Error('`' + name + '` cannot be empty'); } } /* Assert `path` exists. */ function assertPath(path, name) { if (!path) { throw new Error('Setting `' + name + '` requires `path` to be set too'); } } /***/ }), /* 159 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /* Expose. */ module.exports = hidden; /* Check if `filename` is hidden (starts with a dot). */ function hidden(filename) { if (typeof filename !== 'string') { throw new Error('Expected string'); } return filename.charAt(0) === '.'; } /***/ }), /* 160 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var debug = __webpack_require__(9)('unified-engine:file-set-pipeline:stdin'); var vfile = __webpack_require__(39); var concat = __webpack_require__(161); module.exports = stdin; function stdin(context, settings, next) { var streamIn = settings.streamIn; var err; if (settings.files && settings.files.length !== 0) { debug('Ignoring `streamIn`'); if (settings.filePath) { err = new Error( 'Do not pass both `--file-path` and real files.\n' + 'Did you mean to pass stdin instead of files?' ); } next(err); return; } if (streamIn.isTTY) { debug('Cannot read from `tty` stream'); next(new Error('No input')); return; } debug('Reading from `streamIn`'); streamIn.pipe(concat({encoding: 'string'}, read)); function read(value) { var file = vfile(settings.filePath || undefined); debug('Read from `streamIn`'); file.cwd = settings.cwd; file.contents = value; file.data.unifiedEngineGiven = true; file.data.unifiedEngineStreamIn = true; context.files = [file]; /* If `out` wasn’t set, set `out`. */ settings.out = settings.out === null || settings.out === undefined ? true : settings.out; next(); } } /***/ }), /* 161 */ /***/ (function(module, exports, __webpack_require__) { var Writable = __webpack_require__(162).Writable var inherits = __webpack_require__(13) var bufferFrom = __webpack_require__(167) if (typeof Uint8Array === 'undefined') { var U8 = __webpack_require__(168).Uint8Array } else { var U8 = Uint8Array } function ConcatStream(opts, cb) { if (!(this instanceof ConcatStream)) return new ConcatStream(opts, cb) if (typeof opts === 'function') { cb = opts opts = {} } if (!opts) opts = {} var encoding = opts.encoding var shouldInferEncoding = false if (!encoding) { shouldInferEncoding = true } else { encoding = String(encoding).toLowerCase() if (encoding === 'u8' || encoding === 'uint8') { encoding = 'uint8array' } } Writable.call(this, { objectMode: true }) this.encoding = encoding this.shouldInferEncoding = shouldInferEncoding if (cb) this.on('finish', function () { cb(this.getBody()) }) this.body = [] } module.exports = ConcatStream inherits(ConcatStream, Writable) ConcatStream.prototype._write = function(chunk, enc, next) { this.body.push(chunk) next() } ConcatStream.prototype.inferEncoding = function (buff) { var firstBuffer = buff === undefined ? this.body[0] : buff; if (Buffer.isBuffer(firstBuffer)) return 'buffer' if (typeof Uint8Array !== 'undefined' && firstBuffer instanceof Uint8Array) return 'uint8array' if (Array.isArray(firstBuffer)) return 'array' if (typeof firstBuffer === 'string') return 'string' if (Object.prototype.toString.call(firstBuffer) === "[object Object]") return 'object' return 'buffer' } ConcatStream.prototype.getBody = function () { if (!this.encoding && this.body.length === 0) return [] if (this.shouldInferEncoding) this.encoding = this.inferEncoding() if (this.encoding === 'array') return arrayConcat(this.body) if (this.encoding === 'string') return stringConcat(this.body) if (this.encoding === 'buffer') return bufferConcat(this.body) if (this.encoding === 'uint8array') return u8Concat(this.body) return this.body } var isArray = Array.isArray || function (arr) { return Object.prototype.toString.call(arr) == '[object Array]' } function isArrayish (arr) { return /Array\]$/.test(Object.prototype.toString.call(arr)) } function isBufferish (p) { return typeof p === 'string' || isArrayish(p) || (p && typeof p.subarray === 'function') } function stringConcat (parts) { var strings = [] var needsToString = false for (var i = 0; i < parts.length; i++) { var p = parts[i] if (typeof p === 'string') { strings.push(p) } else if (Buffer.isBuffer(p)) { strings.push(p) } else if (isBufferish(p)) { strings.push(bufferFrom(p)) } else { strings.push(bufferFrom(String(p))) } } if (Buffer.isBuffer(parts[0])) { strings = Buffer.concat(strings) strings = strings.toString('utf8') } else { strings = strings.join('') } return strings } function bufferConcat (parts) { var bufs = [] for (var i = 0; i < parts.length; i++) { var p = parts[i] if (Buffer.isBuffer(p)) { bufs.push(p) } else if (isBufferish(p)) { bufs.push(bufferFrom(p)) } else { bufs.push(bufferFrom(String(p))) } } return Buffer.concat(bufs) } function arrayConcat (parts) { var res = [] for (var i = 0; i < parts.length; i++) { res.push.apply(res, parts[i]) } return res } function u8Concat (parts) { var len = 0 for (var i = 0; i < parts.length; i++) { if (typeof parts[i] === 'string') { parts[i] = bufferFrom(parts[i]) } len += parts[i].length } var u8 = new U8(len) for (var i = 0, offset = 0; i < parts.length; i++) { var part = parts[i] for (var j = 0; j < part.length; j++) { u8[offset++] = part[j] } } return u8 } /***/ }), /* 162 */ /***/ (function(module, exports, __webpack_require__) { var Stream = __webpack_require__(32); if (process.env.READABLE_STREAM === 'disable' && Stream) { module.exports = Stream; exports = module.exports = Stream.Readable; exports.Readable = Stream.Readable; exports.Writable = Stream.Writable; exports.Duplex = Stream.Duplex; exports.Transform = Stream.Transform; exports.PassThrough = Stream.PassThrough; exports.Stream = Stream; } else { exports = module.exports = __webpack_require__(67); exports.Stream = Stream || exports; exports.Readable = exports; exports.Writable = __webpack_require__(70); exports.Duplex = __webpack_require__(18); exports.Transform = __webpack_require__(72); exports.PassThrough = __webpack_require__(166); } /***/ }), /* 163 */ /***/ (function(module, exports) { var toString = {}.toString; module.exports = Array.isArray || function (arr) { return toString.call(arr) == '[object Array]'; }; /***/ }), /* 164 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } var Buffer = __webpack_require__(29).Buffer; var util = __webpack_require__(11); function copyBuffer(src, target, offset) { src.copy(target, offset); } module.exports = function () { function BufferList() { _classCallCheck(this, BufferList); this.head = null; this.tail = null; this.length = 0; } BufferList.prototype.push = function push(v) { var entry = { data: v, next: null }; if (this.length > 0) this.tail.next = entry;else this.head = entry; this.tail = entry; ++this.length; }; BufferList.prototype.unshift = function unshift(v) { var entry = { data: v, next: this.head }; if (this.length === 0) this.tail = entry; this.head = entry; ++this.length; }; BufferList.prototype.shift = function shift() { if (this.length === 0) return; var ret = this.head.data; if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next; --this.length; return ret; }; BufferList.prototype.clear = function clear() { this.head = this.tail = null; this.length = 0; }; BufferList.prototype.join = function join(s) { if (this.length === 0) return ''; var p = this.head; var ret = '' + p.data; while (p = p.next) { ret += s + p.data; }return ret; }; BufferList.prototype.concat = function concat(n) { if (this.length === 0) return Buffer.alloc(0); if (this.length === 1) return this.head.data; var ret = Buffer.allocUnsafe(n >>> 0); var p = this.head; var i = 0; while (p) { copyBuffer(p.data, ret, i); i += p.data.length; p = p.next; } return ret; }; return BufferList; }(); if (util && util.inspect && util.inspect.custom) { module.exports.prototype[util.inspect.custom] = function () { var obj = util.inspect({ length: this.length }); return this.constructor.name + ' ' + obj; }; } /***/ }), /* 165 */ /***/ (function(module, exports, __webpack_require__) { /** * For Node.js, simply re-export the core `util.deprecate` function. */ module.exports = __webpack_require__(11).deprecate; /***/ }), /* 166 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; // 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. // a passthrough stream. // basically just the most minimal sort of Transform stream. // Every written chunk gets output as-is. module.exports = PassThrough; var Transform = __webpack_require__(72); /**/ var util = __webpack_require__(22); util.inherits = __webpack_require__(13); /**/ util.inherits(PassThrough, Transform); function PassThrough(options) { if (!(this instanceof PassThrough)) return new PassThrough(options); Transform.call(this, options); } PassThrough.prototype._transform = function (chunk, encoding, cb) { cb(null, chunk); }; /***/ }), /* 167 */ /***/ (function(module, exports) { var toString = Object.prototype.toString var isModern = ( typeof Buffer.alloc === 'function' && typeof Buffer.allocUnsafe === 'function' && typeof Buffer.from === 'function' ) function isArrayBuffer (input) { return toString.call(input).slice(8, -1) === 'ArrayBuffer' } function fromArrayBuffer (obj, byteOffset, length) { byteOffset >>>= 0 var maxLength = obj.byteLength - byteOffset if (maxLength < 0) { throw new RangeError("'offset' is out of bounds") } if (length === undefined) { length = maxLength } else { length >>>= 0 if (length > maxLength) { throw new RangeError("'length' is out of bounds") } } return isModern ? Buffer.from(obj.slice(byteOffset, byteOffset + length)) : new Buffer(new Uint8Array(obj.slice(byteOffset, byteOffset + length))) } function fromString (string, encoding) { if (typeof encoding !== 'string' || encoding === '') { encoding = 'utf8' } if (!Buffer.isEncoding(encoding)) { throw new TypeError('"encoding" must be a valid string encoding') } return isModern ? Buffer.from(string, encoding) : new Buffer(string, encoding) } function bufferFrom (value, encodingOrOffset, length) { if (typeof value === 'number') { throw new TypeError('"value" argument must not be a number') } if (isArrayBuffer(value)) { return fromArrayBuffer(value, encodingOrOffset, length) } if (typeof value === 'string') { return fromString(value, encodingOrOffset) } return isModern ? Buffer.from(value) : new Buffer(value) } module.exports = bufferFrom /***/ }), /* 168 */ /***/ (function(module, exports) { var undefined = (void 0); // Paranoia // Beyond this value, index getters/setters (i.e. array[0], array[1]) are so slow to // create, and consume so much memory, that the browser appears frozen. var MAX_ARRAY_LENGTH = 1e5; // Approximations of internal ECMAScript conversion functions var ECMAScript = (function() { // Stash a copy in case other scripts modify these var opts = Object.prototype.toString, ophop = Object.prototype.hasOwnProperty; return { // Class returns internal [[Class]] property, used to avoid cross-frame instanceof issues: Class: function(v) { return opts.call(v).replace(/^\[object *|\]$/g, ''); }, HasProperty: function(o, p) { return p in o; }, HasOwnProperty: function(o, p) { return ophop.call(o, p); }, IsCallable: function(o) { return typeof o === 'function'; }, ToInt32: function(v) { return v >> 0; }, ToUint32: function(v) { return v >>> 0; } }; }()); // Snapshot intrinsics var LN2 = Math.LN2, abs = Math.abs, floor = Math.floor, log = Math.log, min = Math.min, pow = Math.pow, round = Math.round; // ES5: lock down object properties function configureProperties(obj) { if (getOwnPropNames && defineProp) { var props = getOwnPropNames(obj), i; for (i = 0; i < props.length; i += 1) { defineProp(obj, props[i], { value: obj[props[i]], writable: false, enumerable: false, configurable: false }); } } } // emulate ES5 getter/setter API using legacy APIs // http://blogs.msdn.com/b/ie/archive/2010/09/07/transitioning-existing-code-to-the-es5-getter-setter-apis.aspx // (second clause tests for Object.defineProperty() in IE<9 that only supports extending DOM prototypes, but // note that IE<9 does not support __defineGetter__ or __defineSetter__ so it just renders the method harmless) var defineProp if (Object.defineProperty && (function() { try { Object.defineProperty({}, 'x', {}); return true; } catch (e) { return false; } })()) { defineProp = Object.defineProperty; } else { defineProp = function(o, p, desc) { if (!o === Object(o)) throw new TypeError("Object.defineProperty called on non-object"); if (ECMAScript.HasProperty(desc, 'get') && Object.prototype.__defineGetter__) { Object.prototype.__defineGetter__.call(o, p, desc.get); } if (ECMAScript.HasProperty(desc, 'set') && Object.prototype.__defineSetter__) { Object.prototype.__defineSetter__.call(o, p, desc.set); } if (ECMAScript.HasProperty(desc, 'value')) { o[p] = desc.value; } return o; }; } var getOwnPropNames = Object.getOwnPropertyNames || function (o) { if (o !== Object(o)) throw new TypeError("Object.getOwnPropertyNames called on non-object"); var props = [], p; for (p in o) { if (ECMAScript.HasOwnProperty(o, p)) { props.push(p); } } return props; }; // ES5: Make obj[index] an alias for obj._getter(index)/obj._setter(index, value) // for index in 0 ... obj.length function makeArrayAccessors(obj) { if (!defineProp) { return; } if (obj.length > MAX_ARRAY_LENGTH) throw new RangeError("Array too large for polyfill"); function makeArrayAccessor(index) { defineProp(obj, index, { 'get': function() { return obj._getter(index); }, 'set': function(v) { obj._setter(index, v); }, enumerable: true, configurable: false }); } var i; for (i = 0; i < obj.length; i += 1) { makeArrayAccessor(i); } } // Internal conversion functions: // pack() - take a number (interpreted as Type), output a byte array // unpack() - take a byte array, output a Type-like number function as_signed(value, bits) { var s = 32 - bits; return (value << s) >> s; } function as_unsigned(value, bits) { var s = 32 - bits; return (value << s) >>> s; } function packI8(n) { return [n & 0xff]; } function unpackI8(bytes) { return as_signed(bytes[0], 8); } function packU8(n) { return [n & 0xff]; } function unpackU8(bytes) { return as_unsigned(bytes[0], 8); } function packU8Clamped(n) { n = round(Number(n)); return [n < 0 ? 0 : n > 0xff ? 0xff : n & 0xff]; } function packI16(n) { return [(n >> 8) & 0xff, n & 0xff]; } function unpackI16(bytes) { return as_signed(bytes[0] << 8 | bytes[1], 16); } function packU16(n) { return [(n >> 8) & 0xff, n & 0xff]; } function unpackU16(bytes) { return as_unsigned(bytes[0] << 8 | bytes[1], 16); } function packI32(n) { return [(n >> 24) & 0xff, (n >> 16) & 0xff, (n >> 8) & 0xff, n & 0xff]; } function unpackI32(bytes) { return as_signed(bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3], 32); } function packU32(n) { return [(n >> 24) & 0xff, (n >> 16) & 0xff, (n >> 8) & 0xff, n & 0xff]; } function unpackU32(bytes) { return as_unsigned(bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3], 32); } function packIEEE754(v, ebits, fbits) { var bias = (1 << (ebits - 1)) - 1, s, e, f, ln, i, bits, str, bytes; function roundToEven(n) { var w = floor(n), f = n - w; if (f < 0.5) return w; if (f > 0.5) return w + 1; return w % 2 ? w + 1 : w; } // Compute sign, exponent, fraction if (v !== v) { // NaN // http://dev.w3.org/2006/webapi/WebIDL/#es-type-mapping e = (1 << ebits) - 1; f = pow(2, fbits - 1); s = 0; } else if (v === Infinity || v === -Infinity) { e = (1 << ebits) - 1; f = 0; s = (v < 0) ? 1 : 0; } else if (v === 0) { e = 0; f = 0; s = (1 / v === -Infinity) ? 1 : 0; } else { s = v < 0; v = abs(v); if (v >= pow(2, 1 - bias)) { e = min(floor(log(v) / LN2), 1023); f = roundToEven(v / pow(2, e) * pow(2, fbits)); if (f / pow(2, fbits) >= 2) { e = e + 1; f = 1; } if (e > bias) { // Overflow e = (1 << ebits) - 1; f = 0; } else { // Normalized e = e + bias; f = f - pow(2, fbits); } } else { // Denormalized e = 0; f = roundToEven(v / pow(2, 1 - bias - fbits)); } } // Pack sign, exponent, fraction bits = []; for (i = fbits; i; i -= 1) { bits.push(f % 2 ? 1 : 0); f = floor(f / 2); } for (i = ebits; i; i -= 1) { bits.push(e % 2 ? 1 : 0); e = floor(e / 2); } bits.push(s ? 1 : 0); bits.reverse(); str = bits.join(''); // Bits to bytes bytes = []; while (str.length) { bytes.push(parseInt(str.substring(0, 8), 2)); str = str.substring(8); } return bytes; } function unpackIEEE754(bytes, ebits, fbits) { // Bytes to bits var bits = [], i, j, b, str, bias, s, e, f; for (i = bytes.length; i; i -= 1) { b = bytes[i - 1]; for (j = 8; j; j -= 1) { bits.push(b % 2 ? 1 : 0); b = b >> 1; } } bits.reverse(); str = bits.join(''); // Unpack sign, exponent, fraction bias = (1 << (ebits - 1)) - 1; s = parseInt(str.substring(0, 1), 2) ? -1 : 1; e = parseInt(str.substring(1, 1 + ebits), 2); f = parseInt(str.substring(1 + ebits), 2); // Produce number if (e === (1 << ebits) - 1) { return f !== 0 ? NaN : s * Infinity; } else if (e > 0) { // Normalized return s * pow(2, e - bias) * (1 + f / pow(2, fbits)); } else if (f !== 0) { // Denormalized return s * pow(2, -(bias - 1)) * (f / pow(2, fbits)); } else { return s < 0 ? -0 : 0; } } function unpackF64(b) { return unpackIEEE754(b, 11, 52); } function packF64(v) { return packIEEE754(v, 11, 52); } function unpackF32(b) { return unpackIEEE754(b, 8, 23); } function packF32(v) { return packIEEE754(v, 8, 23); } // // 3 The ArrayBuffer Type // (function() { /** @constructor */ var ArrayBuffer = function ArrayBuffer(length) { length = ECMAScript.ToInt32(length); if (length < 0) throw new RangeError('ArrayBuffer size is not a small enough positive integer'); this.byteLength = length; this._bytes = []; this._bytes.length = length; var i; for (i = 0; i < this.byteLength; i += 1) { this._bytes[i] = 0; } configureProperties(this); }; exports.ArrayBuffer = exports.ArrayBuffer || ArrayBuffer; // // 4 The ArrayBufferView Type // // NOTE: this constructor is not exported /** @constructor */ var ArrayBufferView = function ArrayBufferView() { //this.buffer = null; //this.byteOffset = 0; //this.byteLength = 0; }; // // 5 The Typed Array View Types // function makeConstructor(bytesPerElement, pack, unpack) { // Each TypedArray type requires a distinct constructor instance with // identical logic, which this produces. var ctor; ctor = function(buffer, byteOffset, length) { var array, sequence, i, s; if (!arguments.length || typeof arguments[0] === 'number') { // Constructor(unsigned long length) this.length = ECMAScript.ToInt32(arguments[0]); if (length < 0) throw new RangeError('ArrayBufferView size is not a small enough positive integer'); this.byteLength = this.length * this.BYTES_PER_ELEMENT; this.buffer = new ArrayBuffer(this.byteLength); this.byteOffset = 0; } else if (typeof arguments[0] === 'object' && arguments[0].constructor === ctor) { // Constructor(TypedArray array) array = arguments[0]; this.length = array.length; this.byteLength = this.length * this.BYTES_PER_ELEMENT; this.buffer = new ArrayBuffer(this.byteLength); this.byteOffset = 0; for (i = 0; i < this.length; i += 1) { this._setter(i, array._getter(i)); } } else if (typeof arguments[0] === 'object' && !(arguments[0] instanceof ArrayBuffer || ECMAScript.Class(arguments[0]) === 'ArrayBuffer')) { // Constructor(sequence array) sequence = arguments[0]; this.length = ECMAScript.ToUint32(sequence.length); this.byteLength = this.length * this.BYTES_PER_ELEMENT; this.buffer = new ArrayBuffer(this.byteLength); this.byteOffset = 0; for (i = 0; i < this.length; i += 1) { s = sequence[i]; this._setter(i, Number(s)); } } else if (typeof arguments[0] === 'object' && (arguments[0] instanceof ArrayBuffer || ECMAScript.Class(arguments[0]) === 'ArrayBuffer')) { // Constructor(ArrayBuffer buffer, // optional unsigned long byteOffset, optional unsigned long length) this.buffer = buffer; this.byteOffset = ECMAScript.ToUint32(byteOffset); if (this.byteOffset > this.buffer.byteLength) { throw new RangeError("byteOffset out of range"); } if (this.byteOffset % this.BYTES_PER_ELEMENT) { // The given byteOffset must be a multiple of the element // size of the specific type, otherwise an exception is raised. throw new RangeError("ArrayBuffer length minus the byteOffset is not a multiple of the element size."); } if (arguments.length < 3) { this.byteLength = this.buffer.byteLength - this.byteOffset; if (this.byteLength % this.BYTES_PER_ELEMENT) { throw new RangeError("length of buffer minus byteOffset not a multiple of the element size"); } this.length = this.byteLength / this.BYTES_PER_ELEMENT; } else { this.length = ECMAScript.ToUint32(length); this.byteLength = this.length * this.BYTES_PER_ELEMENT; } if ((this.byteOffset + this.byteLength) > this.buffer.byteLength) { throw new RangeError("byteOffset and length reference an area beyond the end of the buffer"); } } else { throw new TypeError("Unexpected argument type(s)"); } this.constructor = ctor; configureProperties(this); makeArrayAccessors(this); }; ctor.prototype = new ArrayBufferView(); ctor.prototype.BYTES_PER_ELEMENT = bytesPerElement; ctor.prototype._pack = pack; ctor.prototype._unpack = unpack; ctor.BYTES_PER_ELEMENT = bytesPerElement; // getter type (unsigned long index); ctor.prototype._getter = function(index) { if (arguments.length < 1) throw new SyntaxError("Not enough arguments"); index = ECMAScript.ToUint32(index); if (index >= this.length) { return undefined; } var bytes = [], i, o; for (i = 0, o = this.byteOffset + index * this.BYTES_PER_ELEMENT; i < this.BYTES_PER_ELEMENT; i += 1, o += 1) { bytes.push(this.buffer._bytes[o]); } return this._unpack(bytes); }; // NONSTANDARD: convenience alias for getter: type get(unsigned long index); ctor.prototype.get = ctor.prototype._getter; // setter void (unsigned long index, type value); ctor.prototype._setter = function(index, value) { if (arguments.length < 2) throw new SyntaxError("Not enough arguments"); index = ECMAScript.ToUint32(index); if (index >= this.length) { return undefined; } var bytes = this._pack(value), i, o; for (i = 0, o = this.byteOffset + index * this.BYTES_PER_ELEMENT; i < this.BYTES_PER_ELEMENT; i += 1, o += 1) { this.buffer._bytes[o] = bytes[i]; } }; // void set(TypedArray array, optional unsigned long offset); // void set(sequence array, optional unsigned long offset); ctor.prototype.set = function(index, value) { if (arguments.length < 1) throw new SyntaxError("Not enough arguments"); var array, sequence, offset, len, i, s, d, byteOffset, byteLength, tmp; if (typeof arguments[0] === 'object' && arguments[0].constructor === this.constructor) { // void set(TypedArray array, optional unsigned long offset); array = arguments[0]; offset = ECMAScript.ToUint32(arguments[1]); if (offset + array.length > this.length) { throw new RangeError("Offset plus length of array is out of range"); } byteOffset = this.byteOffset + offset * this.BYTES_PER_ELEMENT; byteLength = array.length * this.BYTES_PER_ELEMENT; if (array.buffer === this.buffer) { tmp = []; for (i = 0, s = array.byteOffset; i < byteLength; i += 1, s += 1) { tmp[i] = array.buffer._bytes[s]; } for (i = 0, d = byteOffset; i < byteLength; i += 1, d += 1) { this.buffer._bytes[d] = tmp[i]; } } else { for (i = 0, s = array.byteOffset, d = byteOffset; i < byteLength; i += 1, s += 1, d += 1) { this.buffer._bytes[d] = array.buffer._bytes[s]; } } } else if (typeof arguments[0] === 'object' && typeof arguments[0].length !== 'undefined') { // void set(sequence array, optional unsigned long offset); sequence = arguments[0]; len = ECMAScript.ToUint32(sequence.length); offset = ECMAScript.ToUint32(arguments[1]); if (offset + len > this.length) { throw new RangeError("Offset plus length of array is out of range"); } for (i = 0; i < len; i += 1) { s = sequence[i]; this._setter(offset + i, Number(s)); } } else { throw new TypeError("Unexpected argument type(s)"); } }; // TypedArray subarray(long begin, optional long end); ctor.prototype.subarray = function(start, end) { function clamp(v, min, max) { return v < min ? min : v > max ? max : v; } start = ECMAScript.ToInt32(start); end = ECMAScript.ToInt32(end); if (arguments.length < 1) { start = 0; } if (arguments.length < 2) { end = this.length; } if (start < 0) { start = this.length + start; } if (end < 0) { end = this.length + end; } start = clamp(start, 0, this.length); end = clamp(end, 0, this.length); var len = end - start; if (len < 0) { len = 0; } return new this.constructor( this.buffer, this.byteOffset + start * this.BYTES_PER_ELEMENT, len); }; return ctor; } var Int8Array = makeConstructor(1, packI8, unpackI8); var Uint8Array = makeConstructor(1, packU8, unpackU8); var Uint8ClampedArray = makeConstructor(1, packU8Clamped, unpackU8); var Int16Array = makeConstructor(2, packI16, unpackI16); var Uint16Array = makeConstructor(2, packU16, unpackU16); var Int32Array = makeConstructor(4, packI32, unpackI32); var Uint32Array = makeConstructor(4, packU32, unpackU32); var Float32Array = makeConstructor(4, packF32, unpackF32); var Float64Array = makeConstructor(8, packF64, unpackF64); exports.Int8Array = exports.Int8Array || Int8Array; exports.Uint8Array = exports.Uint8Array || Uint8Array; exports.Uint8ClampedArray = exports.Uint8ClampedArray || Uint8ClampedArray; exports.Int16Array = exports.Int16Array || Int16Array; exports.Uint16Array = exports.Uint16Array || Uint16Array; exports.Int32Array = exports.Int32Array || Int32Array; exports.Uint32Array = exports.Uint32Array || Uint32Array; exports.Float32Array = exports.Float32Array || Float32Array; exports.Float64Array = exports.Float64Array || Float64Array; }()); // // 6 The DataView View Type // (function() { function r(array, index) { return ECMAScript.IsCallable(array.get) ? array.get(index) : array[index]; } var IS_BIG_ENDIAN = (function() { var u16array = new(exports.Uint16Array)([0x1234]), u8array = new(exports.Uint8Array)(u16array.buffer); return r(u8array, 0) === 0x12; }()); // Constructor(ArrayBuffer buffer, // optional unsigned long byteOffset, // optional unsigned long byteLength) /** @constructor */ var DataView = function DataView(buffer, byteOffset, byteLength) { if (arguments.length === 0) { buffer = new exports.ArrayBuffer(0); } else if (!(buffer instanceof exports.ArrayBuffer || ECMAScript.Class(buffer) === 'ArrayBuffer')) { throw new TypeError("TypeError"); } this.buffer = buffer || new exports.ArrayBuffer(0); this.byteOffset = ECMAScript.ToUint32(byteOffset); if (this.byteOffset > this.buffer.byteLength) { throw new RangeError("byteOffset out of range"); } if (arguments.length < 3) { this.byteLength = this.buffer.byteLength - this.byteOffset; } else { this.byteLength = ECMAScript.ToUint32(byteLength); } if ((this.byteOffset + this.byteLength) > this.buffer.byteLength) { throw new RangeError("byteOffset and length reference an area beyond the end of the buffer"); } configureProperties(this); }; function makeGetter(arrayType) { return function(byteOffset, littleEndian) { byteOffset = ECMAScript.ToUint32(byteOffset); if (byteOffset + arrayType.BYTES_PER_ELEMENT > this.byteLength) { throw new RangeError("Array index out of range"); } byteOffset += this.byteOffset; var uint8Array = new exports.Uint8Array(this.buffer, byteOffset, arrayType.BYTES_PER_ELEMENT), bytes = [], i; for (i = 0; i < arrayType.BYTES_PER_ELEMENT; i += 1) { bytes.push(r(uint8Array, i)); } if (Boolean(littleEndian) === Boolean(IS_BIG_ENDIAN)) { bytes.reverse(); } return r(new arrayType(new exports.Uint8Array(bytes).buffer), 0); }; } DataView.prototype.getUint8 = makeGetter(exports.Uint8Array); DataView.prototype.getInt8 = makeGetter(exports.Int8Array); DataView.prototype.getUint16 = makeGetter(exports.Uint16Array); DataView.prototype.getInt16 = makeGetter(exports.Int16Array); DataView.prototype.getUint32 = makeGetter(exports.Uint32Array); DataView.prototype.getInt32 = makeGetter(exports.Int32Array); DataView.prototype.getFloat32 = makeGetter(exports.Float32Array); DataView.prototype.getFloat64 = makeGetter(exports.Float64Array); function makeSetter(arrayType) { return function(byteOffset, value, littleEndian) { byteOffset = ECMAScript.ToUint32(byteOffset); if (byteOffset + arrayType.BYTES_PER_ELEMENT > this.byteLength) { throw new RangeError("Array index out of range"); } // Get bytes var typeArray = new arrayType([value]), byteArray = new exports.Uint8Array(typeArray.buffer), bytes = [], i, byteView; for (i = 0; i < arrayType.BYTES_PER_ELEMENT; i += 1) { bytes.push(r(byteArray, i)); } // Flip if necessary if (Boolean(littleEndian) === Boolean(IS_BIG_ENDIAN)) { bytes.reverse(); } // Write them byteView = new exports.Uint8Array(this.buffer, byteOffset, arrayType.BYTES_PER_ELEMENT); byteView.set(bytes); }; } DataView.prototype.setUint8 = makeSetter(exports.Uint8Array); DataView.prototype.setInt8 = makeSetter(exports.Int8Array); DataView.prototype.setUint16 = makeSetter(exports.Uint16Array); DataView.prototype.setInt16 = makeSetter(exports.Int16Array); DataView.prototype.setUint32 = makeSetter(exports.Uint32Array); DataView.prototype.setInt32 = makeSetter(exports.Int32Array); DataView.prototype.setFloat32 = makeSetter(exports.Float32Array); DataView.prototype.setFloat64 = makeSetter(exports.Float64Array); exports.DataView = exports.DataView || DataView; }()); /***/ }), /* 169 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var FileSet = __webpack_require__(170); var filePipeline = __webpack_require__(171); module.exports = transform; /* Transform all files. */ function transform(context, settings, next) { var fileSet = new FileSet(); context.fileSet = fileSet; fileSet.on('add', add).on('done', next); if (context.files.length === 0) { next(); } else { context.files.forEach(fileSet.add, fileSet); } function add(file) { filePipeline.run({ configuration: context.configuration, processor: settings.processor(), cwd: settings.cwd, extensions: settings.extensions, pluginPrefix: settings.pluginPrefix, treeIn: settings.treeIn, treeOut: settings.treeOut, inspect: settings.inspect, color: settings.color, out: settings.out, output: settings.output, streamOut: settings.streamOut, alwaysStringify: settings.alwaysStringify }, file, fileSet, done); function done(err) { /* istanbul ignore next - doesn’t occur as all * failures in `filePipeLine` are failed on each * file. Still, just to ensure things work in * the future, we add an extra check. */ if (err) { err = file.message(err); err.fatal = true; } fileSet.emit('one', file); } } } /***/ }), /* 170 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var events = __webpack_require__(37); var inherits = __webpack_require__(11).inherits; var trough = __webpack_require__(24); var vfile = __webpack_require__(39); var string = __webpack_require__(17); module.exports = FileSet; /* FileSet constructor. */ function FileSet() { var self = this; self.files = []; self.origins = []; self.expected = 0; self.actual = 0; self.pipeline = trough(); self.plugins = []; events.init.call(self); self.on('one', one.bind(self)); } /* Events. */ inherits(FileSet, events.EventEmitter); /* Expose methods. */ FileSet.prototype.valueOf = valueOf; FileSet.prototype.use = use; FileSet.prototype.add = add; /* Create an array representation of `fileSet`. */ function valueOf() { return this.files; } /* Attach middleware to the pipeline on `fileSet`. */ function use(plugin) { var self = this; var pipeline = self.pipeline; var duplicate = false; if (plugin && plugin.pluginId) { duplicate = self.plugins.some(function (fn) { return fn.pluginId === plugin.pluginId; }); } if (!duplicate && self.plugins.indexOf(plugin) !== -1) { duplicate = true; } if (!duplicate) { self.plugins.push(plugin); pipeline.use(plugin); } return this; } /* Add a file to be processed. * * Ignores duplicate files (based on the `filePath` at time * of addition). * * Only runs `file-pipeline` on files which have not * `failed` before addition. */ function add(file) { var self = this; var origin; if (string(file)) { file = vfile(file); } /* Prevent files from being added multiple times. */ origin = file.history[0]; if (self.origins.indexOf(origin) !== -1) { return self; } self.origins.push(origin); /* Add. */ self.valueOf().push(file); self.expected++; /* Force an asynchronous operation. * This ensures that files which fall through * the file pipeline immediately (e.g., when * already fatally failed) still queue up * correctly. */ setImmediate(function () { self.emit('add', file); }); return self; } /* Utility invoked when a single file has completed it's * pipeline, triggering `done` when all files are complete. */ function one() { var self = this; self.actual++; if (self.actual >= self.expected) { self.emit('done'); } } /***/ }), /* 171 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var trough = __webpack_require__(24); var read = __webpack_require__(172); var configure = __webpack_require__(173); var parse = __webpack_require__(175); var transform = __webpack_require__(176); var queue = __webpack_require__(177); var stringify = __webpack_require__(178); var copy = __webpack_require__(180); var stdout = __webpack_require__(181); var fileSystem = __webpack_require__(182); /* Expose: This pipeline ensures each of the pipes * always runs: even if the read pipe fails, * queue and write trigger. */ module.exports = trough() .use(chunk(trough().use(read).use(configure).use(parse).use(transform))) .use(chunk(trough().use(queue))) .use(chunk(trough().use(stringify).use(copy).use(stdout).use(fileSystem))); /* Factory to run a pipe. Wraps a pipe to trigger an * error on the `file` in `context`, but still call * `next`. */ function chunk(pipe) { return run; /* Run the bound bound pipe and handles any errors. */ function run(context, file, fileSet, next) { pipe.run(context, file, fileSet, one); function one(err) { var messages = file.messages; var index; if (err) { index = messages.indexOf(err); if (index === -1) { err = file.message(err); index = messages.length - 1; } messages[index].fatal = true; } next(); } } } /***/ }), /* 172 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var fs = __webpack_require__(6); var path = __webpack_require__(4); var debug = __webpack_require__(9)('unified-engine:file-pipeline:read'); var stats = __webpack_require__(12); module.exports = read; var resolve = path.resolve; var readFile = fs.readFile; /* Fill a file with its contents when not already filled. */ function read(context, file, fileSet, next) { var filePath = file.path; if (file.contents || file.data.unifiedEngineStreamIn) { debug('Not reading file `%s` with contents', filePath); next(); } else if (stats(file).fatal) { debug('Not reading failed file `%s`', filePath); next(); } else { filePath = resolve(context.cwd, filePath); debug('Reading `%s` in `%s`', filePath, 'utf8'); readFile(filePath, 'utf8', function (err, contents) { debug('Read `%s` (err: %s)', filePath, err); file.contents = contents || ''; next(err); }); } } /***/ }), /* 173 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var debug = __webpack_require__(9)('unified-engine:file-pipeline:configure'); var stats = __webpack_require__(12); var fnName = __webpack_require__(174); var object = __webpack_require__(35); var empty = __webpack_require__(73); module.exports = configure; /* Collect configuration for a file based on the context. */ function configure(context, file, fileSet, next) { var config = context.configuration; var processor = context.processor; if (stats(file).fatal) { return next(); } config.load(file.path, handleConfiguration); function handleConfiguration(err, configuration) { var plugins; var options; var plugin; var length; var index; var name; if (err) { return next(err); } /* Store configuration on the context object. */ debug('Using settings `%j`', configuration.settings); processor.data('settings', configuration.settings); plugins = configuration.plugins; length = plugins.length; index = -1; debug('Using `%d` plugins', length); while (++index < length) { plugin = plugins[index][0]; options = plugins[index][1]; if (options === false) { continue; } /* Allow for default arguments in es2020. */ if (options === null || (object(options) && empty(options))) { options = undefined; } name = fnName(plugin) || 'function'; debug('Using plug-in `%s`, with options `%j`', name, options); try { processor.use(plugin, options, fileSet); } catch (err) { /* istanbul ignore next - Shouldn’t happen anymore! */ return next(err); } } next(); } } /***/ }), /* 174 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = function (fn) { if (typeof fn !== 'function') { throw new TypeError('Expected a function'); } return fn.displayName || fn.name || (/function ([^\(]+)?\(/.exec(fn.toString()) || [])[1] || null; }; /***/ }), /* 175 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var debug = __webpack_require__(9)('unified-engine:file-pipeline:parse'); var stats = __webpack_require__(12); var json = __webpack_require__(51); module.exports = parse; /* Fill a file with a tree. */ function parse(context, file) { var message; if (stats(file).fatal) { return; } if (context.treeIn) { debug('Not parsing already parsed document'); try { context.tree = json(file.toString()); } catch (err) { message = file.message(new Error('Cannot read file as JSON\n' + err.message)); message.fatal = true; } /* Add the preferred extension to ensure the file, when compiled, is * correctly recognized. Only add it if there’s a path — not if the * file is for example stdin. */ if (file.path) { file.extname = context.extensions[0]; } file.contents = ''; return; } debug('Parsing `%s`', file.path); context.tree = context.processor.parse(file); debug('Parsed document'); } /***/ }), /* 176 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var debug = __webpack_require__(9)('unified-engine:file-pipeline:transform'); var stats = __webpack_require__(12); module.exports = transform; /* Transform the tree associated with a file with * configured plug-ins. */ function transform(context, file, fileSet, next) { if (stats(file).fatal) { next(); return; } debug('Transforming document `%s`', file.path); context.processor.run(context.tree, file, function (err, node) { debug('Transformed document (error: %s)', err); context.tree = node; next(err); }); } /***/ }), /* 177 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var debug = __webpack_require__(9)('unified-engine:file-pipeline:queue'); var stats = __webpack_require__(12); var func = __webpack_require__(26); module.exports = queue; /* Queue all files which came this far. * When the last file gets here, run the file-set pipeline * and flush the queue. */ function queue(context, file, fileSet, next) { var origin = file.history[0]; var map = fileSet.complete; var complete = true; if (!map) { map = {}; fileSet.complete = map; } debug('Queueing `%s`', origin); map[origin] = next; fileSet.valueOf().forEach(each); if (!complete) { debug('Not flushing: some files cannot be flushed'); return; } fileSet.complete = {}; fileSet.pipeline.run(fileSet, done); function each(file) { var key = file.history[0]; if (stats(file).fatal) { return; } if (func(map[key])) { debug('`%s` can be flushed', key); } else { debug('Interupting flush: `%s` is not finished', key); complete = false; } } function done(err) { debug('Flushing: all files can be flushed'); /* Flush. */ for (origin in map) { map[origin](err); } } } /***/ }), /* 178 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var debug = __webpack_require__(9)('unified-engine:file-pipeline:stringify'); var stats = __webpack_require__(12); var inspect = __webpack_require__(179); module.exports = stringify; /* Stringify a tree. */ function stringify(context, file) { var processor = context.processor; var tree = context.tree; var value; if (stats(file).fatal) { debug('Not compiling failed document'); return; } if (!context.output && !context.out && !context.alwaysStringify) { debug('Not compiling document without output settings'); return; } debug('Compiling `%s`', file.path); if (context.inspect) { /* Add a `txt` extension if there’s a path. */ if (file.path) { file.extname = '.txt'; } value = inspect[context.color ? 'color' : 'noColor'](tree) + '\n'; } else if (context.treeOut) { /* Add a `json` extension to ensure the file is correctly seen as JSON. * Only add it if there’s a path — not if the file is for example stdin. */ if (file.path) { file.extname = '.json'; } /* Add the line break to create a valid UNIX file. */ value = JSON.stringify(tree, null, 2) + '\n'; } else { value = processor.stringify(tree, file); } file.contents = value; debug('Compiled document'); } /***/ }), /* 179 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var isEmpty = __webpack_require__(73) /* Detect color support. */ var color = true try { color = 'inspect' in __webpack_require__(11) } catch (err) { /* istanbul ignore next - browser */ color = false } module.exports = color ? inspect : /* istanbul ignore next */ noColor inspect.color = inspect noColor.color = inspect inspect.noColor = noColor noColor.noColor = noColor var dim = ansiColor(2, 22) var yellow = ansiColor(33, 39) var green = ansiColor(32, 39) /* Define ANSII color removal functionality. */ var COLOR_EXPRESSION = new RegExp( '(?:' + '(?:\\u001b\\[)|' + '\\u009b' + ')' + '(?:' + '(?:[0-9]{1,3})?(?:(?:;[0-9]{0,3})*)?[A-M|f-m]' + ')|' + '\\u001b[A-M]', 'g' ) /* Standard keys defined by unist: * https://github.com/syntax-tree/unist. * We don’t ignore `data` though. */ var ignore = ['type', 'value', 'children', 'position'] /* Inspects a node, without using color. */ function noColor(node, pad) { return stripColor(inspect(node, pad)) } /* Inspects a node. */ function inspect(node, pad) { var result var children var index var length if (node && Boolean(node.length) && typeof node !== 'string') { length = node.length index = -1 result = [] while (++index < length) { result[index] = inspect(node[index]) } return result.join('\n') } if (!node || !node.type) { return String(node) } result = [formatNode(node)] children = node.children length = children && children.length index = -1 if (!length) { return result[0] } if (!pad || typeof pad === 'number') { pad = '' } while (++index < length) { node = children[index] if (index === length - 1) { result.push(formatNesting(pad + '└─ ') + inspect(node, pad + ' ')) } else { result.push(formatNesting(pad + '├─ ') + inspect(node, pad + '│ ')) } } return result.join('\n') } /* Colored nesting formatter. */ function formatNesting(value) { return dim(value) } /* Compile a single position. */ function compile(pos) { var values = [] if (!pos) { return null } values = [[pos.line || 1, pos.column || 1].join(':')] if ('offset' in pos) { values.push(String(pos.offset || 0)) } return values } /* Compile a location. */ function stringify(start, end) { var values = [] var positions = [] var offsets = [] add(start) add(end) if (positions.length !== 0) { values.push(positions.join('-')) } if (offsets.length !== 0) { values.push(offsets.join('-')) } return values.join(', ') /* Add a position. */ function add(position) { var tuple = compile(position) if (tuple) { positions.push(tuple[0]) if (tuple[1]) { offsets.push(tuple[1]) } } } } /* Colored node formatter. */ function formatNode(node) { var log = node.type var location = node.position || {} var position = stringify(location.start, location.end) var key var values = [] var value if (node.children) { log += dim('[') + yellow(node.children.length) + dim(']') } else if (typeof node.value === 'string') { log += dim(': ') + green(JSON.stringify(node.value)) } if (position) { log += ' (' + position + ')' } for (key in node) { value = node[key] if ( ignore.indexOf(key) !== -1 || value === null || value === undefined || (typeof value === 'object' && isEmpty(value)) ) { continue } values.push('[' + key + '=' + JSON.stringify(value) + ']') } if (values.length !== 0) { log += ' ' + values.join('') } return log } /* Remove ANSI colour from `value`. */ function stripColor(value) { return value.replace(COLOR_EXPRESSION, '') } /* Factory to wrap values in ANSI colours. */ function ansiColor(open, close) { return color function color(value) { return '\u001B[' + open + 'm' + value + '\u001B[' + close + 'm' } } /***/ }), /* 180 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var fs = __webpack_require__(6); var path = __webpack_require__(4); var debug = __webpack_require__(9)('unified-engine:file-pipeline:copy'); var string = __webpack_require__(17); module.exports = copy; var stat = fs.stat; var dirname = path.dirname; var resolve = path.resolve; var relative = path.relative; /* Move a file. */ function copy(context, file, fileSet, next) { var output = context.output; var multi = fileSet.expected > 1; var outpath = output; var currentPath = file.path; if (!string(outpath)) { debug('Not copying'); return next(); } outpath = resolve(context.cwd, outpath); debug('Copying `%s`', currentPath); stat(outpath, onstatfile); function onstatfile(err, stats) { if (err) { if (err.code !== 'ENOENT' || output.charAt(output.length - 1) === path.sep) { return next(new Error('Cannot read output directory. Error:\n' + err.message)); } stat(dirname(outpath), onstatparent); } else { done(stats.isDirectory()); } } /* This is either given an error, or the parent exists which * is a directory, but we should keep the basename of the * given file. */ function onstatparent(err) { if (err) { next(new Error('Cannot read parent directory. Error:\n' + err.message)); } else { done(false); } } function done(directory) { if (!directory && multi) { return next(new Error('Cannot write multiple files to single output: ' + outpath)); } file[directory ? 'dirname' : 'path'] = relative(file.cwd, outpath); debug('Copying document from %s to %s', currentPath, file.path); next(); } } /***/ }), /* 181 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var debug = __webpack_require__(9)('unified-engine:file-pipeline:stdout'); var stats = __webpack_require__(12); module.exports = stdout; /* Write a virtual file to `streamOut`. * Ignored when `output` is given, more than one file * was processed, or `out` is false. */ function stdout(context, file, fileSet, next) { if (!file.data.unifiedEngineGiven) { debug('Ignoring programmatically added file'); next(); } else if (stats(file).fatal || context.output || !context.out) { debug('Ignoring writing to `streamOut`'); next(); } else { debug('Writing document to `streamOut`'); context.streamOut.write(file.toString(), next); } } /***/ }), /* 182 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var fs = __webpack_require__(6); var path = __webpack_require__(4); var debug = __webpack_require__(9)('unified-engine:file-pipeline:file-system'); module.exports = fileSystem; var writeFile = fs.writeFile; var resolve = path.resolve; /* Write a virtual file to the file-system. * Ignored when `output` is not given. */ function fileSystem(context, file, fileSet, next) { var destinationPath; if (!context.output) { debug('Ignoring writing to file-system'); return next(); } if (!file.data.unifiedEngineGiven) { debug('Ignoring programmatically added file'); return next(); } destinationPath = file.path; if (!destinationPath) { debug('Cannot write file without a `destinationPath`'); return next(new Error('Cannot write file without an output path ')); } destinationPath = resolve(context.cwd, destinationPath); debug('Writing document to `%s`', destinationPath); file.stored = true; writeFile(destinationPath, file.toString(), next); } /***/ }), /* 183 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var xtend = __webpack_require__(7); var load = __webpack_require__(55); var report = __webpack_require__(184); var string = __webpack_require__(17); module.exports = log; var prefix = 'vfile-reporter'; function log(context, settings, next) { var reporter = settings.reporter || report; var diagnostics; if (string(reporter)) { try { reporter = load(reporter, {cwd: settings.cwd, prefix: prefix}); } catch (err) { next(new Error('Could not find reporter `' + reporter + '`')); return; } } diagnostics = reporter(context.files.filter(given), xtend(settings.reporterOptions, { quiet: settings.quiet, silent: settings.silent, color: settings.color })); if (diagnostics) { if (diagnostics.charAt(diagnostics.length - 1) !== '\n') { diagnostics += '\n'; } settings.streamError.write(diagnostics, next); } else { next(); } } function given(file) { return file.data.unifiedEngineGiven; } /***/ }), /* 184 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var supported = __webpack_require__(53).hasBasic; var width = __webpack_require__(185); var stringify = __webpack_require__(27); var repeat = __webpack_require__(10); var statistics = __webpack_require__(12); module.exports = reporter; /* Check which characters should be used. */ var windows = process.platform === 'win32'; /* `log-symbols` without chalk: */ /* istanbul ignore next - Windows. */ var chars = windows ? {error: '×', warning: '‼'} : {error: '✖', warning: '⚠'}; /* Match trailing white-space. */ var trailing = /\s*$/; /* Default filename. */ var DEFAULT = ''; var noop = {open: '', close: ''}; var colors = { underline: {open: '\u001b[4m', close: '\u001b[24m'}, red: {open: '\u001b[31m', close: '\u001b[39m'}, yellow: {open: '\u001b[33m', close: '\u001b[39m'}, green: {open: '\u001b[32m', close: '\u001b[39m'} }; var noops = { underline: noop, red: noop, yellow: noop, green: noop }; var labels = { true: 'error', false: 'warning', null: 'info', undefined: 'info' }; /* Report a file’s messages. */ function reporter(files, options) { var settings = options || {}; var one; if (!files) { return ''; } /* Error. */ if ('name' in files && 'message' in files) { return String(files.stack || files); } /* One file. */ if (!('length' in files)) { one = true; files = [files]; } return compile(parse(filter(files, settings), settings), one, settings); } function filter(files, options) { var result = []; var length = files.length; var index = -1; var file; if (!options.quiet && !options.silent) { return files.concat(); } while (++index < length) { file = files[index]; if (applicable(file, options).length !== 0) { result.push(file); } } return result; } function parse(files, options) { var length = files.length; var index = -1; var rows = []; var all = []; var locationSize = 0; var labelSize = 0; var reasonSize = 0; var ruleIdSize = 0; var file; var destination; var origin; var messages; var offset; var count; var message; var loc; var reason; var label; var id; while (++index < length) { file = files[index]; destination = current(file); origin = file.history[0] || destination; messages = applicable(file, options).sort(comparator); if (rows.length !== 0 && rows[rows.length - 1].type !== 'header') { rows.push({type: 'separator'}); } rows.push({ type: 'header', origin: origin, destination: destination, name: origin || options.defaultName || DEFAULT, stored: Boolean(file.stored), moved: Boolean(file.stored && destination !== origin), stats: statistics(messages) }); offset = -1; count = messages.length; while (++offset < count) { message = messages[offset]; id = message.ruleId || ''; reason = message.stack || message.message; loc = message.location; loc = stringify(loc.end.line && loc.end.column ? loc : loc.start); if (options.verbose && message.note) { reason += '\n' + message.note; } label = labels[message.fatal]; rows.push({ location: loc, label: label, reason: reason, ruleId: id, source: message.source }); locationSize = Math.max(realLength(loc), locationSize); labelSize = Math.max(realLength(label), labelSize); reasonSize = Math.max(realLength(reason), reasonSize); ruleIdSize = Math.max(realLength(id), ruleIdSize); } all = all.concat(messages); } return { rows: rows, statistics: statistics(all), location: locationSize, label: labelSize, reason: reasonSize, ruleId: ruleIdSize }; } function compile(map, one, options) { var enabled = options.color; var all = map.statistics; var rows = map.rows; var length = rows.length; var index = -1; var lines = []; var row; var line; var style; var color; if (enabled === null || enabled === undefined) { enabled = supported; } style = enabled ? colors : noops; while (++index < length) { row = rows[index]; if (row.type === 'separator') { lines.push(''); } else if (row.type === 'header') { if (one && !options.defaultName && !row.origin) { line = ''; } else { color = style[row.stats.fatal ? 'red' : (row.stats.total ? 'yellow' : 'green')]; line = style.underline.open + color.open + row.name + color.close + style.underline.close; line += row.moved ? ' > ' + row.destination : ''; } if (!row.stats.total) { line += line ? ': ' : ''; if (row.stored) { line += style.yellow.open + 'written' + style.yellow.close; } else { line += 'no issues found'; } } if (line) { lines.push(line); } } else { color = style[row.label === 'error' ? 'red' : 'yellow']; lines.push([ '', padLeft(row.location, map.location), padRight(color.open + row.label + color.close, map.label), padRight(row.reason, map.reason), padRight(row.ruleId, map.ruleId), row.source || '' ].join(' ').replace(trailing, '')); } } if (all.fatal || all.warn) { line = []; if (all.fatal) { line.push([ style.red.open + chars.error + style.red.close, all.fatal, plural(labels.true, all.fatal) ].join(' ')); } if (all.warn) { line.push([ style.yellow.open + chars.warning + style.yellow.close, all.warn, plural(labels.false, all.warn) ].join(' ')); } line = line.join(', '); if (all.total !== all.fatal && all.total !== all.warn) { line = all.total + ' messages (' + line + ')'; } lines.push('', line); } return lines.join('\n'); } function applicable(file, options) { var messages = file.messages; var length = messages.length; var index = -1; var result = []; if (options.silent) { while (++index < length) { if (messages[index].fatal) { result.push(messages[index]); } } } else { result = messages.concat(); } return result; } /* Get the length of `value`, ignoring ANSI sequences. */ function realLength(value) { var length = value.indexOf('\n'); return width(length === -1 ? value : value.slice(0, length)); } /* Pad `value` on the left. */ function padLeft(value, minimum) { return repeat(' ', minimum - realLength(value)) + value; } /* Pad `value` on the Right. */ function padRight(value, minimum) { return value + repeat(' ', minimum - realLength(value)); } /* Comparator. */ function comparator(a, b) { return check(a, b, 'line') || check(a, b, 'column') || -1; } /* Compare a single property. */ function check(a, b, property) { return (a[property] || 0) - (b[property] || 0); } function current(file) { /* istanbul ignore if - Previous `vfile` version. */ if (file.filePath) { return file.filePath(); } return file.path; } function plural(value, count) { return count === 1 ? value : value + 's'; } /***/ }), /* 185 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var stripAnsi = __webpack_require__(186); var codePointAt = __webpack_require__(188); var isFullwidthCodePoint = __webpack_require__(189); // https://github.com/nodejs/io.js/blob/cff7300a578be1b10001f2d967aaedc88aee6402/lib/readline.js#L1345 module.exports = function (str) { if (typeof str !== 'string' || str.length === 0) { return 0; } var width = 0; str = stripAnsi(str); for (var i = 0; i < str.length; i++) { var code = codePointAt(str, i); // ignore control characters if (code <= 0x1f || (code >= 0x7f && code <= 0x9f)) { continue; } // surrogates if (code >= 0x10000) { i++; } if (isFullwidthCodePoint(code)) { width += 2; } else { width++; } } return width; }; /***/ }), /* 186 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var ansiRegex = __webpack_require__(187)(); module.exports = function (str) { return typeof str === 'string' ? str.replace(ansiRegex, '') : str; }; /***/ }), /* 187 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = function () { return /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-PRZcf-nqry=><]/g; }; /***/ }), /* 188 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /* eslint-disable babel/new-cap, xo/throw-new-error */ module.exports = function (str, pos) { if (str === null || str === undefined) { throw TypeError(); } str = String(str); var size = str.length; var i = pos ? Number(pos) : 0; if (Number.isNaN(i)) { i = 0; } if (i < 0 || i >= size) { return undefined; } var first = str.charCodeAt(i); if (first >= 0xD800 && first <= 0xDBFF && size > i + 1) { var second = str.charCodeAt(i + 1); if (second >= 0xDC00 && second <= 0xDFFF) { return ((first - 0xD800) * 0x400) + second - 0xDC00 + 0x10000; } } return first; }; /***/ }), /* 189 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var numberIsNan = __webpack_require__(190); module.exports = function (x) { if (numberIsNan(x)) { return false; } // https://github.com/nodejs/io.js/blob/cff7300a578be1b10001f2d967aaedc88aee6402/lib/readline.js#L1369 // code points are derived from: // http://www.unix.org/Public/UNIDATA/EastAsianWidth.txt if (x >= 0x1100 && ( x <= 0x115f || // Hangul Jamo 0x2329 === x || // LEFT-POINTING ANGLE BRACKET 0x232a === x || // RIGHT-POINTING ANGLE BRACKET // CJK Radicals Supplement .. Enclosed CJK Letters and Months (0x2e80 <= x && x <= 0x3247 && x !== 0x303f) || // Enclosed CJK Letters and Months .. CJK Unified Ideographs Extension A 0x3250 <= x && x <= 0x4dbf || // CJK Unified Ideographs .. Yi Radicals 0x4e00 <= x && x <= 0xa4c6 || // Hangul Jamo Extended-A 0xa960 <= x && x <= 0xa97c || // Hangul Syllables 0xac00 <= x && x <= 0xd7a3 || // CJK Compatibility Ideographs 0xf900 <= x && x <= 0xfaff || // Vertical Forms 0xfe10 <= x && x <= 0xfe19 || // CJK Compatibility Forms .. Small Form Variants 0xfe30 <= x && x <= 0xfe6b || // Halfwidth and Fullwidth Forms 0xff01 <= x && x <= 0xff60 || 0xffe0 <= x && x <= 0xffe6 || // Kana Supplement 0x1b000 <= x && x <= 0x1b001 || // Enclosed Ideographic Supplement 0x1f200 <= x && x <= 0x1f251 || // CJK Unified Ideographs Extension B .. Tertiary Ideographic Plane 0x20000 <= x && x <= 0x3fffd)) { return true; } return false; } /***/ }), /* 190 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = Number.isNaN || function (x) { return x !== x; }; /***/ }), /* 191 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var table = __webpack_require__(192) var camelcase = __webpack_require__(193) var minimist = __webpack_require__(56) var json5 = __webpack_require__(194) var fault = __webpack_require__(34) var schema = __webpack_require__(198) module.exports = options /* Schema for `minimist`. */ var minischema = { unknown: handleUnknownArgument, default: {}, alias: {}, string: [], boolean: [] } schema.forEach(addEach) /* Parse CLI options. */ function options(flags, configuration) { var extension = configuration.extensions[0] var name = configuration.name var config = toCamelCase(minimist(flags, minischema)) var help var ext var report schema.forEach(function(option) { if (option.type === 'string' && config[option.long] === '') { throw fault('Missing value:%s', inspect(option).join(' ')) } }) ext = extensions(config.ext) report = reporter(config.report) help = [ inspectAll(schema), '', 'Examples:', '', ' # Process `input.' + extension + '`', ' $ ' + name + ' input.' + extension + ' -o output.' + extension, '', ' # Pipe', ' $ ' + name + ' < input.' + extension + ' > output.' + extension, '', ' # Rewrite all applicable files', ' $ ' + name + ' . -o' ].join('\n') return { helpMessage: help, /* “hidden” feature, makes testing easier. */ cwd: configuration.cwd, processor: configuration.processor, help: config.help, version: config.version, files: config._, watch: config.watch, extensions: ext.length ? ext : configuration.extensions, output: config.output, out: config.stdout, tree: config.tree, treeIn: config.treeIn, treeOut: config.treeOut, inspect: config.inspect, rcName: configuration.rcName, packageField: configuration.packageField, rcPath: config.rcPath, detectConfig: config.config, settings: settings(config.setting), ignoreName: configuration.ignoreName, ignorePath: config.ignorePath, detectIgnore: config.ignore, pluginPrefix: configuration.pluginPrefix, plugins: plugins(config.use), reporter: report[0], reporterOptions: report[1], color: config.color, silent: config.silent, quiet: config.quiet, frail: config.frail } } function addEach(option) { var value = option.default minischema.default[option.long] = value === undefined ? null : value if (option.type in minischema) { minischema[option.type].push(option.long) } if (option.short) { minischema.alias[option.short] = option.long } } /* Parse `extensions`. */ function extensions(value) { return flatten(normalize(value).map(splitList)) } /* Parse `plugins`. */ function plugins(value) { var result = {} normalize(value) .map(splitOptions) .forEach(function(value) { result[value[0]] = value[1] ? parseConfig(value[1], {}) : null }) return result } /* Parse `reporter`: only one is accepted. */ function reporter(value) { var all = normalize(value) .map(splitOptions) .map(function(value) { return [value[0], value[1] ? parseConfig(value[1], {}) : null] }) return all[all.length - 1] || [] } /* Parse `settings`. */ function settings(value) { var cache = {} normalize(value).forEach(function(value) { parseConfig(value, cache) }) return cache } /* Parse configuration. */ function parseConfig(flags, cache) { var flag var message try { flags = toCamelCase(parseJSON(flags)) } catch (err) { /* Fix position */ message = err.message.replace(/at(?= position)/, 'around') throw fault('Cannot parse `%s` as JSON: %s', flags, message) } for (flag in flags) { cache[flag] = flags[flag] } return cache } /* Handle an unknown flag. */ function handleUnknownArgument(flag) { /* Glob. */ if (flag.charAt(0) !== '-') { return } /* Long options. Always unknown. */ if (flag.charAt(1) === '-') { throw fault('Unknown option `%s`, expected:\n%s', flag, inspectAll(schema)) } /* Short options. Can be grouped. */ flag .slice(1) .split('') .forEach(each) function each(key) { var length = schema.length var index = -1 var option while (++index < length) { option = schema[index] if (option.short === key) { return } } throw fault( 'Unknown short option `-%s`, expected:\n%s', key, inspectAll(schema.filter(short)) ) } function short(option) { return option.short } } /* Inspect all `options`. */ function inspectAll(options) { return table(options.map(inspect)) } /* Inspect one `option`. */ function inspect(option) { var description = option.description var long = option.long if (option.default === true || option.truelike) { description += ' (on by default)' long = '[no-]' + long } return [ '', option.short ? '-' + option.short : '', '--' + long + (option.value ? ' ' + option.value : ''), description ] } /* Normalize `value`. */ function normalize(value) { if (!value) { return [] } if (typeof value === 'string') { return [value] } return flatten(value.map(normalize)) } /* Flatten `values`. */ function flatten(values) { return [].concat.apply([], values) } function splitOptions(value) { return value.split('=') } function splitList(value) { return value.split(',') } /* Transform the keys on an object to camel-case, * recursivly. */ function toCamelCase(object) { var result = {} var value var key for (key in object) { value = object[key] if (value && typeof value === 'object' && !('length' in value)) { value = toCamelCase(value) } result[camelcase(key)] = value } return result } /* Parse a (lazy?) JSON config. */ function parseJSON(value) { return json5.parse('{' + value + '}') } /***/ }), /* 192 */ /***/ (function(module, exports) { module.exports = function (rows_, opts) { if (!opts) opts = {}; var hsep = opts.hsep === undefined ? ' ' : opts.hsep; var align = opts.align || []; var stringLength = opts.stringLength || function (s) { return String(s).length; } ; var dotsizes = reduce(rows_, function (acc, row) { forEach(row, function (c, ix) { var n = dotindex(c); if (!acc[ix] || n > acc[ix]) acc[ix] = n; }); return acc; }, []); var rows = map(rows_, function (row) { return map(row, function (c_, ix) { var c = String(c_); if (align[ix] === '.') { var index = dotindex(c); var size = dotsizes[ix] + (/\./.test(c) ? 1 : 2) - (stringLength(c) - index) ; return c + Array(size).join(' '); } else return c; }); }); var sizes = reduce(rows, function (acc, row) { forEach(row, function (c, ix) { var n = stringLength(c); if (!acc[ix] || n > acc[ix]) acc[ix] = n; }); return acc; }, []); return map(rows, function (row) { return map(row, function (c, ix) { var n = (sizes[ix] - stringLength(c)) || 0; var s = Array(Math.max(n + 1, 1)).join(' '); if (align[ix] === 'r' || align[ix] === '.') { return s + c; } if (align[ix] === 'c') { return Array(Math.ceil(n / 2 + 1)).join(' ') + c + Array(Math.floor(n / 2 + 1)).join(' ') ; } return c + s; }).join(hsep).replace(/\s+$/, ''); }).join('\n'); }; function dotindex (c) { var m = /\.[^.]*$/.exec(c); return m ? m.index + 1 : c.length; } function reduce (xs, f, init) { if (xs.reduce) return xs.reduce(f, init); var i = 0; var acc = arguments.length >= 3 ? init : xs[i++]; for (; i < xs.length; i++) { f(acc, xs[i], i); } return acc; } function forEach (xs, f) { if (xs.forEach) return xs.forEach(f); for (var i = 0; i < xs.length; i++) { f.call(xs, xs[i], i); } } function map (xs, f) { if (xs.map) return xs.map(f); var res = []; for (var i = 0; i < xs.length; i++) { res.push(f.call(xs, xs[i], i)); } return res; } /***/ }), /* 193 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; const preserveCamelCase = input => { let isLastCharLower = false; let isLastCharUpper = false; let isLastLastCharUpper = false; for (let i = 0; i < input.length; i++) { const c = input[i]; if (isLastCharLower && /[a-zA-Z]/.test(c) && c.toUpperCase() === c) { input = input.slice(0, i) + '-' + input.slice(i); isLastCharLower = false; isLastLastCharUpper = isLastCharUpper; isLastCharUpper = true; i++; } else if (isLastCharUpper && isLastLastCharUpper && /[a-zA-Z]/.test(c) && c.toLowerCase() === c) { input = input.slice(0, i - 1) + '-' + input.slice(i - 1); isLastLastCharUpper = isLastCharUpper; isLastCharUpper = false; isLastCharLower = true; } else { isLastCharLower = c.toLowerCase() === c; isLastLastCharUpper = isLastCharUpper; isLastCharUpper = c.toUpperCase() === c; } } return input; }; module.exports = (input, options) => { options = Object.assign({ pascalCase: false }, options); const postProcess = x => options.pascalCase ? x.charAt(0).toUpperCase() + x.slice(1) : x; if (Array.isArray(input)) { input = input.map(x => x.trim()) .filter(x => x.length) .join('-'); } else { input = input.trim(); } if (input.length === 0) { return ''; } if (input.length === 1) { return options.pascalCase ? input.toUpperCase() : input.toLowerCase(); } if (/^[a-z\d]+$/.test(input)) { return postProcess(input); } const hasUpperCase = input !== input.toLowerCase(); if (hasUpperCase) { input = preserveCamelCase(input); } input = input .replace(/^[_.\- ]+/, '') .toLowerCase() .replace(/[_.\- ]+(\w|$)/g, (m, p1) => p1.toUpperCase()); return postProcess(input); }; /***/ }), /* 194 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports,'__esModule',{value:true});var _parse=__webpack_require__(195);var _parse2=_interopRequireDefault(_parse);var _stringify=__webpack_require__(197);var _stringify2=_interopRequireDefault(_stringify);function _interopRequireDefault(obj){return obj&&obj.__esModule?obj:{default:obj}}exports.default={parse:_parse2.default,stringify:_stringify2.default};module.exports=exports['default']; /***/ }), /* 195 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports,'__esModule',{value:true});var _typeof=typeof Symbol==='function'&&typeof Symbol.iterator==='symbol'?function(obj){return typeof obj}:function(obj){return obj&&typeof Symbol==='function'&&obj.constructor===Symbol&&obj!==Symbol.prototype?'symbol':typeof obj};exports.default=parse;var _util=__webpack_require__(74);var util=_interopRequireWildcard(_util);function _interopRequireWildcard(obj){if(obj&&obj.__esModule){return obj}else{var newObj={};if(obj!=null){for(var key in obj){if(Object.prototype.hasOwnProperty.call(obj,key))newObj[key]=obj[key]}}newObj.default=obj;return newObj}}var source=void 0;var parseState=void 0;var stack=void 0;var pos=void 0;var line=void 0;var column=void 0;var token=void 0;var key=void 0;var root=void 0;function parse(text,reviver){source=String(text);parseState='start';stack=[];pos=0;line=1;column=0;token=undefined;key=undefined;root=undefined;do{token=lex();parseStates[parseState]()}while(token.type!=='eof');if(typeof reviver==='function'){return internalize({'':root},'',reviver)}return root}function internalize(holder,name,reviver){var value=holder[name];if(value!=null&&(typeof value==='undefined'?'undefined':_typeof(value))==='object'){for(var _key in value){var replacement=internalize(value,_key,reviver);if(replacement===undefined){delete value[_key]}else{value[_key]=replacement}}}return reviver.call(holder,name,value)}var lexState=void 0;var buffer=void 0;var doubleQuote=void 0;var _sign=void 0;var c=void 0;function lex(){lexState='default';buffer='';doubleQuote=false;_sign=1;for(;;){c=peek();var _token=lexStates[lexState]();if(_token){return _token}}}function peek(){if(source[pos]){return String.fromCodePoint(source.codePointAt(pos))}}function read(){var c=peek();if(c==='\n'){line++;column=0}else if(c){column+=c.length}else{column++}if(c){pos+=c.length}return c}var lexStates={default:function _default(){switch(c){case'\t':case'\x0B':case'\f':case' ':case'\xA0':case'\uFEFF':case'\n':case'\r':case'\u2028':case'\u2029':read();return;case'/':read();lexState='comment';return;case undefined:read();return newToken('eof');}if(util.isSpaceSeparator(c)){read();return}return lexStates[parseState]()},comment:function comment(){switch(c){case'*':read();lexState='multiLineComment';return;case'/':read();lexState='singleLineComment';return;}throw invalidChar(read())},multiLineComment:function multiLineComment(){switch(c){case'*':read();lexState='multiLineCommentAsterisk';return;case undefined:throw invalidChar(read());}read()},multiLineCommentAsterisk:function multiLineCommentAsterisk(){switch(c){case'*':read();return;case'/':read();lexState='default';return;case undefined:throw invalidChar(read());}read();lexState='multiLineComment'},singleLineComment:function singleLineComment(){switch(c){case'\n':case'\r':case'\u2028':case'\u2029':read();lexState='default';return;case undefined:read();return newToken('eof');}read()},value:function value(){switch(c){case'{':case'[':return newToken('punctuator',read());case'n':read();literal('ull');return newToken('null',null);case't':read();literal('rue');return newToken('boolean',true);case'f':read();literal('alse');return newToken('boolean',false);case'-':case'+':if(read()==='-'){_sign=-1}lexState='sign';return;case'.':buffer=read();lexState='decimalPointLeading';return;case'0':buffer=read();lexState='zero';return;case'1':case'2':case'3':case'4':case'5':case'6':case'7':case'8':case'9':buffer=read();lexState='decimalInteger';return;case'I':read();literal('nfinity');return newToken('numeric',Infinity);case'N':read();literal('aN');return newToken('numeric',NaN);case'"':case'\'':doubleQuote=read()==='"';buffer='';lexState='string';return;}throw invalidChar(read())},identifierNameStartEscape:function identifierNameStartEscape(){if(c!=='u'){throw invalidChar(read())}read();var u=unicodeEscape();switch(u){case'$':case'_':break;default:if(!util.isIdStartChar(u)){throw invalidIdentifier()}break;}buffer+=u;lexState='identifierName'},identifierName:function identifierName(){switch(c){case'$':case'_':case'\u200C':case'\u200D':buffer+=read();return;case'\\':read();lexState='identifierNameEscape';return;}if(util.isIdContinueChar(c)){buffer+=read();return}return newToken('identifier',buffer)},identifierNameEscape:function identifierNameEscape(){if(c!=='u'){throw invalidChar(read())}read();var u=unicodeEscape();switch(u){case'$':case'_':case'\u200C':case'\u200D':break;default:if(!util.isIdContinueChar(u)){throw invalidIdentifier()}break;}buffer+=u;lexState='identifierName'},sign:function sign(){switch(c){case'.':buffer=read();lexState='decimalPointLeading';return;case'0':buffer=read();lexState='zero';return;case'1':case'2':case'3':case'4':case'5':case'6':case'7':case'8':case'9':buffer=read();lexState='decimalInteger';return;case'I':read();literal('nfinity');return newToken('numeric',_sign*Infinity);case'N':read();literal('aN');return newToken('numeric',NaN);}throw invalidChar(read())},zero:function zero(){switch(c){case'.':buffer+=read();lexState='decimalPoint';return;case'e':case'E':buffer+=read();lexState='decimalExponent';return;case'x':case'X':buffer+=read();lexState='hexadecimal';return;}return newToken('numeric',_sign*0)},decimalInteger:function decimalInteger(){switch(c){case'.':buffer+=read();lexState='decimalPoint';return;case'e':case'E':buffer+=read();lexState='decimalExponent';return;}if(util.isDigit(c)){buffer+=read();return}return newToken('numeric',_sign*Number(buffer))},decimalPointLeading:function decimalPointLeading(){if(util.isDigit(c)){buffer+=read();lexState='decimalFraction';return}throw invalidChar(read())},decimalPoint:function decimalPoint(){switch(c){case'e':case'E':buffer+=read();lexState='decimalExponent';return;}if(util.isDigit(c)){buffer+=read();lexState='decimalFraction';return}return newToken('numeric',_sign*Number(buffer))},decimalFraction:function decimalFraction(){switch(c){case'e':case'E':buffer+=read();lexState='decimalExponent';return;}if(util.isDigit(c)){buffer+=read();return}return newToken('numeric',_sign*Number(buffer))},decimalExponent:function decimalExponent(){switch(c){case'+':case'-':buffer+=read();lexState='decimalExponentSign';return;}if(util.isDigit(c)){buffer+=read();lexState='decimalExponentInteger';return}throw invalidChar(read())},decimalExponentSign:function decimalExponentSign(){if(util.isDigit(c)){buffer+=read();lexState='decimalExponentInteger';return}throw invalidChar(read())},decimalExponentInteger:function decimalExponentInteger(){if(util.isDigit(c)){buffer+=read();return}return newToken('numeric',_sign*Number(buffer))},hexadecimal:function hexadecimal(){if(util.isHexDigit(c)){buffer+=read();lexState='hexadecimalInteger';return}throw invalidChar(read())},hexadecimalInteger:function hexadecimalInteger(){if(util.isHexDigit(c)){buffer+=read();return}return newToken('numeric',_sign*Number(buffer))},string:function string(){switch(c){case'\\':read();buffer+=escape();return;case'"':if(doubleQuote){read();return newToken('string',buffer)}buffer+=read();return;case'\'':if(!doubleQuote){read();return newToken('string',buffer)}buffer+=read();return;case'\n':case'\r':throw invalidChar(read());case'\u2028':case'\u2029':separatorChar(c);break;case undefined:throw invalidChar(read());}buffer+=read()},start:function start(){switch(c){case'{':case'[':return newToken('punctuator',read());}lexState='value'},beforePropertyName:function beforePropertyName(){switch(c){case'$':case'_':buffer=read();lexState='identifierName';return;case'\\':read();lexState='identifierNameStartEscape';return;case'}':return newToken('punctuator',read());case'"':case'\'':doubleQuote=read()==='"';lexState='string';return;}if(util.isIdStartChar(c)){buffer+=read();lexState='identifierName';return}throw invalidChar(read())},afterPropertyName:function afterPropertyName(){if(c===':'){return newToken('punctuator',read())}throw invalidChar(read())},beforePropertyValue:function beforePropertyValue(){lexState='value'},afterPropertyValue:function afterPropertyValue(){switch(c){case',':case'}':return newToken('punctuator',read());}throw invalidChar(read())},beforeArrayValue:function beforeArrayValue(){if(c===']'){return newToken('punctuator',read())}lexState='value'},afterArrayValue:function afterArrayValue(){switch(c){case',':case']':return newToken('punctuator',read());}throw invalidChar(read())},end:function end(){throw invalidChar(read())}};function newToken(type,value){return{type:type,value:value,line:line,column:column}}function literal(s){var _iteratorNormalCompletion=true;var _didIteratorError=false;var _iteratorError=undefined;try{for(var _iterator=s[Symbol.iterator](),_step;!(_iteratorNormalCompletion=(_step=_iterator.next()).done);_iteratorNormalCompletion=true){var _c=_step.value;var p=peek();if(p!==_c){throw invalidChar(read())}read()}}catch(err){_didIteratorError=true;_iteratorError=err}finally{try{if(!_iteratorNormalCompletion&&_iterator.return){_iterator.return()}}finally{if(_didIteratorError){throw _iteratorError}}}}function escape(){var c=peek();switch(c){case'b':read();return'\b';case'f':read();return'\f';case'n':read();return'\n';case'r':read();return'\r';case't':read();return'\t';case'v':read();return'\x0B';case'0':read();if(util.isDigit(peek())){throw invalidChar(read())}return'\0';case'x':read();return hexEscape();case'u':read();return unicodeEscape();case'\n':case'\u2028':case'\u2029':read();return'';case'\r':read();if(peek()==='\n'){read()}return'';case'1':case'2':case'3':case'4':case'5':case'6':case'7':case'8':case'9':throw invalidChar(read());case undefined:throw invalidChar(read());}return read()}function hexEscape(){var buffer='';var c=peek();if(!util.isHexDigit(c)){throw invalidChar(read())}buffer+=read();c=peek();if(!util.isHexDigit(c)){throw invalidChar(read())}buffer+=read();return String.fromCodePoint(parseInt(buffer,16))}function unicodeEscape(){var buffer='';var count=4;while(count-->0){var _c2=peek();if(!util.isHexDigit(_c2)){throw invalidChar(read())}buffer+=read()}return String.fromCodePoint(parseInt(buffer,16))}var parseStates={start:function start(){if(token.type==='eof'){throw invalidEOF()}push()},beforePropertyName:function beforePropertyName(){switch(token.type){case'identifier':case'string':key=token.value;parseState='afterPropertyName';return;case'punctuator':pop();return;case'eof':throw invalidEOF();}},afterPropertyName:function afterPropertyName(){if(token.type==='eof'){throw invalidEOF()}parseState='beforePropertyValue'},beforePropertyValue:function beforePropertyValue(){if(token.type==='eof'){throw invalidEOF()}push()},beforeArrayValue:function beforeArrayValue(){if(token.type==='eof'){throw invalidEOF()}if(token.type==='punctuator'&&token.value===']'){pop();return}push()},afterPropertyValue:function afterPropertyValue(){if(token.type==='eof'){throw invalidEOF()}switch(token.value){case',':parseState='beforePropertyName';return;case'}':pop();}},afterArrayValue:function afterArrayValue(){if(token.type==='eof'){throw invalidEOF()}switch(token.value){case',':parseState='beforeArrayValue';return;case']':pop();}},end:function end(){}};function push(){var value=void 0;switch(token.type){case'punctuator':switch(token.value){case'{':value={};break;case'[':value=[];break;}break;case'null':case'boolean':case'numeric':case'string':value=token.value;break;}if(root===undefined){root=value}else{var parent=stack[stack.length-1];if(Array.isArray(parent)){parent.push(value)}else{parent[key]=value}}if(value!==null&&(typeof value==='undefined'?'undefined':_typeof(value))==='object'){stack.push(value);if(Array.isArray(value)){parseState='beforeArrayValue'}else{parseState='beforePropertyName'}}else{var current=stack[stack.length-1];if(current==null){parseState='end'}else if(Array.isArray(current)){parseState='afterArrayValue'}else{parseState='afterPropertyValue'}}}function pop(){stack.pop();var current=stack[stack.length-1];if(current==null){parseState='end'}else if(Array.isArray(current)){parseState='afterArrayValue'}else{parseState='afterPropertyValue'}}function invalidChar(c){if(c===undefined){return syntaxError('JSON5: invalid end of input at '+line+':'+column)}return syntaxError('JSON5: invalid character \''+formatChar(c)+'\' at '+line+':'+column)}function invalidEOF(){return syntaxError('JSON5: invalid end of input at '+line+':'+column)}function invalidIdentifier(){column-=5;return syntaxError('JSON5: invalid identifier character at '+line+':'+column)}function separatorChar(c){console.warn('JSON5: \''+c+'\' is not valid ECMAScript; consider escaping')}function formatChar(c){var replacements={'\'':'\\\'','"':'\\"','\\':'\\\\','\b':'\\b','\f':'\\f','\n':'\\n','\r':'\\r','\t':'\\t','\x0B':'\\v','\0':'\\0','\u2028':'\\u2028','\u2029':'\\u2029'};if(replacements[c]){return replacements[c]}if(c<' '){var hexString=c.charCodeAt(0).toString(16);return'\\x'+('00'+hexString).substring(hexString.length)}return c}function syntaxError(message){var err=new SyntaxError(message);err.lineNumber=line;err.columnNumber=column;return err}module.exports=exports['default']; /***/ }), /* 196 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports,"__esModule",{value:true});var Space_Separator=exports.Space_Separator=/[\u1680\u2000-\u200A\u202F\u205F\u3000]/;var ID_Start=exports.ID_Start=/[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B4\u08B6-\u08BD\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC00-\uDC34\uDC47-\uDC4A\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDF00-\uDF19]|\uD806[\uDCA0-\uDCDF\uDCFF\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC2E\uDC40\uDC72-\uDC8F]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50\uDF93-\uDF9F\uDFE0]|\uD821[\uDC00-\uDFEC]|\uD822[\uDC00-\uDEF2]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD83A[\uDC00-\uDCC4\uDD00-\uDD43]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1]|\uD87E[\uDC00-\uDE1D]/;var ID_Continue=exports.ID_Continue=/[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0-\u08B4\u08B6-\u08BD\u08D4-\u08E1\u08E3-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0AF9\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C80-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D01-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D54-\u0D57\u0D5F-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19D9\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1C80-\u1C88\u1CD0-\u1CD2\u1CD4-\u1CF6\u1CF8\u1CF9\u1D00-\u1DF5\u1DFB-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u2E2F\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099\u309A\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA8FD\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDDFD\uDE80-\uDE9C\uDEA0-\uDED0\uDEE0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF7A\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00-\uDE03\uDE05\uDE06\uDE0C-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE38-\uDE3A\uDE3F\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE6\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC00-\uDC46\uDC66-\uDC6F\uDC7F-\uDCBA\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD00-\uDD34\uDD36-\uDD3F\uDD50-\uDD73\uDD76\uDD80-\uDDC4\uDDCA-\uDDCC\uDDD0-\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE37\uDE3E\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEEA\uDEF0-\uDEF9\uDF00-\uDF03\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3C-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF50\uDF57\uDF5D-\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC00-\uDC4A\uDC50-\uDC59\uDC80-\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDB5\uDDB8-\uDDC0\uDDD8-\uDDDD\uDE00-\uDE40\uDE44\uDE50-\uDE59\uDE80-\uDEB7\uDEC0-\uDEC9\uDF00-\uDF19\uDF1D-\uDF2B\uDF30-\uDF39]|\uD806[\uDCA0-\uDCE9\uDCFF\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC36\uDC38-\uDC40\uDC50-\uDC59\uDC72-\uDC8F\uDC92-\uDCA7\uDCA9-\uDCB6]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDED0-\uDEED\uDEF0-\uDEF4\uDF00-\uDF36\uDF40-\uDF43\uDF50-\uDF59\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50-\uDF7E\uDF8F-\uDF9F\uDFE0]|\uD821[\uDC00-\uDFEC]|\uD822[\uDC00-\uDEF2]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD838[\uDC00-\uDC06\uDC08-\uDC18\uDC1B-\uDC21\uDC23\uDC24\uDC26-\uDC2A]|\uD83A[\uDC00-\uDCC4\uDCD0-\uDCD6\uDD00-\uDD4A\uDD50-\uDD59]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1]|\uD87E[\uDC00-\uDE1D]|\uDB40[\uDD00-\uDDEF]/; /***/ }), /* 197 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports,'__esModule',{value:true});var _typeof=typeof Symbol==='function'&&typeof Symbol.iterator==='symbol'?function(obj){return typeof obj}:function(obj){return obj&&typeof Symbol==='function'&&obj.constructor===Symbol&&obj!==Symbol.prototype?'symbol':typeof obj};exports.default=stringify;var _util=__webpack_require__(74);var util=_interopRequireWildcard(_util);function _interopRequireWildcard(obj){if(obj&&obj.__esModule){return obj}else{var newObj={};if(obj!=null){for(var key in obj){if(Object.prototype.hasOwnProperty.call(obj,key))newObj[key]=obj[key]}}newObj.default=obj;return newObj}}function stringify(value,replacer,space){var stack=[];var indent='';var propertyList=void 0;var replacerFunc=void 0;var gap='';var quote=void 0;if(replacer!=null&&(typeof replacer==='undefined'?'undefined':_typeof(replacer))==='object'&&!Array.isArray(replacer)){space=replacer.space;quote=replacer.quote;replacer=replacer.replacer}if(typeof replacer==='function'){replacerFunc=replacer}else if(Array.isArray(replacer)){propertyList=[];var _iteratorNormalCompletion=true;var _didIteratorError=false;var _iteratorError=undefined;try{for(var _iterator=replacer[Symbol.iterator](),_step;!(_iteratorNormalCompletion=(_step=_iterator.next()).done);_iteratorNormalCompletion=true){var v=_step.value;var item=void 0;if(typeof v==='string'){item=v}else if(typeof v==='number'||v instanceof String||v instanceof Number){item=String(v)}if(item!==undefined&&propertyList.indexOf(item)<0){propertyList.push(item)}}}catch(err){_didIteratorError=true;_iteratorError=err}finally{try{if(!_iteratorNormalCompletion&&_iterator.return){_iterator.return()}}finally{if(_didIteratorError){throw _iteratorError}}}}if(space instanceof Number){space=Number(space)}else if(space instanceof String){space=String(space)}if(typeof space==='number'){if(space>0){space=Math.min(10,Math.floor(space));gap=' '.substr(0,space)}}else if(typeof space==='string'){gap=space.substr(0,10)}return serializeProperty('',{'':value});function serializeProperty(key,holder){var value=holder[key];if(value!=null){if(typeof value.toJSON5==='function'){value=value.toJSON5(key)}else if(typeof value.toJSON==='function'){value=value.toJSON(key)}}if(replacerFunc){value=replacerFunc.call(holder,key,value)}if(value instanceof Number){value=Number(value)}else if(value instanceof String){value=String(value)}else if(value instanceof Boolean){value=value.valueOf()}switch(value){case null:return'null';case true:return'true';case false:return'false';}if(typeof value==='string'){return quoteString(value,false)}if(typeof value==='number'){return String(value)}if((typeof value==='undefined'?'undefined':_typeof(value))==='object'){return Array.isArray(value)?serializeArray(value):serializeObject(value)}return undefined}function quoteString(value){var quotes={'\'':0.1,'"':0.2};var replacements={'\'':'\\\'','"':'\\"','\\':'\\\\','\b':'\\b','\f':'\\f','\n':'\\n','\r':'\\r','\t':'\\t','\x0B':'\\v','\0':'\\0','\u2028':'\\u2028','\u2029':'\\u2029'};var product='';var _iteratorNormalCompletion2=true;var _didIteratorError2=false;var _iteratorError2=undefined;try{for(var _iterator2=value[Symbol.iterator](),_step2;!(_iteratorNormalCompletion2=(_step2=_iterator2.next()).done);_iteratorNormalCompletion2=true){var c=_step2.value;switch(c){case'\'':case'"':quotes[c]++;product+=c;continue;}if(replacements[c]){product+=replacements[c];continue}if(c<' '){var hexString=c.charCodeAt(0).toString(16);product+='\\x'+('00'+hexString).substring(hexString.length);continue}product+=c}}catch(err){_didIteratorError2=true;_iteratorError2=err}finally{try{if(!_iteratorNormalCompletion2&&_iterator2.return){_iterator2.return()}}finally{if(_didIteratorError2){throw _iteratorError2}}}var quoteChar=quote||Object.keys(quotes).reduce(function(a,b){return quotes[a]=0){throw TypeError('Converting circular structure to JSON5')}stack.push(value);var stepback=indent;indent=indent+gap;var keys=propertyList||Object.keys(value);var partial=[];var _iteratorNormalCompletion3=true;var _didIteratorError3=false;var _iteratorError3=undefined;try{for(var _iterator3=keys[Symbol.iterator](),_step3;!(_iteratorNormalCompletion3=(_step3=_iterator3.next()).done);_iteratorNormalCompletion3=true){var key=_step3.value;var propertyString=serializeProperty(key,value);if(propertyString!==undefined){var member=serializeKey(key)+':';if(gap!==''){member+=' '}member+=propertyString;partial.push(member)}}}catch(err){_didIteratorError3=true;_iteratorError3=err}finally{try{if(!_iteratorNormalCompletion3&&_iterator3.return){_iterator3.return()}}finally{if(_didIteratorError3){throw _iteratorError3}}}var final=void 0;if(partial.length===0){final='{}'}else{var properties=void 0;if(gap===''){properties=partial.join(',');final='{'+properties+'}'}else{var separator=',\n'+indent;properties=partial.join(separator);final='{\n'+indent+properties+',\n'+stepback+'}'}}stack.pop();indent=stepback;return final}function serializeKey(key){if(key.length===0){return quoteString(key,true)}var firstChar=String.fromCodePoint(key.codePointAt(0));if(!util.isIdStartChar(firstChar)){return quoteString(key,true)}for(var i=firstChar.length;i=0){throw TypeError('Converting circular structure to JSON5')}stack.push(value);var stepback=indent;indent=indent+gap;var partial=[];for(var i=0;i"},{"long":"ignore-path","description":"specify ignore file","short":"i","type":"string","value":""},{"long":"setting","description":"specify settings","short":"s","type":"string","value":""},{"long":"ext","description":"specify extensions","short":"e","type":"string","value":""},{"long":"use","description":"use plugins","short":"u","type":"string","value":""},{"long":"watch","description":"watch for changes and reprocess","short":"w","type":"boolean","default":false},{"long":"quiet","description":"output only warnings and errors","short":"q","type":"boolean","default":false},{"long":"silent","description":"output only errors","short":"S","type":"boolean","default":false},{"long":"frail","description":"exit with 1 on warnings","short":"f","type":"boolean","default":false},{"long":"tree","description":"specify input and output as syntax tree","short":"t","type":"boolean","default":false},{"long":"report","description":"specify reporter","type":"string","value":""},{"long":"file-path","description":"specify path to process as","type":"string","value":""},{"long":"tree-in","description":"specify input as syntax tree","type":"boolean"},{"long":"tree-out","description":"output syntax tree","type":"boolean"},{"long":"inspect","description":"output formatted syntax tree","type":"boolean"},{"long":"stdout","description":"specify writing to stdout","type":"boolean","truelike":true},{"long":"color","description":"specify color in report","type":"boolean","default":true},{"long":"config","description":"search for configuration files","type":"boolean","default":true},{"long":"ignore","description":"search for ignore files","type":"boolean","default":true}]; /***/ }), /* 199 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = __webpack_require__(200); /***/ }), /* 200 */ /***/ (function(module) { module.exports = ["md","markdown","mdown","mkdn","mkd","mdwn","mkdown","ron"]; /***/ }), /* 201 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var unified = __webpack_require__(202) var parse = __webpack_require__(209) var stringify = __webpack_require__(258) module.exports = unified() .use(parse) .use(stringify) .freeze() /***/ }), /* 202 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var extend = __webpack_require__(203) var bail = __webpack_require__(204) var vfile = __webpack_require__(205) var trough = __webpack_require__(24) var string = __webpack_require__(17) var plain = __webpack_require__(208) // Expose a frozen processor. module.exports = unified().freeze() var slice = [].slice var own = {}.hasOwnProperty // Process pipeline. var pipeline = trough() .use(pipelineParse) .use(pipelineRun) .use(pipelineStringify) function pipelineParse(p, ctx) { ctx.tree = p.parse(ctx.file) } function pipelineRun(p, ctx, next) { p.run(ctx.tree, ctx.file, done) function done(err, tree, file) { if (err) { next(err) } else { ctx.tree = tree ctx.file = file next() } } } function pipelineStringify(p, ctx) { ctx.file.contents = p.stringify(ctx.tree, ctx.file) } // Function to create the first processor. function unified() { var attachers = [] var transformers = trough() var namespace = {} var frozen = false var freezeIndex = -1 // Data management. processor.data = data // Lock. processor.freeze = freeze // Plugins. processor.attachers = attachers processor.use = use // API. processor.parse = parse processor.stringify = stringify processor.run = run processor.runSync = runSync processor.process = process processor.processSync = processSync // Expose. return processor // Create a new processor based on the processor in the current scope. function processor() { var destination = unified() var length = attachers.length var index = -1 while (++index < length) { destination.use.apply(null, attachers[index]) } destination.data(extend(true, {}, namespace)) return destination } // Freeze: used to signal a processor that has finished configuration. // // For example, take unified itself. It’s frozen. Plugins should not be // added to it. Rather, it should be extended, by invoking it, before // modifying it. // // In essence, always invoke this when exporting a processor. function freeze() { var values var plugin var options var transformer if (frozen) { return processor } while (++freezeIndex < attachers.length) { values = attachers[freezeIndex] plugin = values[0] options = values[1] transformer = null if (options === false) { continue } if (options === true) { values[1] = undefined } transformer = plugin.apply(processor, values.slice(1)) if (typeof transformer === 'function') { transformers.use(transformer) } } frozen = true freezeIndex = Infinity return processor } // Data management. Getter / setter for processor-specific informtion. function data(key, value) { if (string(key)) { // Set `key`. if (arguments.length === 2) { assertUnfrozen('data', frozen) namespace[key] = value return processor } // Get `key`. return (own.call(namespace, key) && namespace[key]) || null } // Set space. if (key) { assertUnfrozen('data', frozen) namespace = key return processor } // Get space. return namespace } // Plugin management. // // Pass it: // * an attacher and options, // * a preset, // * a list of presets, attachers, and arguments (list of attachers and // options). function use(value) { var settings assertUnfrozen('use', frozen) if (value === null || value === undefined) { // Empty. } else if (typeof value === 'function') { addPlugin.apply(null, arguments) } else if (typeof value === 'object') { if ('length' in value) { addList(value) } else { addPreset(value) } } else { throw new Error('Expected usable value, not `' + value + '`') } if (settings) { namespace.settings = extend(namespace.settings || {}, settings) } return processor function addPreset(result) { addList(result.plugins) if (result.settings) { settings = extend(settings || {}, result.settings) } } function add(value) { if (typeof value === 'function') { addPlugin(value) } else if (typeof value === 'object') { if ('length' in value) { addPlugin.apply(null, value) } else { addPreset(value) } } else { throw new Error('Expected usable value, not `' + value + '`') } } function addList(plugins) { var length var index if (plugins === null || plugins === undefined) { // Empty. } else if (typeof plugins === 'object' && 'length' in plugins) { length = plugins.length index = -1 while (++index < length) { add(plugins[index]) } } else { throw new Error('Expected a list of plugins, not `' + plugins + '`') } } function addPlugin(plugin, value) { var entry = find(plugin) if (entry) { if (plain(entry[1]) && plain(value)) { value = extend(entry[1], value) } entry[1] = value } else { attachers.push(slice.call(arguments)) } } } function find(plugin) { var length = attachers.length var index = -1 var entry while (++index < length) { entry = attachers[index] if (entry[0] === plugin) { return entry } } } // Parse a file (in string or vfile representation) into a unist node using // the `Parser` on the processor. function parse(doc) { var file = vfile(doc) var Parser freeze() Parser = processor.Parser assertParser('parse', Parser) if (newable(Parser)) { return new Parser(String(file), file).parse() } return Parser(String(file), file) // eslint-disable-line new-cap } // Run transforms on a unist node representation of a file (in string or // vfile representation), async. function run(node, file, cb) { assertNode(node) freeze() if (!cb && typeof file === 'function') { cb = file file = null } if (!cb) { return new Promise(executor) } executor(null, cb) function executor(resolve, reject) { transformers.run(node, vfile(file), done) function done(err, tree, file) { tree = tree || node if (err) { reject(err) } else if (resolve) { resolve(tree) } else { cb(null, tree, file) } } } } // Run transforms on a unist node representation of a file (in string or // vfile representation), sync. function runSync(node, file) { var complete = false var result run(node, file, done) assertDone('runSync', 'run', complete) return result function done(err, tree) { complete = true bail(err) result = tree } } // Stringify a unist node representation of a file (in string or vfile // representation) into a string using the `Compiler` on the processor. function stringify(node, doc) { var file = vfile(doc) var Compiler freeze() Compiler = processor.Compiler assertCompiler('stringify', Compiler) assertNode(node) if (newable(Compiler)) { return new Compiler(node, file).compile() } return Compiler(node, file) // eslint-disable-line new-cap } // Parse a file (in string or vfile representation) into a unist node using // the `Parser` on the processor, then run transforms on that node, and // compile the resulting node using the `Compiler` on the processor, and // store that result on the vfile. function process(doc, cb) { freeze() assertParser('process', processor.Parser) assertCompiler('process', processor.Compiler) if (!cb) { return new Promise(executor) } executor(null, cb) function executor(resolve, reject) { var file = vfile(doc) pipeline.run(processor, {file: file}, done) function done(err) { if (err) { reject(err) } else if (resolve) { resolve(file) } else { cb(null, file) } } } } // Process the given document (in string or vfile representation), sync. function processSync(doc) { var complete = false var file freeze() assertParser('processSync', processor.Parser) assertCompiler('processSync', processor.Compiler) file = vfile(doc) process(file, done) assertDone('processSync', 'process', complete) return file function done(err) { complete = true bail(err) } } } // Check if `func` is a constructor. function newable(value) { return typeof value === 'function' && keys(value.prototype) } // Check if `value` is an object with keys. function keys(value) { var key for (key in value) { return true } return false } // Assert a parser is available. function assertParser(name, Parser) { if (typeof Parser !== 'function') { throw new Error('Cannot `' + name + '` without `Parser`') } } // Assert a compiler is available. function assertCompiler(name, Compiler) { if (typeof Compiler !== 'function') { throw new Error('Cannot `' + name + '` without `Compiler`') } } // Assert the processor is not frozen. function assertUnfrozen(name, frozen) { if (frozen) { throw new Error( 'Cannot invoke `' + name + '` on a frozen processor.\nCreate a new processor first, by invoking it: use `processor()` instead of `processor`.' ) } } // Assert `node` is a unist node. function assertNode(node) { if (!node || !string(node.type)) { throw new Error('Expected node, got `' + node + '`') } } // Assert that `complete` is `true`. function assertDone(name, asyncName, complete) { if (!complete) { throw new Error( '`' + name + '` finished async. Use `' + asyncName + '` instead' ) } } /***/ }), /* 203 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var hasOwn = Object.prototype.hasOwnProperty; var toStr = Object.prototype.toString; var defineProperty = Object.defineProperty; var gOPD = Object.getOwnPropertyDescriptor; var isArray = function isArray(arr) { if (typeof Array.isArray === 'function') { return Array.isArray(arr); } return toStr.call(arr) === '[object Array]'; }; var isPlainObject = function isPlainObject(obj) { if (!obj || toStr.call(obj) !== '[object Object]') { return false; } var hasOwnConstructor = hasOwn.call(obj, 'constructor'); var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf'); // Not own constructor property must be Object if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) { return false; } // Own properties are enumerated firstly, so to speed up, // if last one is own, then all properties are own. var key; for (key in obj) { /**/ } return typeof key === 'undefined' || hasOwn.call(obj, key); }; // If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target var setProperty = function setProperty(target, options) { if (defineProperty && options.name === '__proto__') { defineProperty(target, options.name, { enumerable: true, configurable: true, value: options.newValue, writable: true }); } else { target[options.name] = options.newValue; } }; // Return undefined instead of __proto__ if '__proto__' is not an own property var getProperty = function getProperty(obj, name) { if (name === '__proto__') { if (!hasOwn.call(obj, name)) { return void 0; } else if (gOPD) { // In early versions of node, obj['__proto__'] is buggy when obj has // __proto__ as an own property. Object.getOwnPropertyDescriptor() works. return gOPD(obj, name).value; } } return obj[name]; }; module.exports = function extend() { var options, name, src, copy, copyIsArray, clone; var target = arguments[0]; var i = 1; var length = arguments.length; var deep = false; // Handle a deep copy situation if (typeof target === 'boolean') { deep = target; target = arguments[1] || {}; // skip the boolean and the target i = 2; } if (target == null || (typeof target !== 'object' && typeof target !== 'function')) { target = {}; } for (; i < length; ++i) { options = arguments[i]; // Only deal with non-null/undefined values if (options != null) { // Extend the base object for (name in options) { src = getProperty(target, name); copy = getProperty(options, name); // Prevent never-ending loop if (target !== copy) { // Recurse if we're merging plain objects or arrays if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) { if (copyIsArray) { copyIsArray = false; clone = src && isArray(src) ? src : []; } else { clone = src && isPlainObject(src) ? src : {}; } // Never move original objects, clone them setProperty(target, { name: name, newValue: extend(deep, clone, copy) }); // Don't bring in undefined values } else if (typeof copy !== 'undefined') { setProperty(target, { name: name, newValue: copy }); } } } } } // Return the modified object return target; }; /***/ }), /* 204 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = bail function bail(err) { if (err) { throw err } } /***/ }), /* 205 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var VMessage = __webpack_require__(65) var VFile = __webpack_require__(206) module.exports = VFile var proto = VFile.prototype proto.message = message proto.info = info proto.fail = fail // Slight backwards compatibility. Remove in the future. proto.warn = message // Create a message with `reason` at `position`. When an error is passed in as // `reason`, copies the stack. function message(reason, position, origin) { var filePath = this.path var message = new VMessage(reason, position, origin) if (filePath) { message.name = filePath + ':' + message.name message.file = filePath } message.fatal = false this.messages.push(message) return message } // Fail. Creates a vmessage, associates it with the file, and throws it. function fail() { var message = this.message.apply(this, arguments) message.fatal = true throw message } // Info. Creates a vmessage, associates it with the file, and marks the // fatality as null. function info() { var message = this.message.apply(this, arguments) message.fatal = null return message } /***/ }), /* 206 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var path = __webpack_require__(4) var replace = __webpack_require__(66) var buffer = __webpack_require__(207) module.exports = VFile var own = {}.hasOwnProperty var proto = VFile.prototype proto.toString = toString // Order of setting (least specific to most), we need this because otherwise // `{stem: 'a', path: '~/b.js'}` would throw, as a path is needed before a // stem can be set. var order = ['history', 'path', 'basename', 'stem', 'extname', 'dirname'] // Construct a new file. function VFile(options) { var prop var index var length if (!options) { options = {} } else if (typeof options === 'string' || buffer(options)) { options = {contents: options} } else if ('message' in options && 'messages' in options) { return options } if (!(this instanceof VFile)) { return new VFile(options) } this.data = {} this.messages = [] this.history = [] this.cwd = process.cwd() // Set path related properties in the correct order. index = -1 length = order.length while (++index < length) { prop = order[index] if (own.call(options, prop)) { this[prop] = options[prop] } } // Set non-path related properties. for (prop in options) { if (order.indexOf(prop) === -1) { this[prop] = options[prop] } } } // Access full path (`~/index.min.js`). Object.defineProperty(proto, 'path', { get: function() { return this.history[this.history.length - 1] }, set: function(path) { assertNonEmpty(path, 'path') if (path !== this.path) { this.history.push(path) } } }) // Access parent path (`~`). Object.defineProperty(proto, 'dirname', { get: function() { return typeof this.path === 'string' ? path.dirname(this.path) : undefined }, set: function(dirname) { assertPath(this.path, 'dirname') this.path = path.join(dirname || '', this.basename) } }) // Access basename (`index.min.js`). Object.defineProperty(proto, 'basename', { get: function() { return typeof this.path === 'string' ? path.basename(this.path) : undefined }, set: function(basename) { assertNonEmpty(basename, 'basename') assertPart(basename, 'basename') this.path = path.join(this.dirname || '', basename) } }) // Access extname (`.js`). Object.defineProperty(proto, 'extname', { get: function() { return typeof this.path === 'string' ? path.extname(this.path) : undefined }, set: function(extname) { var ext = extname || '' assertPart(ext, 'extname') assertPath(this.path, 'extname') if (ext) { if (ext.charAt(0) !== '.') { throw new Error('`extname` must start with `.`') } if (ext.indexOf('.', 1) !== -1) { throw new Error('`extname` cannot contain multiple dots') } } this.path = replace(this.path, ext) } }) // Access stem (`index.min`). Object.defineProperty(proto, 'stem', { get: function() { return typeof this.path === 'string' ? path.basename(this.path, this.extname) : undefined }, set: function(stem) { assertNonEmpty(stem, 'stem') assertPart(stem, 'stem') this.path = path.join(this.dirname || '', stem + (this.extname || '')) } }) // Get the value of the file. function toString(encoding) { var value = this.contents || '' return buffer(value) ? value.toString(encoding) : String(value) } // Assert that `part` is not a path (i.e., does not contain `path.sep`). function assertPart(part, name) { if (part.indexOf(path.sep) !== -1) { throw new Error( '`' + name + '` cannot be a path: did not expect `' + path.sep + '`' ) } } // Assert that `part` is not empty. function assertNonEmpty(part, name) { if (!part) { throw new Error('`' + name + '` cannot be empty') } } // Assert `path` exists. function assertPath(path, name) { if (!path) { throw new Error('Setting `' + name + '` requires `path` to be set too') } } /***/ }), /* 207 */ /***/ (function(module, exports) { /*! * Determine if an object is a Buffer * * @author Feross Aboukhadijeh * @license MIT */ module.exports = function isBuffer (obj) { return obj != null && obj.constructor != null && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj) } /***/ }), /* 208 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var toString = Object.prototype.toString; module.exports = function (x) { var prototype; return toString.call(x) === '[object Object]' && (prototype = Object.getPrototypeOf(x), prototype === null || prototype === Object.getPrototypeOf({})); }; /***/ }), /* 209 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var unherit = __webpack_require__(75) var xtend = __webpack_require__(7) var Parser = __webpack_require__(210) module.exports = parse parse.Parser = Parser function parse(options) { var settings = this.data('settings') var Local = unherit(Parser) Local.prototype.options = xtend(Local.prototype.options, settings, options) this.Parser = Local } /***/ }), /* 210 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var xtend = __webpack_require__(7) var toggle = __webpack_require__(76) var vfileLocation = __webpack_require__(19) var unescape = __webpack_require__(211) var decode = __webpack_require__(212) var tokenizer = __webpack_require__(216) module.exports = Parser function Parser(doc, file) { this.file = file this.offset = {} this.options = xtend(this.options) this.setOptions({}) this.inList = false this.inBlock = false this.inLink = false this.atStart = true this.toOffset = vfileLocation(file).toOffset this.unescape = unescape(this, 'escape') this.decode = decode(this) } var proto = Parser.prototype // Expose core. proto.setOptions = __webpack_require__(217) proto.parse = __webpack_require__(219) // Expose `defaults`. proto.options = __webpack_require__(82) // Enter and exit helpers. proto.exitStart = toggle('atStart', true) proto.enterList = toggle('inList', false) proto.enterLink = toggle('inLink', false) proto.enterBlock = toggle('inBlock', false) // Nodes that can interupt a paragraph: // // ```markdown // A paragraph, followed by a thematic break. // ___ // ``` // // In the above example, the thematic break “interupts” the paragraph. proto.interruptParagraph = [ ['thematicBreak'], ['atxHeading'], ['fencedCode'], ['blockquote'], ['html'], ['setextHeading', {commonmark: false}], ['definition', {commonmark: false}], ['footnote', {commonmark: false}] ] // Nodes that can interupt a list: // // ```markdown // - One // ___ // ``` // // In the above example, the thematic break “interupts” the list. proto.interruptList = [ ['atxHeading', {pedantic: false}], ['fencedCode', {pedantic: false}], ['thematicBreak', {pedantic: false}], ['definition', {commonmark: false}], ['footnote', {commonmark: false}] ] // Nodes that can interupt a blockquote: // // ```markdown // > A paragraph. // ___ // ``` // // In the above example, the thematic break “interupts” the blockquote. proto.interruptBlockquote = [ ['indentedCode', {commonmark: true}], ['fencedCode', {commonmark: true}], ['atxHeading', {commonmark: true}], ['setextHeading', {commonmark: true}], ['thematicBreak', {commonmark: true}], ['html', {commonmark: true}], ['list', {commonmark: true}], ['definition', {commonmark: false}], ['footnote', {commonmark: false}] ] // Handlers. proto.blockTokenizers = { newline: __webpack_require__(223), indentedCode: __webpack_require__(224), fencedCode: __webpack_require__(225), blockquote: __webpack_require__(226), atxHeading: __webpack_require__(227), thematicBreak: __webpack_require__(228), list: __webpack_require__(229), setextHeading: __webpack_require__(231), html: __webpack_require__(232), footnote: __webpack_require__(233), definition: __webpack_require__(235), table: __webpack_require__(236), paragraph: __webpack_require__(237) } proto.inlineTokenizers = { escape: __webpack_require__(238), autoLink: __webpack_require__(240), url: __webpack_require__(241), html: __webpack_require__(243), link: __webpack_require__(244), reference: __webpack_require__(245), strong: __webpack_require__(246), emphasis: __webpack_require__(248), deletion: __webpack_require__(251), code: __webpack_require__(253), break: __webpack_require__(255), text: __webpack_require__(257) } // Expose precedence. proto.blockMethods = keys(proto.blockTokenizers) proto.inlineMethods = keys(proto.inlineTokenizers) // Tokenizers. proto.tokenizeBlock = tokenizer('block') proto.tokenizeInline = tokenizer('inline') proto.tokenizeFactory = tokenizer // Get all keys in `value`. function keys(value) { var result = [] var key for (key in value) { result.push(key) } return result } /***/ }), /* 211 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = factory var backslash = '\\' // Factory to de-escape a value, based on a list at `key` in `ctx`. function factory(ctx, key) { return unescape // De-escape a string using the expression at `key` in `ctx`. function unescape(value) { var prev = 0 var index = value.indexOf(backslash) var escape = ctx[key] var queue = [] var character while (index !== -1) { queue.push(value.slice(prev, index)) prev = index + 1 character = value.charAt(prev) // If the following character is not a valid escape, add the slash. if (!character || escape.indexOf(character) === -1) { queue.push(backslash) } index = value.indexOf(backslash, prev + 1) } queue.push(value.slice(prev)) return queue.join('') } } /***/ }), /* 212 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var xtend = __webpack_require__(7) var entities = __webpack_require__(30) module.exports = factory // Factory to create an entity decoder. function factory(ctx) { decoder.raw = decodeRaw return decoder // Normalize `position` to add an `indent`. function normalize(position) { var offsets = ctx.offset var line = position.line var result = [] while (++line) { if (!(line in offsets)) { break } result.push((offsets[line] || 0) + 1) } return {start: position, indent: result} } // Decode `value` (at `position`) into text-nodes. function decoder(value, position, handler) { entities(value, { position: normalize(position), warning: handleWarning, text: handler, reference: handler, textContext: ctx, referenceContext: ctx }) } // Decode `value` (at `position`) into a string. function decodeRaw(value, position, options) { return entities( value, xtend(options, {position: normalize(position), warning: handleWarning}) ) } // Handle a warning. // See for the warnings. function handleWarning(reason, position, code) { if (code !== 3) { ctx.file.message(reason, position) } } } /***/ }), /* 213 */ /***/ (function(module) { module.exports = {"0":"�","128":"€","130":"‚","131":"ƒ","132":"„","133":"…","134":"†","135":"‡","136":"ˆ","137":"‰","138":"Š","139":"‹","140":"Œ","142":"Ž","145":"‘","146":"’","147":"“","148":"”","149":"•","150":"–","151":"—","152":"˜","153":"™","154":"š","155":"›","156":"œ","158":"ž","159":"Ÿ"}; /***/ }), /* 214 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var characterEntities = __webpack_require__(215) module.exports = decodeEntity var own = {}.hasOwnProperty function decodeEntity(characters) { return own.call(characterEntities, characters) ? characterEntities[characters] : false } /***/ }), /* 215 */ /***/ (function(module) { module.exports = {"AEli":"Æ","AElig":"Æ","AM":"&","AMP":"&","Aacut":"Á","Aacute":"Á","Abreve":"Ă","Acir":"Â","Acirc":"Â","Acy":"А","Afr":"𝔄","Agrav":"À","Agrave":"À","Alpha":"Α","Amacr":"Ā","And":"⩓","Aogon":"Ą","Aopf":"𝔸","ApplyFunction":"⁡","Arin":"Å","Aring":"Å","Ascr":"𝒜","Assign":"≔","Atild":"Ã","Atilde":"Ã","Aum":"Ä","Auml":"Ä","Backslash":"∖","Barv":"⫧","Barwed":"⌆","Bcy":"Б","Because":"∵","Bernoullis":"ℬ","Beta":"Β","Bfr":"𝔅","Bopf":"𝔹","Breve":"˘","Bscr":"ℬ","Bumpeq":"≎","CHcy":"Ч","COP":"©","COPY":"©","Cacute":"Ć","Cap":"⋒","CapitalDifferentialD":"ⅅ","Cayleys":"ℭ","Ccaron":"Č","Ccedi":"Ç","Ccedil":"Ç","Ccirc":"Ĉ","Cconint":"∰","Cdot":"Ċ","Cedilla":"¸","CenterDot":"·","Cfr":"ℭ","Chi":"Χ","CircleDot":"⊙","CircleMinus":"⊖","CirclePlus":"⊕","CircleTimes":"⊗","ClockwiseContourIntegral":"∲","CloseCurlyDoubleQuote":"”","CloseCurlyQuote":"’","Colon":"∷","Colone":"⩴","Congruent":"≡","Conint":"∯","ContourIntegral":"∮","Copf":"ℂ","Coproduct":"∐","CounterClockwiseContourIntegral":"∳","Cross":"⨯","Cscr":"𝒞","Cup":"⋓","CupCap":"≍","DD":"ⅅ","DDotrahd":"⤑","DJcy":"Ђ","DScy":"Ѕ","DZcy":"Џ","Dagger":"‡","Darr":"↡","Dashv":"⫤","Dcaron":"Ď","Dcy":"Д","Del":"∇","Delta":"Δ","Dfr":"𝔇","DiacriticalAcute":"´","DiacriticalDot":"˙","DiacriticalDoubleAcute":"˝","DiacriticalGrave":"`","DiacriticalTilde":"˜","Diamond":"⋄","DifferentialD":"ⅆ","Dopf":"𝔻","Dot":"¨","DotDot":"⃜","DotEqual":"≐","DoubleContourIntegral":"∯","DoubleDot":"¨","DoubleDownArrow":"⇓","DoubleLeftArrow":"⇐","DoubleLeftRightArrow":"⇔","DoubleLeftTee":"⫤","DoubleLongLeftArrow":"⟸","DoubleLongLeftRightArrow":"⟺","DoubleLongRightArrow":"⟹","DoubleRightArrow":"⇒","DoubleRightTee":"⊨","DoubleUpArrow":"⇑","DoubleUpDownArrow":"⇕","DoubleVerticalBar":"∥","DownArrow":"↓","DownArrowBar":"⤓","DownArrowUpArrow":"⇵","DownBreve":"̑","DownLeftRightVector":"⥐","DownLeftTeeVector":"⥞","DownLeftVector":"↽","DownLeftVectorBar":"⥖","DownRightTeeVector":"⥟","DownRightVector":"⇁","DownRightVectorBar":"⥗","DownTee":"⊤","DownTeeArrow":"↧","Downarrow":"⇓","Dscr":"𝒟","Dstrok":"Đ","ENG":"Ŋ","ET":"Ð","ETH":"Ð","Eacut":"É","Eacute":"É","Ecaron":"Ě","Ecir":"Ê","Ecirc":"Ê","Ecy":"Э","Edot":"Ė","Efr":"𝔈","Egrav":"È","Egrave":"È","Element":"∈","Emacr":"Ē","EmptySmallSquare":"◻","EmptyVerySmallSquare":"▫","Eogon":"Ę","Eopf":"𝔼","Epsilon":"Ε","Equal":"⩵","EqualTilde":"≂","Equilibrium":"⇌","Escr":"ℰ","Esim":"⩳","Eta":"Η","Eum":"Ë","Euml":"Ë","Exists":"∃","ExponentialE":"ⅇ","Fcy":"Ф","Ffr":"𝔉","FilledSmallSquare":"◼","FilledVerySmallSquare":"▪","Fopf":"𝔽","ForAll":"∀","Fouriertrf":"ℱ","Fscr":"ℱ","GJcy":"Ѓ","G":">","GT":">","Gamma":"Γ","Gammad":"Ϝ","Gbreve":"Ğ","Gcedil":"Ģ","Gcirc":"Ĝ","Gcy":"Г","Gdot":"Ġ","Gfr":"𝔊","Gg":"⋙","Gopf":"𝔾","GreaterEqual":"≥","GreaterEqualLess":"⋛","GreaterFullEqual":"≧","GreaterGreater":"⪢","GreaterLess":"≷","GreaterSlantEqual":"⩾","GreaterTilde":"≳","Gscr":"𝒢","Gt":"≫","HARDcy":"Ъ","Hacek":"ˇ","Hat":"^","Hcirc":"Ĥ","Hfr":"ℌ","HilbertSpace":"ℋ","Hopf":"ℍ","HorizontalLine":"─","Hscr":"ℋ","Hstrok":"Ħ","HumpDownHump":"≎","HumpEqual":"≏","IEcy":"Е","IJlig":"IJ","IOcy":"Ё","Iacut":"Í","Iacute":"Í","Icir":"Î","Icirc":"Î","Icy":"И","Idot":"İ","Ifr":"ℑ","Igrav":"Ì","Igrave":"Ì","Im":"ℑ","Imacr":"Ī","ImaginaryI":"ⅈ","Implies":"⇒","Int":"∬","Integral":"∫","Intersection":"⋂","InvisibleComma":"⁣","InvisibleTimes":"⁢","Iogon":"Į","Iopf":"𝕀","Iota":"Ι","Iscr":"ℐ","Itilde":"Ĩ","Iukcy":"І","Ium":"Ï","Iuml":"Ï","Jcirc":"Ĵ","Jcy":"Й","Jfr":"𝔍","Jopf":"𝕁","Jscr":"𝒥","Jsercy":"Ј","Jukcy":"Є","KHcy":"Х","KJcy":"Ќ","Kappa":"Κ","Kcedil":"Ķ","Kcy":"К","Kfr":"𝔎","Kopf":"𝕂","Kscr":"𝒦","LJcy":"Љ","L":"<","LT":"<","Lacute":"Ĺ","Lambda":"Λ","Lang":"⟪","Laplacetrf":"ℒ","Larr":"↞","Lcaron":"Ľ","Lcedil":"Ļ","Lcy":"Л","LeftAngleBracket":"⟨","LeftArrow":"←","LeftArrowBar":"⇤","LeftArrowRightArrow":"⇆","LeftCeiling":"⌈","LeftDoubleBracket":"⟦","LeftDownTeeVector":"⥡","LeftDownVector":"⇃","LeftDownVectorBar":"⥙","LeftFloor":"⌊","LeftRightArrow":"↔","LeftRightVector":"⥎","LeftTee":"⊣","LeftTeeArrow":"↤","LeftTeeVector":"⥚","LeftTriangle":"⊲","LeftTriangleBar":"⧏","LeftTriangleEqual":"⊴","LeftUpDownVector":"⥑","LeftUpTeeVector":"⥠","LeftUpVector":"↿","LeftUpVectorBar":"⥘","LeftVector":"↼","LeftVectorBar":"⥒","Leftarrow":"⇐","Leftrightarrow":"⇔","LessEqualGreater":"⋚","LessFullEqual":"≦","LessGreater":"≶","LessLess":"⪡","LessSlantEqual":"⩽","LessTilde":"≲","Lfr":"𝔏","Ll":"⋘","Lleftarrow":"⇚","Lmidot":"Ŀ","LongLeftArrow":"⟵","LongLeftRightArrow":"⟷","LongRightArrow":"⟶","Longleftarrow":"⟸","Longleftrightarrow":"⟺","Longrightarrow":"⟹","Lopf":"𝕃","LowerLeftArrow":"↙","LowerRightArrow":"↘","Lscr":"ℒ","Lsh":"↰","Lstrok":"Ł","Lt":"≪","Map":"⤅","Mcy":"М","MediumSpace":" ","Mellintrf":"ℳ","Mfr":"𝔐","MinusPlus":"∓","Mopf":"𝕄","Mscr":"ℳ","Mu":"Μ","NJcy":"Њ","Nacute":"Ń","Ncaron":"Ň","Ncedil":"Ņ","Ncy":"Н","NegativeMediumSpace":"​","NegativeThickSpace":"​","NegativeThinSpace":"​","NegativeVeryThinSpace":"​","NestedGreaterGreater":"≫","NestedLessLess":"≪","NewLine":"\n","Nfr":"𝔑","NoBreak":"⁠","NonBreakingSpace":" ","Nopf":"ℕ","Not":"⫬","NotCongruent":"≢","NotCupCap":"≭","NotDoubleVerticalBar":"∦","NotElement":"∉","NotEqual":"≠","NotEqualTilde":"≂̸","NotExists":"∄","NotGreater":"≯","NotGreaterEqual":"≱","NotGreaterFullEqual":"≧̸","NotGreaterGreater":"≫̸","NotGreaterLess":"≹","NotGreaterSlantEqual":"⩾̸","NotGreaterTilde":"≵","NotHumpDownHump":"≎̸","NotHumpEqual":"≏̸","NotLeftTriangle":"⋪","NotLeftTriangleBar":"⧏̸","NotLeftTriangleEqual":"⋬","NotLess":"≮","NotLessEqual":"≰","NotLessGreater":"≸","NotLessLess":"≪̸","NotLessSlantEqual":"⩽̸","NotLessTilde":"≴","NotNestedGreaterGreater":"⪢̸","NotNestedLessLess":"⪡̸","NotPrecedes":"⊀","NotPrecedesEqual":"⪯̸","NotPrecedesSlantEqual":"⋠","NotReverseElement":"∌","NotRightTriangle":"⋫","NotRightTriangleBar":"⧐̸","NotRightTriangleEqual":"⋭","NotSquareSubset":"⊏̸","NotSquareSubsetEqual":"⋢","NotSquareSuperset":"⊐̸","NotSquareSupersetEqual":"⋣","NotSubset":"⊂⃒","NotSubsetEqual":"⊈","NotSucceeds":"⊁","NotSucceedsEqual":"⪰̸","NotSucceedsSlantEqual":"⋡","NotSucceedsTilde":"≿̸","NotSuperset":"⊃⃒","NotSupersetEqual":"⊉","NotTilde":"≁","NotTildeEqual":"≄","NotTildeFullEqual":"≇","NotTildeTilde":"≉","NotVerticalBar":"∤","Nscr":"𝒩","Ntild":"Ñ","Ntilde":"Ñ","Nu":"Ν","OElig":"Œ","Oacut":"Ó","Oacute":"Ó","Ocir":"Ô","Ocirc":"Ô","Ocy":"О","Odblac":"Ő","Ofr":"𝔒","Ograv":"Ò","Ograve":"Ò","Omacr":"Ō","Omega":"Ω","Omicron":"Ο","Oopf":"𝕆","OpenCurlyDoubleQuote":"“","OpenCurlyQuote":"‘","Or":"⩔","Oscr":"𝒪","Oslas":"Ø","Oslash":"Ø","Otild":"Õ","Otilde":"Õ","Otimes":"⨷","Oum":"Ö","Ouml":"Ö","OverBar":"‾","OverBrace":"⏞","OverBracket":"⎴","OverParenthesis":"⏜","PartialD":"∂","Pcy":"П","Pfr":"𝔓","Phi":"Φ","Pi":"Π","PlusMinus":"±","Poincareplane":"ℌ","Popf":"ℙ","Pr":"⪻","Precedes":"≺","PrecedesEqual":"⪯","PrecedesSlantEqual":"≼","PrecedesTilde":"≾","Prime":"″","Product":"∏","Proportion":"∷","Proportional":"∝","Pscr":"𝒫","Psi":"Ψ","QUO":"\"","QUOT":"\"","Qfr":"𝔔","Qopf":"ℚ","Qscr":"𝒬","RBarr":"⤐","RE":"®","REG":"®","Racute":"Ŕ","Rang":"⟫","Rarr":"↠","Rarrtl":"⤖","Rcaron":"Ř","Rcedil":"Ŗ","Rcy":"Р","Re":"ℜ","ReverseElement":"∋","ReverseEquilibrium":"⇋","ReverseUpEquilibrium":"⥯","Rfr":"ℜ","Rho":"Ρ","RightAngleBracket":"⟩","RightArrow":"→","RightArrowBar":"⇥","RightArrowLeftArrow":"⇄","RightCeiling":"⌉","RightDoubleBracket":"⟧","RightDownTeeVector":"⥝","RightDownVector":"⇂","RightDownVectorBar":"⥕","RightFloor":"⌋","RightTee":"⊢","RightTeeArrow":"↦","RightTeeVector":"⥛","RightTriangle":"⊳","RightTriangleBar":"⧐","RightTriangleEqual":"⊵","RightUpDownVector":"⥏","RightUpTeeVector":"⥜","RightUpVector":"↾","RightUpVectorBar":"⥔","RightVector":"⇀","RightVectorBar":"⥓","Rightarrow":"⇒","Ropf":"ℝ","RoundImplies":"⥰","Rrightarrow":"⇛","Rscr":"ℛ","Rsh":"↱","RuleDelayed":"⧴","SHCHcy":"Щ","SHcy":"Ш","SOFTcy":"Ь","Sacute":"Ś","Sc":"⪼","Scaron":"Š","Scedil":"Ş","Scirc":"Ŝ","Scy":"С","Sfr":"𝔖","ShortDownArrow":"↓","ShortLeftArrow":"←","ShortRightArrow":"→","ShortUpArrow":"↑","Sigma":"Σ","SmallCircle":"∘","Sopf":"𝕊","Sqrt":"√","Square":"□","SquareIntersection":"⊓","SquareSubset":"⊏","SquareSubsetEqual":"⊑","SquareSuperset":"⊐","SquareSupersetEqual":"⊒","SquareUnion":"⊔","Sscr":"𝒮","Star":"⋆","Sub":"⋐","Subset":"⋐","SubsetEqual":"⊆","Succeeds":"≻","SucceedsEqual":"⪰","SucceedsSlantEqual":"≽","SucceedsTilde":"≿","SuchThat":"∋","Sum":"∑","Sup":"⋑","Superset":"⊃","SupersetEqual":"⊇","Supset":"⋑","THOR":"Þ","THORN":"Þ","TRADE":"™","TSHcy":"Ћ","TScy":"Ц","Tab":"\t","Tau":"Τ","Tcaron":"Ť","Tcedil":"Ţ","Tcy":"Т","Tfr":"𝔗","Therefore":"∴","Theta":"Θ","ThickSpace":"  ","ThinSpace":" ","Tilde":"∼","TildeEqual":"≃","TildeFullEqual":"≅","TildeTilde":"≈","Topf":"𝕋","TripleDot":"⃛","Tscr":"𝒯","Tstrok":"Ŧ","Uacut":"Ú","Uacute":"Ú","Uarr":"↟","Uarrocir":"⥉","Ubrcy":"Ў","Ubreve":"Ŭ","Ucir":"Û","Ucirc":"Û","Ucy":"У","Udblac":"Ű","Ufr":"𝔘","Ugrav":"Ù","Ugrave":"Ù","Umacr":"Ū","UnderBar":"_","UnderBrace":"⏟","UnderBracket":"⎵","UnderParenthesis":"⏝","Union":"⋃","UnionPlus":"⊎","Uogon":"Ų","Uopf":"𝕌","UpArrow":"↑","UpArrowBar":"⤒","UpArrowDownArrow":"⇅","UpDownArrow":"↕","UpEquilibrium":"⥮","UpTee":"⊥","UpTeeArrow":"↥","Uparrow":"⇑","Updownarrow":"⇕","UpperLeftArrow":"↖","UpperRightArrow":"↗","Upsi":"ϒ","Upsilon":"Υ","Uring":"Ů","Uscr":"𝒰","Utilde":"Ũ","Uum":"Ü","Uuml":"Ü","VDash":"⊫","Vbar":"⫫","Vcy":"В","Vdash":"⊩","Vdashl":"⫦","Vee":"⋁","Verbar":"‖","Vert":"‖","VerticalBar":"∣","VerticalLine":"|","VerticalSeparator":"❘","VerticalTilde":"≀","VeryThinSpace":" ","Vfr":"𝔙","Vopf":"𝕍","Vscr":"𝒱","Vvdash":"⊪","Wcirc":"Ŵ","Wedge":"⋀","Wfr":"𝔚","Wopf":"𝕎","Wscr":"𝒲","Xfr":"𝔛","Xi":"Ξ","Xopf":"𝕏","Xscr":"𝒳","YAcy":"Я","YIcy":"Ї","YUcy":"Ю","Yacut":"Ý","Yacute":"Ý","Ycirc":"Ŷ","Ycy":"Ы","Yfr":"𝔜","Yopf":"𝕐","Yscr":"𝒴","Yuml":"Ÿ","ZHcy":"Ж","Zacute":"Ź","Zcaron":"Ž","Zcy":"З","Zdot":"Ż","ZeroWidthSpace":"​","Zeta":"Ζ","Zfr":"ℨ","Zopf":"ℤ","Zscr":"𝒵","aacut":"á","aacute":"á","abreve":"ă","ac":"∾","acE":"∾̳","acd":"∿","acir":"â","acirc":"â","acut":"´","acute":"´","acy":"а","aeli":"æ","aelig":"æ","af":"⁡","afr":"𝔞","agrav":"à","agrave":"à","alefsym":"ℵ","aleph":"ℵ","alpha":"α","amacr":"ā","amalg":"⨿","am":"&","amp":"&","and":"∧","andand":"⩕","andd":"⩜","andslope":"⩘","andv":"⩚","ang":"∠","ange":"⦤","angle":"∠","angmsd":"∡","angmsdaa":"⦨","angmsdab":"⦩","angmsdac":"⦪","angmsdad":"⦫","angmsdae":"⦬","angmsdaf":"⦭","angmsdag":"⦮","angmsdah":"⦯","angrt":"∟","angrtvb":"⊾","angrtvbd":"⦝","angsph":"∢","angst":"Å","angzarr":"⍼","aogon":"ą","aopf":"𝕒","ap":"≈","apE":"⩰","apacir":"⩯","ape":"≊","apid":"≋","apos":"'","approx":"≈","approxeq":"≊","arin":"å","aring":"å","ascr":"𝒶","ast":"*","asymp":"≈","asympeq":"≍","atild":"ã","atilde":"ã","aum":"ä","auml":"ä","awconint":"∳","awint":"⨑","bNot":"⫭","backcong":"≌","backepsilon":"϶","backprime":"‵","backsim":"∽","backsimeq":"⋍","barvee":"⊽","barwed":"⌅","barwedge":"⌅","bbrk":"⎵","bbrktbrk":"⎶","bcong":"≌","bcy":"б","bdquo":"„","becaus":"∵","because":"∵","bemptyv":"⦰","bepsi":"϶","bernou":"ℬ","beta":"β","beth":"ℶ","between":"≬","bfr":"𝔟","bigcap":"⋂","bigcirc":"◯","bigcup":"⋃","bigodot":"⨀","bigoplus":"⨁","bigotimes":"⨂","bigsqcup":"⨆","bigstar":"★","bigtriangledown":"▽","bigtriangleup":"△","biguplus":"⨄","bigvee":"⋁","bigwedge":"⋀","bkarow":"⤍","blacklozenge":"⧫","blacksquare":"▪","blacktriangle":"▴","blacktriangledown":"▾","blacktriangleleft":"◂","blacktriangleright":"▸","blank":"␣","blk12":"▒","blk14":"░","blk34":"▓","block":"█","bne":"=⃥","bnequiv":"≡⃥","bnot":"⌐","bopf":"𝕓","bot":"⊥","bottom":"⊥","bowtie":"⋈","boxDL":"╗","boxDR":"╔","boxDl":"╖","boxDr":"╓","boxH":"═","boxHD":"╦","boxHU":"╩","boxHd":"╤","boxHu":"╧","boxUL":"╝","boxUR":"╚","boxUl":"╜","boxUr":"╙","boxV":"║","boxVH":"╬","boxVL":"╣","boxVR":"╠","boxVh":"╫","boxVl":"╢","boxVr":"╟","boxbox":"⧉","boxdL":"╕","boxdR":"╒","boxdl":"┐","boxdr":"┌","boxh":"─","boxhD":"╥","boxhU":"╨","boxhd":"┬","boxhu":"┴","boxminus":"⊟","boxplus":"⊞","boxtimes":"⊠","boxuL":"╛","boxuR":"╘","boxul":"┘","boxur":"└","boxv":"│","boxvH":"╪","boxvL":"╡","boxvR":"╞","boxvh":"┼","boxvl":"┤","boxvr":"├","bprime":"‵","breve":"˘","brvba":"¦","brvbar":"¦","bscr":"𝒷","bsemi":"⁏","bsim":"∽","bsime":"⋍","bsol":"\\","bsolb":"⧅","bsolhsub":"⟈","bull":"•","bullet":"•","bump":"≎","bumpE":"⪮","bumpe":"≏","bumpeq":"≏","cacute":"ć","cap":"∩","capand":"⩄","capbrcup":"⩉","capcap":"⩋","capcup":"⩇","capdot":"⩀","caps":"∩︀","caret":"⁁","caron":"ˇ","ccaps":"⩍","ccaron":"č","ccedi":"ç","ccedil":"ç","ccirc":"ĉ","ccups":"⩌","ccupssm":"⩐","cdot":"ċ","cedi":"¸","cedil":"¸","cemptyv":"⦲","cen":"¢","cent":"¢","centerdot":"·","cfr":"𝔠","chcy":"ч","check":"✓","checkmark":"✓","chi":"χ","cir":"○","cirE":"⧃","circ":"ˆ","circeq":"≗","circlearrowleft":"↺","circlearrowright":"↻","circledR":"®","circledS":"Ⓢ","circledast":"⊛","circledcirc":"⊚","circleddash":"⊝","cire":"≗","cirfnint":"⨐","cirmid":"⫯","cirscir":"⧂","clubs":"♣","clubsuit":"♣","colon":":","colone":"≔","coloneq":"≔","comma":",","commat":"@","comp":"∁","compfn":"∘","complement":"∁","complexes":"ℂ","cong":"≅","congdot":"⩭","conint":"∮","copf":"𝕔","coprod":"∐","cop":"©","copy":"©","copysr":"℗","crarr":"↵","cross":"✗","cscr":"𝒸","csub":"⫏","csube":"⫑","csup":"⫐","csupe":"⫒","ctdot":"⋯","cudarrl":"⤸","cudarrr":"⤵","cuepr":"⋞","cuesc":"⋟","cularr":"↶","cularrp":"⤽","cup":"∪","cupbrcap":"⩈","cupcap":"⩆","cupcup":"⩊","cupdot":"⊍","cupor":"⩅","cups":"∪︀","curarr":"↷","curarrm":"⤼","curlyeqprec":"⋞","curlyeqsucc":"⋟","curlyvee":"⋎","curlywedge":"⋏","curre":"¤","curren":"¤","curvearrowleft":"↶","curvearrowright":"↷","cuvee":"⋎","cuwed":"⋏","cwconint":"∲","cwint":"∱","cylcty":"⌭","dArr":"⇓","dHar":"⥥","dagger":"†","daleth":"ℸ","darr":"↓","dash":"‐","dashv":"⊣","dbkarow":"⤏","dblac":"˝","dcaron":"ď","dcy":"д","dd":"ⅆ","ddagger":"‡","ddarr":"⇊","ddotseq":"⩷","de":"°","deg":"°","delta":"δ","demptyv":"⦱","dfisht":"⥿","dfr":"𝔡","dharl":"⇃","dharr":"⇂","diam":"⋄","diamond":"⋄","diamondsuit":"♦","diams":"♦","die":"¨","digamma":"ϝ","disin":"⋲","div":"÷","divid":"÷","divide":"÷","divideontimes":"⋇","divonx":"⋇","djcy":"ђ","dlcorn":"⌞","dlcrop":"⌍","dollar":"$","dopf":"𝕕","dot":"˙","doteq":"≐","doteqdot":"≑","dotminus":"∸","dotplus":"∔","dotsquare":"⊡","doublebarwedge":"⌆","downarrow":"↓","downdownarrows":"⇊","downharpoonleft":"⇃","downharpoonright":"⇂","drbkarow":"⤐","drcorn":"⌟","drcrop":"⌌","dscr":"𝒹","dscy":"ѕ","dsol":"⧶","dstrok":"đ","dtdot":"⋱","dtri":"▿","dtrif":"▾","duarr":"⇵","duhar":"⥯","dwangle":"⦦","dzcy":"џ","dzigrarr":"⟿","eDDot":"⩷","eDot":"≑","eacut":"é","eacute":"é","easter":"⩮","ecaron":"ě","ecir":"ê","ecirc":"ê","ecolon":"≕","ecy":"э","edot":"ė","ee":"ⅇ","efDot":"≒","efr":"𝔢","eg":"⪚","egrav":"è","egrave":"è","egs":"⪖","egsdot":"⪘","el":"⪙","elinters":"⏧","ell":"ℓ","els":"⪕","elsdot":"⪗","emacr":"ē","empty":"∅","emptyset":"∅","emptyv":"∅","emsp13":" ","emsp14":" ","emsp":" ","eng":"ŋ","ensp":" ","eogon":"ę","eopf":"𝕖","epar":"⋕","eparsl":"⧣","eplus":"⩱","epsi":"ε","epsilon":"ε","epsiv":"ϵ","eqcirc":"≖","eqcolon":"≕","eqsim":"≂","eqslantgtr":"⪖","eqslantless":"⪕","equals":"=","equest":"≟","equiv":"≡","equivDD":"⩸","eqvparsl":"⧥","erDot":"≓","erarr":"⥱","escr":"ℯ","esdot":"≐","esim":"≂","eta":"η","et":"ð","eth":"ð","eum":"ë","euml":"ë","euro":"€","excl":"!","exist":"∃","expectation":"ℰ","exponentiale":"ⅇ","fallingdotseq":"≒","fcy":"ф","female":"♀","ffilig":"ffi","fflig":"ff","ffllig":"ffl","ffr":"𝔣","filig":"fi","fjlig":"fj","flat":"♭","fllig":"fl","fltns":"▱","fnof":"ƒ","fopf":"𝕗","forall":"∀","fork":"⋔","forkv":"⫙","fpartint":"⨍","frac1":"¼","frac12":"½","frac13":"⅓","frac14":"¼","frac15":"⅕","frac16":"⅙","frac18":"⅛","frac23":"⅔","frac25":"⅖","frac3":"¾","frac34":"¾","frac35":"⅗","frac38":"⅜","frac45":"⅘","frac56":"⅚","frac58":"⅝","frac78":"⅞","frasl":"⁄","frown":"⌢","fscr":"𝒻","gE":"≧","gEl":"⪌","gacute":"ǵ","gamma":"γ","gammad":"ϝ","gap":"⪆","gbreve":"ğ","gcirc":"ĝ","gcy":"г","gdot":"ġ","ge":"≥","gel":"⋛","geq":"≥","geqq":"≧","geqslant":"⩾","ges":"⩾","gescc":"⪩","gesdot":"⪀","gesdoto":"⪂","gesdotol":"⪄","gesl":"⋛︀","gesles":"⪔","gfr":"𝔤","gg":"≫","ggg":"⋙","gimel":"ℷ","gjcy":"ѓ","gl":"≷","glE":"⪒","gla":"⪥","glj":"⪤","gnE":"≩","gnap":"⪊","gnapprox":"⪊","gne":"⪈","gneq":"⪈","gneqq":"≩","gnsim":"⋧","gopf":"𝕘","grave":"`","gscr":"ℊ","gsim":"≳","gsime":"⪎","gsiml":"⪐","g":">","gt":">","gtcc":"⪧","gtcir":"⩺","gtdot":"⋗","gtlPar":"⦕","gtquest":"⩼","gtrapprox":"⪆","gtrarr":"⥸","gtrdot":"⋗","gtreqless":"⋛","gtreqqless":"⪌","gtrless":"≷","gtrsim":"≳","gvertneqq":"≩︀","gvnE":"≩︀","hArr":"⇔","hairsp":" ","half":"½","hamilt":"ℋ","hardcy":"ъ","harr":"↔","harrcir":"⥈","harrw":"↭","hbar":"ℏ","hcirc":"ĥ","hearts":"♥","heartsuit":"♥","hellip":"…","hercon":"⊹","hfr":"𝔥","hksearow":"⤥","hkswarow":"⤦","hoarr":"⇿","homtht":"∻","hookleftarrow":"↩","hookrightarrow":"↪","hopf":"𝕙","horbar":"―","hscr":"𝒽","hslash":"ℏ","hstrok":"ħ","hybull":"⁃","hyphen":"‐","iacut":"í","iacute":"í","ic":"⁣","icir":"î","icirc":"î","icy":"и","iecy":"е","iexc":"¡","iexcl":"¡","iff":"⇔","ifr":"𝔦","igrav":"ì","igrave":"ì","ii":"ⅈ","iiiint":"⨌","iiint":"∭","iinfin":"⧜","iiota":"℩","ijlig":"ij","imacr":"ī","image":"ℑ","imagline":"ℐ","imagpart":"ℑ","imath":"ı","imof":"⊷","imped":"Ƶ","in":"∈","incare":"℅","infin":"∞","infintie":"⧝","inodot":"ı","int":"∫","intcal":"⊺","integers":"ℤ","intercal":"⊺","intlarhk":"⨗","intprod":"⨼","iocy":"ё","iogon":"į","iopf":"𝕚","iota":"ι","iprod":"⨼","iques":"¿","iquest":"¿","iscr":"𝒾","isin":"∈","isinE":"⋹","isindot":"⋵","isins":"⋴","isinsv":"⋳","isinv":"∈","it":"⁢","itilde":"ĩ","iukcy":"і","ium":"ï","iuml":"ï","jcirc":"ĵ","jcy":"й","jfr":"𝔧","jmath":"ȷ","jopf":"𝕛","jscr":"𝒿","jsercy":"ј","jukcy":"є","kappa":"κ","kappav":"ϰ","kcedil":"ķ","kcy":"к","kfr":"𝔨","kgreen":"ĸ","khcy":"х","kjcy":"ќ","kopf":"𝕜","kscr":"𝓀","lAarr":"⇚","lArr":"⇐","lAtail":"⤛","lBarr":"⤎","lE":"≦","lEg":"⪋","lHar":"⥢","lacute":"ĺ","laemptyv":"⦴","lagran":"ℒ","lambda":"λ","lang":"⟨","langd":"⦑","langle":"⟨","lap":"⪅","laqu":"«","laquo":"«","larr":"←","larrb":"⇤","larrbfs":"⤟","larrfs":"⤝","larrhk":"↩","larrlp":"↫","larrpl":"⤹","larrsim":"⥳","larrtl":"↢","lat":"⪫","latail":"⤙","late":"⪭","lates":"⪭︀","lbarr":"⤌","lbbrk":"❲","lbrace":"{","lbrack":"[","lbrke":"⦋","lbrksld":"⦏","lbrkslu":"⦍","lcaron":"ľ","lcedil":"ļ","lceil":"⌈","lcub":"{","lcy":"л","ldca":"⤶","ldquo":"“","ldquor":"„","ldrdhar":"⥧","ldrushar":"⥋","ldsh":"↲","le":"≤","leftarrow":"←","leftarrowtail":"↢","leftharpoondown":"↽","leftharpoonup":"↼","leftleftarrows":"⇇","leftrightarrow":"↔","leftrightarrows":"⇆","leftrightharpoons":"⇋","leftrightsquigarrow":"↭","leftthreetimes":"⋋","leg":"⋚","leq":"≤","leqq":"≦","leqslant":"⩽","les":"⩽","lescc":"⪨","lesdot":"⩿","lesdoto":"⪁","lesdotor":"⪃","lesg":"⋚︀","lesges":"⪓","lessapprox":"⪅","lessdot":"⋖","lesseqgtr":"⋚","lesseqqgtr":"⪋","lessgtr":"≶","lesssim":"≲","lfisht":"⥼","lfloor":"⌊","lfr":"𝔩","lg":"≶","lgE":"⪑","lhard":"↽","lharu":"↼","lharul":"⥪","lhblk":"▄","ljcy":"љ","ll":"≪","llarr":"⇇","llcorner":"⌞","llhard":"⥫","lltri":"◺","lmidot":"ŀ","lmoust":"⎰","lmoustache":"⎰","lnE":"≨","lnap":"⪉","lnapprox":"⪉","lne":"⪇","lneq":"⪇","lneqq":"≨","lnsim":"⋦","loang":"⟬","loarr":"⇽","lobrk":"⟦","longleftarrow":"⟵","longleftrightarrow":"⟷","longmapsto":"⟼","longrightarrow":"⟶","looparrowleft":"↫","looparrowright":"↬","lopar":"⦅","lopf":"𝕝","loplus":"⨭","lotimes":"⨴","lowast":"∗","lowbar":"_","loz":"◊","lozenge":"◊","lozf":"⧫","lpar":"(","lparlt":"⦓","lrarr":"⇆","lrcorner":"⌟","lrhar":"⇋","lrhard":"⥭","lrm":"‎","lrtri":"⊿","lsaquo":"‹","lscr":"𝓁","lsh":"↰","lsim":"≲","lsime":"⪍","lsimg":"⪏","lsqb":"[","lsquo":"‘","lsquor":"‚","lstrok":"ł","l":"<","lt":"<","ltcc":"⪦","ltcir":"⩹","ltdot":"⋖","lthree":"⋋","ltimes":"⋉","ltlarr":"⥶","ltquest":"⩻","ltrPar":"⦖","ltri":"◃","ltrie":"⊴","ltrif":"◂","lurdshar":"⥊","luruhar":"⥦","lvertneqq":"≨︀","lvnE":"≨︀","mDDot":"∺","mac":"¯","macr":"¯","male":"♂","malt":"✠","maltese":"✠","map":"↦","mapsto":"↦","mapstodown":"↧","mapstoleft":"↤","mapstoup":"↥","marker":"▮","mcomma":"⨩","mcy":"м","mdash":"—","measuredangle":"∡","mfr":"𝔪","mho":"℧","micr":"µ","micro":"µ","mid":"∣","midast":"*","midcir":"⫰","middo":"·","middot":"·","minus":"−","minusb":"⊟","minusd":"∸","minusdu":"⨪","mlcp":"⫛","mldr":"…","mnplus":"∓","models":"⊧","mopf":"𝕞","mp":"∓","mscr":"𝓂","mstpos":"∾","mu":"μ","multimap":"⊸","mumap":"⊸","nGg":"⋙̸","nGt":"≫⃒","nGtv":"≫̸","nLeftarrow":"⇍","nLeftrightarrow":"⇎","nLl":"⋘̸","nLt":"≪⃒","nLtv":"≪̸","nRightarrow":"⇏","nVDash":"⊯","nVdash":"⊮","nabla":"∇","nacute":"ń","nang":"∠⃒","nap":"≉","napE":"⩰̸","napid":"≋̸","napos":"ʼn","napprox":"≉","natur":"♮","natural":"♮","naturals":"ℕ","nbs":" ","nbsp":" ","nbump":"≎̸","nbumpe":"≏̸","ncap":"⩃","ncaron":"ň","ncedil":"ņ","ncong":"≇","ncongdot":"⩭̸","ncup":"⩂","ncy":"н","ndash":"–","ne":"≠","neArr":"⇗","nearhk":"⤤","nearr":"↗","nearrow":"↗","nedot":"≐̸","nequiv":"≢","nesear":"⤨","nesim":"≂̸","nexist":"∄","nexists":"∄","nfr":"𝔫","ngE":"≧̸","nge":"≱","ngeq":"≱","ngeqq":"≧̸","ngeqslant":"⩾̸","nges":"⩾̸","ngsim":"≵","ngt":"≯","ngtr":"≯","nhArr":"⇎","nharr":"↮","nhpar":"⫲","ni":"∋","nis":"⋼","nisd":"⋺","niv":"∋","njcy":"њ","nlArr":"⇍","nlE":"≦̸","nlarr":"↚","nldr":"‥","nle":"≰","nleftarrow":"↚","nleftrightarrow":"↮","nleq":"≰","nleqq":"≦̸","nleqslant":"⩽̸","nles":"⩽̸","nless":"≮","nlsim":"≴","nlt":"≮","nltri":"⋪","nltrie":"⋬","nmid":"∤","nopf":"𝕟","no":"¬","not":"¬","notin":"∉","notinE":"⋹̸","notindot":"⋵̸","notinva":"∉","notinvb":"⋷","notinvc":"⋶","notni":"∌","notniva":"∌","notnivb":"⋾","notnivc":"⋽","npar":"∦","nparallel":"∦","nparsl":"⫽⃥","npart":"∂̸","npolint":"⨔","npr":"⊀","nprcue":"⋠","npre":"⪯̸","nprec":"⊀","npreceq":"⪯̸","nrArr":"⇏","nrarr":"↛","nrarrc":"⤳̸","nrarrw":"↝̸","nrightarrow":"↛","nrtri":"⋫","nrtrie":"⋭","nsc":"⊁","nsccue":"⋡","nsce":"⪰̸","nscr":"𝓃","nshortmid":"∤","nshortparallel":"∦","nsim":"≁","nsime":"≄","nsimeq":"≄","nsmid":"∤","nspar":"∦","nsqsube":"⋢","nsqsupe":"⋣","nsub":"⊄","nsubE":"⫅̸","nsube":"⊈","nsubset":"⊂⃒","nsubseteq":"⊈","nsubseteqq":"⫅̸","nsucc":"⊁","nsucceq":"⪰̸","nsup":"⊅","nsupE":"⫆̸","nsupe":"⊉","nsupset":"⊃⃒","nsupseteq":"⊉","nsupseteqq":"⫆̸","ntgl":"≹","ntild":"ñ","ntilde":"ñ","ntlg":"≸","ntriangleleft":"⋪","ntrianglelefteq":"⋬","ntriangleright":"⋫","ntrianglerighteq":"⋭","nu":"ν","num":"#","numero":"№","numsp":" ","nvDash":"⊭","nvHarr":"⤄","nvap":"≍⃒","nvdash":"⊬","nvge":"≥⃒","nvgt":">⃒","nvinfin":"⧞","nvlArr":"⤂","nvle":"≤⃒","nvlt":"<⃒","nvltrie":"⊴⃒","nvrArr":"⤃","nvrtrie":"⊵⃒","nvsim":"∼⃒","nwArr":"⇖","nwarhk":"⤣","nwarr":"↖","nwarrow":"↖","nwnear":"⤧","oS":"Ⓢ","oacut":"ó","oacute":"ó","oast":"⊛","ocir":"ô","ocirc":"ô","ocy":"о","odash":"⊝","odblac":"ő","odiv":"⨸","odot":"⊙","odsold":"⦼","oelig":"œ","ofcir":"⦿","ofr":"𝔬","ogon":"˛","ograv":"ò","ograve":"ò","ogt":"⧁","ohbar":"⦵","ohm":"Ω","oint":"∮","olarr":"↺","olcir":"⦾","olcross":"⦻","oline":"‾","olt":"⧀","omacr":"ō","omega":"ω","omicron":"ο","omid":"⦶","ominus":"⊖","oopf":"𝕠","opar":"⦷","operp":"⦹","oplus":"⊕","or":"∨","orarr":"↻","ord":"º","order":"ℴ","orderof":"ℴ","ordf":"ª","ordm":"º","origof":"⊶","oror":"⩖","orslope":"⩗","orv":"⩛","oscr":"ℴ","oslas":"ø","oslash":"ø","osol":"⊘","otild":"õ","otilde":"õ","otimes":"⊗","otimesas":"⨶","oum":"ö","ouml":"ö","ovbar":"⌽","par":"¶","para":"¶","parallel":"∥","parsim":"⫳","parsl":"⫽","part":"∂","pcy":"п","percnt":"%","period":".","permil":"‰","perp":"⊥","pertenk":"‱","pfr":"𝔭","phi":"φ","phiv":"ϕ","phmmat":"ℳ","phone":"☎","pi":"π","pitchfork":"⋔","piv":"ϖ","planck":"ℏ","planckh":"ℎ","plankv":"ℏ","plus":"+","plusacir":"⨣","plusb":"⊞","pluscir":"⨢","plusdo":"∔","plusdu":"⨥","pluse":"⩲","plusm":"±","plusmn":"±","plussim":"⨦","plustwo":"⨧","pm":"±","pointint":"⨕","popf":"𝕡","poun":"£","pound":"£","pr":"≺","prE":"⪳","prap":"⪷","prcue":"≼","pre":"⪯","prec":"≺","precapprox":"⪷","preccurlyeq":"≼","preceq":"⪯","precnapprox":"⪹","precneqq":"⪵","precnsim":"⋨","precsim":"≾","prime":"′","primes":"ℙ","prnE":"⪵","prnap":"⪹","prnsim":"⋨","prod":"∏","profalar":"⌮","profline":"⌒","profsurf":"⌓","prop":"∝","propto":"∝","prsim":"≾","prurel":"⊰","pscr":"𝓅","psi":"ψ","puncsp":" ","qfr":"𝔮","qint":"⨌","qopf":"𝕢","qprime":"⁗","qscr":"𝓆","quaternions":"ℍ","quatint":"⨖","quest":"?","questeq":"≟","quo":"\"","quot":"\"","rAarr":"⇛","rArr":"⇒","rAtail":"⤜","rBarr":"⤏","rHar":"⥤","race":"∽̱","racute":"ŕ","radic":"√","raemptyv":"⦳","rang":"⟩","rangd":"⦒","range":"⦥","rangle":"⟩","raqu":"»","raquo":"»","rarr":"→","rarrap":"⥵","rarrb":"⇥","rarrbfs":"⤠","rarrc":"⤳","rarrfs":"⤞","rarrhk":"↪","rarrlp":"↬","rarrpl":"⥅","rarrsim":"⥴","rarrtl":"↣","rarrw":"↝","ratail":"⤚","ratio":"∶","rationals":"ℚ","rbarr":"⤍","rbbrk":"❳","rbrace":"}","rbrack":"]","rbrke":"⦌","rbrksld":"⦎","rbrkslu":"⦐","rcaron":"ř","rcedil":"ŗ","rceil":"⌉","rcub":"}","rcy":"р","rdca":"⤷","rdldhar":"⥩","rdquo":"”","rdquor":"”","rdsh":"↳","real":"ℜ","realine":"ℛ","realpart":"ℜ","reals":"ℝ","rect":"▭","re":"®","reg":"®","rfisht":"⥽","rfloor":"⌋","rfr":"𝔯","rhard":"⇁","rharu":"⇀","rharul":"⥬","rho":"ρ","rhov":"ϱ","rightarrow":"→","rightarrowtail":"↣","rightharpoondown":"⇁","rightharpoonup":"⇀","rightleftarrows":"⇄","rightleftharpoons":"⇌","rightrightarrows":"⇉","rightsquigarrow":"↝","rightthreetimes":"⋌","ring":"˚","risingdotseq":"≓","rlarr":"⇄","rlhar":"⇌","rlm":"‏","rmoust":"⎱","rmoustache":"⎱","rnmid":"⫮","roang":"⟭","roarr":"⇾","robrk":"⟧","ropar":"⦆","ropf":"𝕣","roplus":"⨮","rotimes":"⨵","rpar":")","rpargt":"⦔","rppolint":"⨒","rrarr":"⇉","rsaquo":"›","rscr":"𝓇","rsh":"↱","rsqb":"]","rsquo":"’","rsquor":"’","rthree":"⋌","rtimes":"⋊","rtri":"▹","rtrie":"⊵","rtrif":"▸","rtriltri":"⧎","ruluhar":"⥨","rx":"℞","sacute":"ś","sbquo":"‚","sc":"≻","scE":"⪴","scap":"⪸","scaron":"š","sccue":"≽","sce":"⪰","scedil":"ş","scirc":"ŝ","scnE":"⪶","scnap":"⪺","scnsim":"⋩","scpolint":"⨓","scsim":"≿","scy":"с","sdot":"⋅","sdotb":"⊡","sdote":"⩦","seArr":"⇘","searhk":"⤥","searr":"↘","searrow":"↘","sec":"§","sect":"§","semi":";","seswar":"⤩","setminus":"∖","setmn":"∖","sext":"✶","sfr":"𝔰","sfrown":"⌢","sharp":"♯","shchcy":"щ","shcy":"ш","shortmid":"∣","shortparallel":"∥","sh":"­","shy":"­","sigma":"σ","sigmaf":"ς","sigmav":"ς","sim":"∼","simdot":"⩪","sime":"≃","simeq":"≃","simg":"⪞","simgE":"⪠","siml":"⪝","simlE":"⪟","simne":"≆","simplus":"⨤","simrarr":"⥲","slarr":"←","smallsetminus":"∖","smashp":"⨳","smeparsl":"⧤","smid":"∣","smile":"⌣","smt":"⪪","smte":"⪬","smtes":"⪬︀","softcy":"ь","sol":"/","solb":"⧄","solbar":"⌿","sopf":"𝕤","spades":"♠","spadesuit":"♠","spar":"∥","sqcap":"⊓","sqcaps":"⊓︀","sqcup":"⊔","sqcups":"⊔︀","sqsub":"⊏","sqsube":"⊑","sqsubset":"⊏","sqsubseteq":"⊑","sqsup":"⊐","sqsupe":"⊒","sqsupset":"⊐","sqsupseteq":"⊒","squ":"□","square":"□","squarf":"▪","squf":"▪","srarr":"→","sscr":"𝓈","ssetmn":"∖","ssmile":"⌣","sstarf":"⋆","star":"☆","starf":"★","straightepsilon":"ϵ","straightphi":"ϕ","strns":"¯","sub":"⊂","subE":"⫅","subdot":"⪽","sube":"⊆","subedot":"⫃","submult":"⫁","subnE":"⫋","subne":"⊊","subplus":"⪿","subrarr":"⥹","subset":"⊂","subseteq":"⊆","subseteqq":"⫅","subsetneq":"⊊","subsetneqq":"⫋","subsim":"⫇","subsub":"⫕","subsup":"⫓","succ":"≻","succapprox":"⪸","succcurlyeq":"≽","succeq":"⪰","succnapprox":"⪺","succneqq":"⪶","succnsim":"⋩","succsim":"≿","sum":"∑","sung":"♪","sup":"⊃","sup1":"¹","sup2":"²","sup3":"³","supE":"⫆","supdot":"⪾","supdsub":"⫘","supe":"⊇","supedot":"⫄","suphsol":"⟉","suphsub":"⫗","suplarr":"⥻","supmult":"⫂","supnE":"⫌","supne":"⊋","supplus":"⫀","supset":"⊃","supseteq":"⊇","supseteqq":"⫆","supsetneq":"⊋","supsetneqq":"⫌","supsim":"⫈","supsub":"⫔","supsup":"⫖","swArr":"⇙","swarhk":"⤦","swarr":"↙","swarrow":"↙","swnwar":"⤪","szli":"ß","szlig":"ß","target":"⌖","tau":"τ","tbrk":"⎴","tcaron":"ť","tcedil":"ţ","tcy":"т","tdot":"⃛","telrec":"⌕","tfr":"𝔱","there4":"∴","therefore":"∴","theta":"θ","thetasym":"ϑ","thetav":"ϑ","thickapprox":"≈","thicksim":"∼","thinsp":" ","thkap":"≈","thksim":"∼","thor":"þ","thorn":"þ","tilde":"˜","time":"×","times":"×","timesb":"⊠","timesbar":"⨱","timesd":"⨰","tint":"∭","toea":"⤨","top":"⊤","topbot":"⌶","topcir":"⫱","topf":"𝕥","topfork":"⫚","tosa":"⤩","tprime":"‴","trade":"™","triangle":"▵","triangledown":"▿","triangleleft":"◃","trianglelefteq":"⊴","triangleq":"≜","triangleright":"▹","trianglerighteq":"⊵","tridot":"◬","trie":"≜","triminus":"⨺","triplus":"⨹","trisb":"⧍","tritime":"⨻","trpezium":"⏢","tscr":"𝓉","tscy":"ц","tshcy":"ћ","tstrok":"ŧ","twixt":"≬","twoheadleftarrow":"↞","twoheadrightarrow":"↠","uArr":"⇑","uHar":"⥣","uacut":"ú","uacute":"ú","uarr":"↑","ubrcy":"ў","ubreve":"ŭ","ucir":"û","ucirc":"û","ucy":"у","udarr":"⇅","udblac":"ű","udhar":"⥮","ufisht":"⥾","ufr":"𝔲","ugrav":"ù","ugrave":"ù","uharl":"↿","uharr":"↾","uhblk":"▀","ulcorn":"⌜","ulcorner":"⌜","ulcrop":"⌏","ultri":"◸","umacr":"ū","um":"¨","uml":"¨","uogon":"ų","uopf":"𝕦","uparrow":"↑","updownarrow":"↕","upharpoonleft":"↿","upharpoonright":"↾","uplus":"⊎","upsi":"υ","upsih":"ϒ","upsilon":"υ","upuparrows":"⇈","urcorn":"⌝","urcorner":"⌝","urcrop":"⌎","uring":"ů","urtri":"◹","uscr":"𝓊","utdot":"⋰","utilde":"ũ","utri":"▵","utrif":"▴","uuarr":"⇈","uum":"ü","uuml":"ü","uwangle":"⦧","vArr":"⇕","vBar":"⫨","vBarv":"⫩","vDash":"⊨","vangrt":"⦜","varepsilon":"ϵ","varkappa":"ϰ","varnothing":"∅","varphi":"ϕ","varpi":"ϖ","varpropto":"∝","varr":"↕","varrho":"ϱ","varsigma":"ς","varsubsetneq":"⊊︀","varsubsetneqq":"⫋︀","varsupsetneq":"⊋︀","varsupsetneqq":"⫌︀","vartheta":"ϑ","vartriangleleft":"⊲","vartriangleright":"⊳","vcy":"в","vdash":"⊢","vee":"∨","veebar":"⊻","veeeq":"≚","vellip":"⋮","verbar":"|","vert":"|","vfr":"𝔳","vltri":"⊲","vnsub":"⊂⃒","vnsup":"⊃⃒","vopf":"𝕧","vprop":"∝","vrtri":"⊳","vscr":"𝓋","vsubnE":"⫋︀","vsubne":"⊊︀","vsupnE":"⫌︀","vsupne":"⊋︀","vzigzag":"⦚","wcirc":"ŵ","wedbar":"⩟","wedge":"∧","wedgeq":"≙","weierp":"℘","wfr":"𝔴","wopf":"𝕨","wp":"℘","wr":"≀","wreath":"≀","wscr":"𝓌","xcap":"⋂","xcirc":"◯","xcup":"⋃","xdtri":"▽","xfr":"𝔵","xhArr":"⟺","xharr":"⟷","xi":"ξ","xlArr":"⟸","xlarr":"⟵","xmap":"⟼","xnis":"⋻","xodot":"⨀","xopf":"𝕩","xoplus":"⨁","xotime":"⨂","xrArr":"⟹","xrarr":"⟶","xscr":"𝓍","xsqcup":"⨆","xuplus":"⨄","xutri":"△","xvee":"⋁","xwedge":"⋀","yacut":"ý","yacute":"ý","yacy":"я","ycirc":"ŷ","ycy":"ы","ye":"¥","yen":"¥","yfr":"𝔶","yicy":"ї","yopf":"𝕪","yscr":"𝓎","yucy":"ю","yum":"ÿ","yuml":"ÿ","zacute":"ź","zcaron":"ž","zcy":"з","zdot":"ż","zeetrf":"ℨ","zeta":"ζ","zfr":"𝔷","zhcy":"ж","zigrarr":"⇝","zopf":"𝕫","zscr":"𝓏","zwj":"‍","zwnj":"‌"}; /***/ }), /* 216 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = factory // Construct a tokenizer. This creates both `tokenizeInline` and `tokenizeBlock`. function factory(type) { return tokenize // Tokenizer for a bound `type`. function tokenize(value, location) { var self = this var offset = self.offset var tokens = [] var methods = self[type + 'Methods'] var tokenizers = self[type + 'Tokenizers'] var line = location.line var column = location.column var index var length var method var name var matched var valueLength // Trim white space only lines. if (!value) { return tokens } // Expose on `eat`. eat.now = now eat.file = self.file // Sync initial offset. updatePosition('') // Iterate over `value`, and iterate over all tokenizers. When one eats // something, re-iterate with the remaining value. If no tokenizer eats, // something failed (should not happen) and an exception is thrown. while (value) { index = -1 length = methods.length matched = false while (++index < length) { name = methods[index] method = tokenizers[name] if ( method && /* istanbul ignore next */ (!method.onlyAtStart || self.atStart) && (!method.notInList || !self.inList) && (!method.notInBlock || !self.inBlock) && (!method.notInLink || !self.inLink) ) { valueLength = value.length method.apply(self, [eat, value]) matched = valueLength !== value.length if (matched) { break } } } /* istanbul ignore if */ if (!matched) { self.file.fail(new Error('Infinite loop'), eat.now()) } } self.eof = now() return tokens // Update line, column, and offset based on `value`. function updatePosition(subvalue) { var lastIndex = -1 var index = subvalue.indexOf('\n') while (index !== -1) { line++ lastIndex = index index = subvalue.indexOf('\n', index + 1) } if (lastIndex === -1) { column += subvalue.length } else { column = subvalue.length - lastIndex } if (line in offset) { if (lastIndex !== -1) { column += offset[line] } else if (column <= offset[line]) { column = offset[line] + 1 } } } // Get offset. Called before the first character is eaten to retrieve the // range’s offsets. function getOffset() { var indentation = [] var pos = line + 1 // Done. Called when the last character is eaten to retrieve the range’s // offsets. return function() { var last = line + 1 while (pos < last) { indentation.push((offset[pos] || 0) + 1) pos++ } return indentation } } // Get the current position. function now() { var pos = {line: line, column: column} pos.offset = self.toOffset(pos) return pos } // Store position information for a node. function Position(start) { this.start = start this.end = now() } // Throw when a value is incorrectly eaten. This shouldn’t happen but will // throw on new, incorrect rules. function validateEat(subvalue) { /* istanbul ignore if */ if (value.substring(0, subvalue.length) !== subvalue) { // Capture stack-trace. self.file.fail( new Error( 'Incorrectly eaten value: please report this warning on https://git.io/vg5Ft' ), now() ) } } // Mark position and patch `node.position`. function position() { var before = now() return update // Add the position to a node. function update(node, indent) { var prev = node.position var start = prev ? prev.start : before var combined = [] var n = prev && prev.end.line var l = before.line node.position = new Position(start) // If there was already a `position`, this node was merged. Fixing // `start` wasn’t hard, but the indent is different. Especially // because some information, the indent between `n` and `l` wasn’t // tracked. Luckily, that space is (should be?) empty, so we can // safely check for it now. if (prev && indent && prev.indent) { combined = prev.indent if (n < l) { while (++n < l) { combined.push((offset[n] || 0) + 1) } combined.push(before.column) } indent = combined.concat(indent) } node.position.indent = indent || [] return node } } // Add `node` to `parent`s children or to `tokens`. Performs merges where // possible. function add(node, parent) { var children = parent ? parent.children : tokens var prev = children[children.length - 1] var fn if ( prev && node.type === prev.type && (node.type === 'text' || node.type === 'blockquote') && mergeable(prev) && mergeable(node) ) { fn = node.type === 'text' ? mergeText : mergeBlockquote node = fn.call(self, prev, node) } if (node !== prev) { children.push(node) } if (self.atStart && tokens.length !== 0) { self.exitStart() } return node } // Remove `subvalue` from `value`. `subvalue` must be at the start of // `value`. function eat(subvalue) { var indent = getOffset() var pos = position() var current = now() validateEat(subvalue) apply.reset = reset reset.test = test apply.test = test value = value.substring(subvalue.length) updatePosition(subvalue) indent = indent() return apply // Add the given arguments, add `position` to the returned node, and // return the node. function apply(node, parent) { return pos(add(pos(node), parent), indent) } // Functions just like apply, but resets the content: the line and // column are reversed, and the eaten value is re-added. This is // useful for nodes with a single type of content, such as lists and // tables. See `apply` above for what parameters are expected. function reset() { var node = apply.apply(null, arguments) line = current.line column = current.column value = subvalue + value return node } // Test the position, after eating, and reverse to a not-eaten state. function test() { var result = pos({}) line = current.line column = current.column value = subvalue + value return result.position } } } } // Check whether a node is mergeable with adjacent nodes. function mergeable(node) { var start var end if (node.type !== 'text' || !node.position) { return true } start = node.position.start end = node.position.end // Only merge nodes which occupy the same size as their `value`. return ( start.line !== end.line || end.column - start.column === node.value.length ) } // Merge two text nodes: `node` into `prev`. function mergeText(prev, node) { prev.value += node.value return prev } // Merge two blockquotes: `node` into `prev`, unless in CommonMark mode. function mergeBlockquote(prev, node) { if (this.options.commonmark) { return node } prev.children = prev.children.concat(node.children) return prev } /***/ }), /* 217 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var xtend = __webpack_require__(7) var escapes = __webpack_require__(81) var defaults = __webpack_require__(82) module.exports = setOptions function setOptions(options) { var self = this var current = self.options var key var value if (options == null) { options = {} } else if (typeof options === 'object') { options = xtend(options) } else { throw new Error('Invalid value `' + options + '` for setting `options`') } for (key in defaults) { value = options[key] if (value == null) { value = current[key] } if ( (key !== 'blocks' && typeof value !== 'boolean') || (key === 'blocks' && typeof value !== 'object') ) { throw new Error( 'Invalid value `' + value + '` for setting `options.' + key + '`' ) } options[key] = value } self.options = options self.escape = escapes(options) return self } /***/ }), /* 218 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = [ 'address', 'article', 'aside', 'base', 'basefont', 'blockquote', 'body', 'caption', 'center', 'col', 'colgroup', 'dd', 'details', 'dialog', 'dir', 'div', 'dl', 'dt', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'frame', 'frameset', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'iframe', 'legend', 'li', 'link', 'main', 'menu', 'menuitem', 'meta', 'nav', 'noframes', 'ol', 'optgroup', 'option', 'p', 'param', 'pre', 'section', 'source', 'title', 'summary', 'table', 'tbody', 'td', 'tfoot', 'th', 'thead', 'title', 'tr', 'track', 'ul' ] /***/ }), /* 219 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var xtend = __webpack_require__(7) var removePosition = __webpack_require__(220) module.exports = parse var lineFeed = '\n' var lineBreaksExpression = /\r\n|\r/g // Parse the bound file. function parse() { var self = this var value = String(self.file) var start = {line: 1, column: 1, offset: 0} var content = xtend(start) var node // Clean non-unix newlines: `\r\n` and `\r` are all changed to `\n`. // This should not affect positional information. value = value.replace(lineBreaksExpression, lineFeed) // BOM. if (value.charCodeAt(0) === 0xfeff) { value = value.slice(1) content.column++ content.offset++ } node = { type: 'root', children: self.tokenizeBlock(value, content), position: {start: start, end: self.eof || xtend(start)} } if (!self.options.position) { removePosition(node, true) } return node } /***/ }), /* 220 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var visit = __webpack_require__(1) module.exports = removePosition /* Remove `position`s from `tree`. */ function removePosition(node, force) { visit(node, force ? hard : soft) return node } function hard(node) { delete node.position } function soft(node) { node.position = undefined } /***/ }), /* 221 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = visitParents var is = __webpack_require__(222) var CONTINUE = true var SKIP = 'skip' var EXIT = false visitParents.CONTINUE = CONTINUE visitParents.SKIP = SKIP visitParents.EXIT = EXIT function visitParents(tree, test, visitor, reverse) { if (typeof test === 'function' && typeof visitor !== 'function') { reverse = visitor visitor = test test = null } one(tree, null, []) // Visit a single node. function one(node, index, parents) { var result if (!test || is(test, node, index, parents[parents.length - 1] || null)) { result = visitor(node, parents) if (result === EXIT) { return result } } if (node.children && result !== SKIP) { return all(node.children, parents.concat(node)) === EXIT ? EXIT : result } return result } // Visit children in `parent`. function all(children, parents) { var min = -1 var step = reverse ? -1 : 1 var index = (reverse ? children.length : min) + step var child var result while (index > min && index < children.length) { child = children[index] result = child && one(child, index, parents) if (result === EXIT) { return result } index = typeof result === 'number' ? result : index + step } } } /***/ }), /* 222 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /* eslint-disable max-params */ /* Expose. */ module.exports = is /* Assert if `test` passes for `node`. * When a `parent` node is known the `index` of node */ function is(test, node, index, parent, context) { var hasParent = parent !== null && parent !== undefined var hasIndex = index !== null && index !== undefined var check = convert(test) if ( hasIndex && (typeof index !== 'number' || index < 0 || index === Infinity) ) { throw new Error('Expected positive finite index or child node') } if (hasParent && (!is(null, parent) || !parent.children)) { throw new Error('Expected parent node') } if (!node || !node.type || typeof node.type !== 'string') { return false } if (hasParent !== hasIndex) { throw new Error('Expected both parent and index') } return Boolean(check.call(context, node, index, parent)) } function convert(test) { if (typeof test === 'string') { return typeFactory(test) } if (test === null || test === undefined) { return ok } if (typeof test === 'object') { return ('length' in test ? anyFactory : matchesFactory)(test) } if (typeof test === 'function') { return test } throw new Error('Expected function, string, or object as test') } function convertAll(tests) { var results = [] var length = tests.length var index = -1 while (++index < length) { results[index] = convert(tests[index]) } return results } /* Utility assert each property in `test` is represented * in `node`, and each values are strictly equal. */ function matchesFactory(test) { return matches function matches(node) { var key for (key in test) { if (node[key] !== test[key]) { return false } } return true } } function anyFactory(tests) { var checks = convertAll(tests) var length = checks.length return matches function matches() { var index = -1 while (++index < length) { if (checks[index].apply(this, arguments)) { return true } } return false } } /* Utility to convert a string into a function which checks * a given node’s type for said string. */ function typeFactory(test) { return type function type(node) { return Boolean(node && node.type === test) } } /* Utility to return true. */ function ok() { return true } /***/ }), /* 223 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var whitespace = __webpack_require__(8) module.exports = newline var lineFeed = '\n' function newline(eat, value, silent) { var character = value.charAt(0) var length var subvalue var queue var index if (character !== lineFeed) { return } /* istanbul ignore if - never used (yet) */ if (silent) { return true } index = 1 length = value.length subvalue = character queue = '' while (index < length) { character = value.charAt(index) if (!whitespace(character)) { break } queue += character if (character === lineFeed) { subvalue += queue queue = '' } index++ } eat(subvalue) } /***/ }), /* 224 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var repeat = __webpack_require__(10) var trim = __webpack_require__(40) module.exports = indentedCode var lineFeed = '\n' var tab = '\t' var space = ' ' var tabSize = 4 var codeIndent = repeat(space, tabSize) function indentedCode(eat, value, silent) { var index = -1 var length = value.length var subvalue = '' var content = '' var subvalueQueue = '' var contentQueue = '' var character var blankQueue var indent while (++index < length) { character = value.charAt(index) if (indent) { indent = false subvalue += subvalueQueue content += contentQueue subvalueQueue = '' contentQueue = '' if (character === lineFeed) { subvalueQueue = character contentQueue = character } else { subvalue += character content += character while (++index < length) { character = value.charAt(index) if (!character || character === lineFeed) { contentQueue = character subvalueQueue = character break } subvalue += character content += character } } } else if ( character === space && value.charAt(index + 1) === character && value.charAt(index + 2) === character && value.charAt(index + 3) === character ) { subvalueQueue += codeIndent index += 3 indent = true } else if (character === tab) { subvalueQueue += character indent = true } else { blankQueue = '' while (character === tab || character === space) { blankQueue += character character = value.charAt(++index) } if (character !== lineFeed) { break } subvalueQueue += blankQueue + character contentQueue += character } } if (content) { if (silent) { return true } return eat(subvalue)({ type: 'code', lang: null, meta: null, value: trim(content) }) } } /***/ }), /* 225 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var trim = __webpack_require__(40) module.exports = fencedCode var lineFeed = '\n' var tab = '\t' var space = ' ' var tilde = '~' var graveAccent = '`' var minFenceCount = 3 var tabSize = 4 function fencedCode(eat, value, silent) { var self = this var gfm = self.options.gfm var length = value.length + 1 var index = 0 var subvalue = '' var fenceCount var marker var character var flag var lang var meta var queue var content var exdentedContent var closing var exdentedClosing var indent var now if (!gfm) { return } // Eat initial spacing. while (index < length) { character = value.charAt(index) if (character !== space && character !== tab) { break } subvalue += character index++ } indent = index // Eat the fence. character = value.charAt(index) if (character !== tilde && character !== graveAccent) { return } index++ marker = character fenceCount = 1 subvalue += character while (index < length) { character = value.charAt(index) if (character !== marker) { break } subvalue += character fenceCount++ index++ } if (fenceCount < minFenceCount) { return } // Eat spacing before flag. while (index < length) { character = value.charAt(index) if (character !== space && character !== tab) { break } subvalue += character index++ } // Eat flag. flag = '' queue = '' while (index < length) { character = value.charAt(index) if ( character === lineFeed || character === tilde || character === graveAccent ) { break } if (character === space || character === tab) { queue += character } else { flag += queue + character queue = '' } index++ } character = value.charAt(index) if (character && character !== lineFeed) { return } if (silent) { return true } now = eat.now() now.column += subvalue.length now.offset += subvalue.length subvalue += flag flag = self.decode.raw(self.unescape(flag), now) if (queue) { subvalue += queue } queue = '' closing = '' exdentedClosing = '' content = '' exdentedContent = '' // Eat content. while (index < length) { character = value.charAt(index) content += closing exdentedContent += exdentedClosing closing = '' exdentedClosing = '' if (character !== lineFeed) { content += character exdentedClosing += character index++ continue } // Add the newline to `subvalue` if its the first character. Otherwise, // add it to the `closing` queue. if (content) { closing += character exdentedClosing += character } else { subvalue += character } queue = '' index++ while (index < length) { character = value.charAt(index) if (character !== space) { break } queue += character index++ } closing += queue exdentedClosing += queue.slice(indent) if (queue.length >= tabSize) { continue } queue = '' while (index < length) { character = value.charAt(index) if (character !== marker) { break } queue += character index++ } closing += queue exdentedClosing += queue if (queue.length < fenceCount) { continue } queue = '' while (index < length) { character = value.charAt(index) if (character !== space && character !== tab) { break } closing += character exdentedClosing += character index++ } if (!character || character === lineFeed) { break } } subvalue += content + closing // Get lang and meta from the flag. index = -1 length = flag.length while (++index < length) { character = flag.charAt(index) if (character === space || character === tab) { if (!lang) { lang = flag.slice(0, index) } } else if (lang) { meta = flag.slice(index) break } } return eat(subvalue)({ type: 'code', lang: lang || flag || null, meta: meta || null, value: trim(exdentedContent) }) } /***/ }), /* 226 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var trim = __webpack_require__(14) var interrupt = __webpack_require__(41) module.exports = blockquote var lineFeed = '\n' var tab = '\t' var space = ' ' var greaterThan = '>' function blockquote(eat, value, silent) { var self = this var offsets = self.offset var tokenizers = self.blockTokenizers var interruptors = self.interruptBlockquote var now = eat.now() var currentLine = now.line var length = value.length var values = [] var contents = [] var indents = [] var add var index = 0 var character var rest var nextIndex var content var line var startIndex var prefixed var exit while (index < length) { character = value.charAt(index) if (character !== space && character !== tab) { break } index++ } if (value.charAt(index) !== greaterThan) { return } if (silent) { return true } index = 0 while (index < length) { nextIndex = value.indexOf(lineFeed, index) startIndex = index prefixed = false if (nextIndex === -1) { nextIndex = length } while (index < length) { character = value.charAt(index) if (character !== space && character !== tab) { break } index++ } if (value.charAt(index) === greaterThan) { index++ prefixed = true if (value.charAt(index) === space) { index++ } } else { index = startIndex } content = value.slice(index, nextIndex) if (!prefixed && !trim(content)) { index = startIndex break } if (!prefixed) { rest = value.slice(index) // Check if the following code contains a possible block. if (interrupt(interruptors, tokenizers, self, [eat, rest, true])) { break } } line = startIndex === index ? content : value.slice(startIndex, nextIndex) indents.push(index - startIndex) values.push(line) contents.push(content) index = nextIndex + 1 } index = -1 length = indents.length add = eat(values.join(lineFeed)) while (++index < length) { offsets[currentLine] = (offsets[currentLine] || 0) + indents[index] currentLine++ } exit = self.enterBlock() contents = self.tokenizeBlock(contents.join(lineFeed), now) exit() return add({type: 'blockquote', children: contents}) } /***/ }), /* 227 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = atxHeading var lineFeed = '\n' var tab = '\t' var space = ' ' var numberSign = '#' var maxFenceCount = 6 function atxHeading(eat, value, silent) { var self = this var pedantic = self.options.pedantic var length = value.length + 1 var index = -1 var now = eat.now() var subvalue = '' var content = '' var character var queue var depth // Eat initial spacing. while (++index < length) { character = value.charAt(index) if (character !== space && character !== tab) { index-- break } subvalue += character } // Eat hashes. depth = 0 while (++index <= length) { character = value.charAt(index) if (character !== numberSign) { index-- break } subvalue += character depth++ } if (depth > maxFenceCount) { return } if (!depth || (!pedantic && value.charAt(index + 1) === numberSign)) { return } length = value.length + 1 // Eat intermediate white-space. queue = '' while (++index < length) { character = value.charAt(index) if (character !== space && character !== tab) { index-- break } queue += character } // Exit when not in pedantic mode without spacing. if (!pedantic && queue.length === 0 && character && character !== lineFeed) { return } if (silent) { return true } // Eat content. subvalue += queue queue = '' content = '' while (++index < length) { character = value.charAt(index) if (!character || character === lineFeed) { break } if (character !== space && character !== tab && character !== numberSign) { content += queue + character queue = '' continue } while (character === space || character === tab) { queue += character character = value.charAt(++index) } // `#` without a queue is part of the content. if (!pedantic && content && !queue && character === numberSign) { content += character continue } while (character === numberSign) { queue += character character = value.charAt(++index) } while (character === space || character === tab) { queue += character character = value.charAt(++index) } index-- } now.column += subvalue.length now.offset += subvalue.length subvalue += content + queue return eat(subvalue)({ type: 'heading', depth: depth, children: self.tokenizeInline(content, now) }) } /***/ }), /* 228 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = thematicBreak var tab = '\t' var lineFeed = '\n' var space = ' ' var asterisk = '*' var dash = '-' var underscore = '_' var maxCount = 3 function thematicBreak(eat, value, silent) { var index = -1 var length = value.length + 1 var subvalue = '' var character var marker var markerCount var queue while (++index < length) { character = value.charAt(index) if (character !== tab && character !== space) { break } subvalue += character } if ( character !== asterisk && character !== dash && character !== underscore ) { return } marker = character subvalue += character markerCount = 1 queue = '' while (++index < length) { character = value.charAt(index) if (character === marker) { markerCount++ subvalue += queue + marker queue = '' } else if (character === space) { queue += character } else if ( markerCount >= maxCount && (!character || character === lineFeed) ) { subvalue += queue if (silent) { return true } return eat(subvalue)({type: 'thematicBreak'}) } else { return } } } /***/ }), /* 229 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /* eslint-disable max-params */ var trim = __webpack_require__(14) var repeat = __webpack_require__(10) var decimal = __webpack_require__(23) var getIndent = __webpack_require__(83) var removeIndent = __webpack_require__(230) var interrupt = __webpack_require__(41) module.exports = list var asterisk = '*' var underscore = '_' var plusSign = '+' var dash = '-' var dot = '.' var space = ' ' var lineFeed = '\n' var tab = '\t' var rightParenthesis = ')' var lowercaseX = 'x' var tabSize = 4 var looseListItemExpression = /\n\n(?!\s*$)/ var taskItemExpression = /^\[([ \t]|x|X)][ \t]/ var bulletExpression = /^([ \t]*)([*+-]|\d+[.)])( {1,4}(?! )| |\t|$|(?=\n))([^\n]*)/ var pedanticBulletExpression = /^([ \t]*)([*+-]|\d+[.)])([ \t]+)/ var initialIndentExpression = /^( {1,4}|\t)?/gm function list(eat, value, silent) { var self = this var commonmark = self.options.commonmark var pedantic = self.options.pedantic var tokenizers = self.blockTokenizers var interuptors = self.interruptList var index = 0 var length = value.length var start = null var size = 0 var queue var ordered var character var marker var nextIndex var startIndex var prefixed var currentMarker var content var line var prevEmpty var empty var items var allLines var emptyLines var item var enterTop var exitBlockquote var spread = false var node var now var end var indented while (index < length) { character = value.charAt(index) if (character === tab) { size += tabSize - (size % tabSize) } else if (character === space) { size++ } else { break } index++ } if (size >= tabSize) { return } character = value.charAt(index) if (character === asterisk || character === plusSign || character === dash) { marker = character ordered = false } else { ordered = true queue = '' while (index < length) { character = value.charAt(index) if (!decimal(character)) { break } queue += character index++ } character = value.charAt(index) if ( !queue || !(character === dot || (commonmark && character === rightParenthesis)) ) { return } start = parseInt(queue, 10) marker = character } character = value.charAt(++index) if ( character !== space && character !== tab && (pedantic || (character !== lineFeed && character !== '')) ) { return } if (silent) { return true } index = 0 items = [] allLines = [] emptyLines = [] while (index < length) { nextIndex = value.indexOf(lineFeed, index) startIndex = index prefixed = false indented = false if (nextIndex === -1) { nextIndex = length } end = index + tabSize size = 0 while (index < length) { character = value.charAt(index) if (character === tab) { size += tabSize - (size % tabSize) } else if (character === space) { size++ } else { break } index++ } if (size >= tabSize) { indented = true } if (item && size >= item.indent) { indented = true } character = value.charAt(index) currentMarker = null if (!indented) { if ( character === asterisk || character === plusSign || character === dash ) { currentMarker = character index++ size++ } else { queue = '' while (index < length) { character = value.charAt(index) if (!decimal(character)) { break } queue += character index++ } character = value.charAt(index) index++ if ( queue && (character === dot || (commonmark && character === rightParenthesis)) ) { currentMarker = character size += queue.length + 1 } } if (currentMarker) { character = value.charAt(index) if (character === tab) { size += tabSize - (size % tabSize) index++ } else if (character === space) { end = index + tabSize while (index < end) { if (value.charAt(index) !== space) { break } index++ size++ } if (index === end && value.charAt(index) === space) { index -= tabSize - 1 size -= tabSize - 1 } } else if (character !== lineFeed && character !== '') { currentMarker = null } } } if (currentMarker) { if (!pedantic && marker !== currentMarker) { break } prefixed = true } else { if (!commonmark && !indented && value.charAt(startIndex) === space) { indented = true } else if (commonmark && item) { indented = size >= item.indent || size > tabSize } prefixed = false index = startIndex } line = value.slice(startIndex, nextIndex) content = startIndex === index ? line : value.slice(index, nextIndex) if ( currentMarker === asterisk || currentMarker === underscore || currentMarker === dash ) { if (tokenizers.thematicBreak.call(self, eat, line, true)) { break } } prevEmpty = empty empty = !prefixed && !trim(content).length if (indented && item) { item.value = item.value.concat(emptyLines, line) allLines = allLines.concat(emptyLines, line) emptyLines = [] } else if (prefixed) { if (emptyLines.length !== 0) { spread = true item.value.push('') item.trail = emptyLines.concat() } item = { value: [line], indent: size, trail: [] } items.push(item) allLines = allLines.concat(emptyLines, line) emptyLines = [] } else if (empty) { if (prevEmpty && !commonmark) { break } emptyLines.push(line) } else { if (prevEmpty) { break } if (interrupt(interuptors, tokenizers, self, [eat, line, true])) { break } item.value = item.value.concat(emptyLines, line) allLines = allLines.concat(emptyLines, line) emptyLines = [] } index = nextIndex + 1 } node = eat(allLines.join(lineFeed)).reset({ type: 'list', ordered: ordered, start: start, spread: spread, children: [] }) enterTop = self.enterList() exitBlockquote = self.enterBlock() index = -1 length = items.length while (++index < length) { item = items[index].value.join(lineFeed) now = eat.now() eat(item)(listItem(self, item, now), node) item = items[index].trail.join(lineFeed) if (index !== length - 1) { item += lineFeed } eat(item) } enterTop() exitBlockquote() return node } function listItem(ctx, value, position) { var offsets = ctx.offset var fn = ctx.options.pedantic ? pedanticListItem : normalListItem var checked = null var task var indent value = fn.apply(null, arguments) if (ctx.options.gfm) { task = value.match(taskItemExpression) if (task) { indent = task[0].length checked = task[1].toLowerCase() === lowercaseX offsets[position.line] += indent value = value.slice(indent) } } return { type: 'listItem', spread: looseListItemExpression.test(value), checked: checked, children: ctx.tokenizeBlock(value, position) } } // Create a list-item using overly simple mechanics. function pedanticListItem(ctx, value, position) { var offsets = ctx.offset var line = position.line // Remove the list-item’s bullet. value = value.replace(pedanticBulletExpression, replacer) // The initial line was also matched by the below, so we reset the `line`. line = position.line return value.replace(initialIndentExpression, replacer) // A simple replacer which removed all matches, and adds their length to // `offset`. function replacer($0) { offsets[line] = (offsets[line] || 0) + $0.length line++ return '' } } // Create a list-item using sane mechanics. function normalListItem(ctx, value, position) { var offsets = ctx.offset var line = position.line var max var bullet var rest var lines var trimmedLines var index var length // Remove the list-item’s bullet. value = value.replace(bulletExpression, replacer) lines = value.split(lineFeed) trimmedLines = removeIndent(value, getIndent(max).indent).split(lineFeed) // We replaced the initial bullet with something else above, which was used // to trick `removeIndentation` into removing some more characters when // possible. However, that could result in the initial line to be stripped // more than it should be. trimmedLines[0] = rest offsets[line] = (offsets[line] || 0) + bullet.length line++ index = 0 length = lines.length while (++index < length) { offsets[line] = (offsets[line] || 0) + lines[index].length - trimmedLines[index].length line++ } return trimmedLines.join(lineFeed) function replacer($0, $1, $2, $3, $4) { bullet = $1 + $2 + $3 rest = $4 // Make sure that the first nine numbered list items can indent with an // extra space. That is, when the bullet did not receive an extra final // space. if (Number($2) < 10 && bullet.length % 2 === 1) { $2 = space + $2 } max = $1 + repeat(space, $2.length) + $3 return max + rest } } /***/ }), /* 230 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var trim = __webpack_require__(14) var repeat = __webpack_require__(10) var getIndent = __webpack_require__(83) module.exports = indentation var tab = '\t' var lineFeed = '\n' var space = ' ' var exclamationMark = '!' // Remove the minimum indent from every line in `value`. Supports both tab, // spaced, and mixed indentation (as well as possible). function indentation(value, maximum) { var values = value.split(lineFeed) var position = values.length + 1 var minIndent = Infinity var matrix = [] var index var indentation var stops var padding values.unshift(repeat(space, maximum) + exclamationMark) while (position--) { indentation = getIndent(values[position]) matrix[position] = indentation.stops if (trim(values[position]).length === 0) { continue } if (indentation.indent) { if (indentation.indent > 0 && indentation.indent < minIndent) { minIndent = indentation.indent } } else { minIndent = Infinity break } } if (minIndent !== Infinity) { position = values.length while (position--) { stops = matrix[position] index = minIndent while (index && !(index in stops)) { index-- } if ( trim(values[position]).length !== 0 && minIndent && index !== minIndent ) { padding = tab } else { padding = '' } values[position] = padding + values[position].slice(index in stops ? stops[index] + 1 : 0) } } values.shift() return values.join(lineFeed) } /***/ }), /* 231 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = setextHeading var lineFeed = '\n' var tab = '\t' var space = ' ' var equalsTo = '=' var dash = '-' var maxIndent = 3 var equalsToDepth = 1 var dashDepth = 2 function setextHeading(eat, value, silent) { var self = this var now = eat.now() var length = value.length var index = -1 var subvalue = '' var content var queue var character var marker var depth // Eat initial indentation. while (++index < length) { character = value.charAt(index) if (character !== space || index >= maxIndent) { index-- break } subvalue += character } // Eat content. content = '' queue = '' while (++index < length) { character = value.charAt(index) if (character === lineFeed) { index-- break } if (character === space || character === tab) { queue += character } else { content += queue + character queue = '' } } now.column += subvalue.length now.offset += subvalue.length subvalue += content + queue // Ensure the content is followed by a newline and a valid marker. character = value.charAt(++index) marker = value.charAt(++index) if (character !== lineFeed || (marker !== equalsTo && marker !== dash)) { return } subvalue += character // Eat Setext-line. queue = marker depth = marker === equalsTo ? equalsToDepth : dashDepth while (++index < length) { character = value.charAt(index) if (character !== marker) { if (character !== lineFeed) { return } index-- break } queue += character } if (silent) { return true } return eat(subvalue + queue)({ type: 'heading', depth: depth, children: self.tokenizeInline(content, now) }) } /***/ }), /* 232 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var openCloseTag = __webpack_require__(84).openCloseTag module.exports = blockHtml var tab = '\t' var space = ' ' var lineFeed = '\n' var lessThan = '<' var rawOpenExpression = /^<(script|pre|style)(?=(\s|>|$))/i var rawCloseExpression = /<\/(script|pre|style)>/i var commentOpenExpression = /^/ var instructionOpenExpression = /^<\?/ var instructionCloseExpression = /\?>/ var directiveOpenExpression = /^/ var cdataOpenExpression = /^/ var elementCloseExpression = /^$/ var otherElementOpenExpression = new RegExp(openCloseTag.source + '\\s*$') function blockHtml(eat, value, silent) { var self = this var blocks = self.options.blocks.join('|') var elementOpenExpression = new RegExp( '^|$))', 'i' ) var length = value.length var index = 0 var next var line var offset var character var count var sequence var subvalue var sequences = [ [rawOpenExpression, rawCloseExpression, true], [commentOpenExpression, commentCloseExpression, true], [instructionOpenExpression, instructionCloseExpression, true], [directiveOpenExpression, directiveCloseExpression, true], [cdataOpenExpression, cdataCloseExpression, true], [elementOpenExpression, elementCloseExpression, true], [otherElementOpenExpression, elementCloseExpression, false] ] // Eat initial spacing. while (index < length) { character = value.charAt(index) if (character !== tab && character !== space) { break } index++ } if (value.charAt(index) !== lessThan) { return } next = value.indexOf(lineFeed, index + 1) next = next === -1 ? length : next line = value.slice(index, next) offset = -1 count = sequences.length while (++offset < count) { if (sequences[offset][0].test(line)) { sequence = sequences[offset] break } } if (!sequence) { return } if (silent) { return sequence[2] } index = next if (!sequence[1].test(line)) { while (index < length) { next = value.indexOf(lineFeed, index + 1) next = next === -1 ? length : next line = value.slice(index + 1, next) if (sequence[1].test(line)) { if (line) { index = next } break } index = next } } subvalue = value.slice(0, index) return eat(subvalue)({type: 'html', value: subvalue}) } /***/ }), /* 233 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var whitespace = __webpack_require__(8) var normalize = __webpack_require__(42) module.exports = footnoteDefinition footnoteDefinition.notInList = true footnoteDefinition.notInBlock = true var backslash = '\\' var lineFeed = '\n' var tab = '\t' var space = ' ' var leftSquareBracket = '[' var rightSquareBracket = ']' var caret = '^' var colon = ':' var EXPRESSION_INITIAL_TAB = /^( {4}|\t)?/gm function footnoteDefinition(eat, value, silent) { var self = this var offsets = self.offset var index var length var subvalue var now var currentLine var content var queue var subqueue var character var identifier var add var exit if (!self.options.footnotes) { return } index = 0 length = value.length subvalue = '' now = eat.now() currentLine = now.line while (index < length) { character = value.charAt(index) if (!whitespace(character)) { break } subvalue += character index++ } if ( value.charAt(index) !== leftSquareBracket || value.charAt(index + 1) !== caret ) { return } subvalue += leftSquareBracket + caret index = subvalue.length queue = '' while (index < length) { character = value.charAt(index) if (character === rightSquareBracket) { break } else if (character === backslash) { queue += character index++ character = value.charAt(index) } queue += character index++ } if ( !queue || value.charAt(index) !== rightSquareBracket || value.charAt(index + 1) !== colon ) { return } if (silent) { return true } identifier = queue subvalue += queue + rightSquareBracket + colon index = subvalue.length while (index < length) { character = value.charAt(index) if (character !== tab && character !== space) { break } subvalue += character index++ } now.column += subvalue.length now.offset += subvalue.length queue = '' content = '' subqueue = '' while (index < length) { character = value.charAt(index) if (character === lineFeed) { subqueue = character index++ while (index < length) { character = value.charAt(index) if (character !== lineFeed) { break } subqueue += character index++ } queue += subqueue subqueue = '' while (index < length) { character = value.charAt(index) if (character !== space) { break } subqueue += character index++ } if (subqueue.length === 0) { break } queue += subqueue } if (queue) { content += queue queue = '' } content += character index++ } subvalue += content content = content.replace(EXPRESSION_INITIAL_TAB, function(line) { offsets[currentLine] = (offsets[currentLine] || 0) + line.length currentLine++ return '' }) add = eat(subvalue) exit = self.enterBlock() content = self.tokenizeBlock(content, now) exit() return add({ type: 'footnoteDefinition', identifier: normalize(identifier), label: identifier, children: content }) } /***/ }), /* 234 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = collapse /* collapse(' \t\nbar \nbaz\t'); // ' bar baz ' */ function collapse(value) { return String(value).replace(/\s+/g, ' ') } /***/ }), /* 235 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var whitespace = __webpack_require__(8) var normalize = __webpack_require__(42) module.exports = definition definition.notInList = true definition.notInBlock = true var quotationMark = '"' var apostrophe = "'" var backslash = '\\' var lineFeed = '\n' var tab = '\t' var space = ' ' var leftSquareBracket = '[' var rightSquareBracket = ']' var leftParenthesis = '(' var rightParenthesis = ')' var colon = ':' var lessThan = '<' var greaterThan = '>' function definition(eat, value, silent) { var self = this var commonmark = self.options.commonmark var index = 0 var length = value.length var subvalue = '' var beforeURL var beforeTitle var queue var character var test var identifier var url var title while (index < length) { character = value.charAt(index) if (character !== space && character !== tab) { break } subvalue += character index++ } character = value.charAt(index) if (character !== leftSquareBracket) { return } index++ subvalue += character queue = '' while (index < length) { character = value.charAt(index) if (character === rightSquareBracket) { break } else if (character === backslash) { queue += character index++ character = value.charAt(index) } queue += character index++ } if ( !queue || value.charAt(index) !== rightSquareBracket || value.charAt(index + 1) !== colon ) { return } identifier = queue subvalue += queue + rightSquareBracket + colon index = subvalue.length queue = '' while (index < length) { character = value.charAt(index) if (character !== tab && character !== space && character !== lineFeed) { break } subvalue += character index++ } character = value.charAt(index) queue = '' beforeURL = subvalue if (character === lessThan) { index++ while (index < length) { character = value.charAt(index) if (!isEnclosedURLCharacter(character)) { break } queue += character index++ } character = value.charAt(index) if (character === isEnclosedURLCharacter.delimiter) { subvalue += lessThan + queue + character index++ } else { if (commonmark) { return } index -= queue.length + 1 queue = '' } } if (!queue) { while (index < length) { character = value.charAt(index) if (!isUnclosedURLCharacter(character)) { break } queue += character index++ } subvalue += queue } if (!queue) { return } url = queue queue = '' while (index < length) { character = value.charAt(index) if (character !== tab && character !== space && character !== lineFeed) { break } queue += character index++ } character = value.charAt(index) test = null if (character === quotationMark) { test = quotationMark } else if (character === apostrophe) { test = apostrophe } else if (character === leftParenthesis) { test = rightParenthesis } if (!test) { queue = '' index = subvalue.length } else if (queue) { subvalue += queue + character index = subvalue.length queue = '' while (index < length) { character = value.charAt(index) if (character === test) { break } if (character === lineFeed) { index++ character = value.charAt(index) if (character === lineFeed || character === test) { return } queue += lineFeed } queue += character index++ } character = value.charAt(index) if (character !== test) { return } beforeTitle = subvalue subvalue += queue + character index++ title = queue queue = '' } else { return } while (index < length) { character = value.charAt(index) if (character !== tab && character !== space) { break } subvalue += character index++ } character = value.charAt(index) if (!character || character === lineFeed) { if (silent) { return true } beforeURL = eat(beforeURL).test().end url = self.decode.raw(self.unescape(url), beforeURL, {nonTerminated: false}) if (title) { beforeTitle = eat(beforeTitle).test().end title = self.decode.raw(self.unescape(title), beforeTitle) } return eat(subvalue)({ type: 'definition', identifier: normalize(identifier), label: identifier, title: title || null, url: url }) } } // Check if `character` can be inside an enclosed URI. function isEnclosedURLCharacter(character) { return ( character !== greaterThan && character !== leftSquareBracket && character !== rightSquareBracket ) } isEnclosedURLCharacter.delimiter = greaterThan // Check if `character` can be inside an unclosed URI. function isUnclosedURLCharacter(character) { return ( character !== leftSquareBracket && character !== rightSquareBracket && !whitespace(character) ) } /***/ }), /* 236 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var whitespace = __webpack_require__(8) module.exports = table var tab = '\t' var lineFeed = '\n' var space = ' ' var dash = '-' var colon = ':' var backslash = '\\' var graveAccent = '`' var verticalBar = '|' var minColumns = 1 var minRows = 2 var left = 'left' var center = 'center' var right = 'right' function table(eat, value, silent) { var self = this var index var alignments var alignment var subvalue var row var length var lines var queue var character var hasDash var align var cell var preamble var count var opening var now var position var lineCount var line var rows var table var lineIndex var pipeIndex var first // Exit when not in gfm-mode. if (!self.options.gfm) { return } // Get the rows. // Detecting tables soon is hard, so there are some checks for performance // here, such as the minimum number of rows, and allowed characters in the // alignment row. index = 0 lineCount = 0 length = value.length + 1 lines = [] while (index < length) { lineIndex = value.indexOf(lineFeed, index) pipeIndex = value.indexOf(verticalBar, index + 1) if (lineIndex === -1) { lineIndex = value.length } if (pipeIndex === -1 || pipeIndex > lineIndex) { if (lineCount < minRows) { return } break } lines.push(value.slice(index, lineIndex)) lineCount++ index = lineIndex + 1 } // Parse the alignment row. subvalue = lines.join(lineFeed) alignments = lines.splice(1, 1)[0] || [] index = 0 length = alignments.length lineCount-- alignment = false align = [] while (index < length) { character = alignments.charAt(index) if (character === verticalBar) { hasDash = null if (alignment === false) { if (first === false) { return } } else { align.push(alignment) alignment = false } first = false } else if (character === dash) { hasDash = true alignment = alignment || null } else if (character === colon) { if (alignment === left) { alignment = center } else if (hasDash && alignment === null) { alignment = right } else { alignment = left } } else if (!whitespace(character)) { return } index++ } if (alignment !== false) { align.push(alignment) } // Exit when without enough columns. if (align.length < minColumns) { return } /* istanbul ignore if - never used (yet) */ if (silent) { return true } // Parse the rows. position = -1 rows = [] table = eat(subvalue).reset({type: 'table', align: align, children: rows}) while (++position < lineCount) { line = lines[position] row = {type: 'tableRow', children: []} // Eat a newline character when this is not the first row. if (position) { eat(lineFeed) } // Eat the row. eat(line).reset(row, table) length = line.length + 1 index = 0 queue = '' cell = '' preamble = true count = null opening = null while (index < length) { character = line.charAt(index) if (character === tab || character === space) { if (cell) { queue += character } else { eat(character) } index++ continue } if (character === '' || character === verticalBar) { if (preamble) { eat(character) } else { if (character && opening) { queue += character index++ continue } if ((cell || character) && !preamble) { subvalue = cell if (queue.length > 1) { if (character) { subvalue += queue.slice(0, queue.length - 1) queue = queue.charAt(queue.length - 1) } else { subvalue += queue queue = '' } } now = eat.now() eat(subvalue)( {type: 'tableCell', children: self.tokenizeInline(cell, now)}, row ) } eat(queue + character) queue = '' cell = '' } } else { if (queue) { cell += queue queue = '' } cell += character if (character === backslash && index !== length - 2) { cell += line.charAt(index + 1) index++ } if (character === graveAccent) { count = 1 while (line.charAt(index + 1) === character) { cell += character index++ count++ } if (!opening) { opening = count } else if (count >= opening) { opening = 0 } } } preamble = false index++ } // Eat the alignment row. if (!position) { eat(lineFeed + alignments) } } return table } /***/ }), /* 237 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var trim = __webpack_require__(14) var decimal = __webpack_require__(23) var trimTrailingLines = __webpack_require__(40) var interrupt = __webpack_require__(41) module.exports = paragraph var tab = '\t' var lineFeed = '\n' var space = ' ' var tabSize = 4 // Tokenise paragraph. function paragraph(eat, value, silent) { var self = this var settings = self.options var commonmark = settings.commonmark var gfm = settings.gfm var tokenizers = self.blockTokenizers var interruptors = self.interruptParagraph var index = value.indexOf(lineFeed) var length = value.length var position var subvalue var character var size var now while (index < length) { // Eat everything if there’s no following newline. if (index === -1) { index = length break } // Stop if the next character is NEWLINE. if (value.charAt(index + 1) === lineFeed) { break } // In commonmark-mode, following indented lines are part of the paragraph. if (commonmark) { size = 0 position = index + 1 while (position < length) { character = value.charAt(position) if (character === tab) { size = tabSize break } else if (character === space) { size++ } else { break } position++ } if (size >= tabSize && character !== lineFeed) { index = value.indexOf(lineFeed, index + 1) continue } } subvalue = value.slice(index + 1) // Check if the following code contains a possible block. if (interrupt(interruptors, tokenizers, self, [eat, subvalue, true])) { break } // Break if the following line starts a list, when already in a list, or // when in commonmark, or when in gfm mode and the bullet is *not* numeric. if ( tokenizers.list.call(self, eat, subvalue, true) && (self.inList || commonmark || (gfm && !decimal(trim.left(subvalue).charAt(0)))) ) { break } position = index index = value.indexOf(lineFeed, index + 1) if (index !== -1 && trim(value.slice(position, index)) === '') { index = position break } } subvalue = value.slice(0, index) if (trim(subvalue) === '') { eat(subvalue) return null } /* istanbul ignore if - never used (yet) */ if (silent) { return true } now = eat.now() subvalue = trimTrailingLines(subvalue) return eat(subvalue)({ type: 'paragraph', children: self.tokenizeInline(subvalue, now) }) } /***/ }), /* 238 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var locate = __webpack_require__(239) module.exports = escape escape.locator = locate var lineFeed = '\n' var backslash = '\\' function escape(eat, value, silent) { var self = this var character var node if (value.charAt(0) === backslash) { character = value.charAt(1) if (self.escape.indexOf(character) !== -1) { /* istanbul ignore if - never used (yet) */ if (silent) { return true } if (character === lineFeed) { node = {type: 'break'} } else { node = {type: 'text', value: character} } return eat(backslash + character)(node) } } } /***/ }), /* 239 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = locate function locate(value, fromIndex) { return value.indexOf('\\', fromIndex) } /***/ }), /* 240 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var whitespace = __webpack_require__(8) var decode = __webpack_require__(30) var locate = __webpack_require__(85) module.exports = autoLink autoLink.locator = locate autoLink.notInLink = true var lessThan = '<' var greaterThan = '>' var atSign = '@' var slash = '/' var mailto = 'mailto:' var mailtoLength = mailto.length function autoLink(eat, value, silent) { var self = this var subvalue = '' var length = value.length var index = 0 var queue = '' var hasAtCharacter = false var link = '' var character var now var content var tokenizers var exit if (value.charAt(0) !== lessThan) { return } index++ subvalue = lessThan while (index < length) { character = value.charAt(index) if ( whitespace(character) || character === greaterThan || character === atSign || (character === ':' && value.charAt(index + 1) === slash) ) { break } queue += character index++ } if (!queue) { return } link += queue queue = '' character = value.charAt(index) link += character index++ if (character === atSign) { hasAtCharacter = true } else { if (character !== ':' || value.charAt(index + 1) !== slash) { return } link += slash index++ } while (index < length) { character = value.charAt(index) if (whitespace(character) || character === greaterThan) { break } queue += character index++ } character = value.charAt(index) if (!queue || character !== greaterThan) { return } /* istanbul ignore if - never used (yet) */ if (silent) { return true } link += queue content = link subvalue += link + character now = eat.now() now.column++ now.offset++ if (hasAtCharacter) { if (link.slice(0, mailtoLength).toLowerCase() === mailto) { content = content.substr(mailtoLength) now.column += mailtoLength now.offset += mailtoLength } else { link = mailto + link } } // Temporarily remove all tokenizers except text in autolinks. tokenizers = self.inlineTokenizers self.inlineTokenizers = {text: tokenizers.text} exit = self.enterLink() content = self.tokenizeInline(content, now) self.inlineTokenizers = tokenizers exit() return eat(subvalue)({ type: 'link', title: null, url: decode(link, {nonTerminated: false}), children: content }) } /***/ }), /* 241 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var decode = __webpack_require__(30) var whitespace = __webpack_require__(8) var locate = __webpack_require__(242) module.exports = url url.locator = locate url.notInLink = true var quotationMark = '"' var apostrophe = "'" var leftParenthesis = '(' var rightParenthesis = ')' var comma = ',' var dot = '.' var colon = ':' var semicolon = ';' var lessThan = '<' var atSign = '@' var leftSquareBracket = '[' var rightSquareBracket = ']' var http = 'http://' var https = 'https://' var mailto = 'mailto:' var protocols = [http, https, mailto] var protocolsLength = protocols.length function url(eat, value, silent) { var self = this var subvalue var content var character var index var position var protocol var match var length var queue var parenCount var nextCharacter var tokenizers var exit if (!self.options.gfm) { return } subvalue = '' index = -1 while (++index < protocolsLength) { protocol = protocols[index] match = value.slice(0, protocol.length) if (match.toLowerCase() === protocol) { subvalue = match break } } if (!subvalue) { return } index = subvalue.length length = value.length queue = '' parenCount = 0 while (index < length) { character = value.charAt(index) if (whitespace(character) || character === lessThan) { break } if ( character === dot || character === comma || character === colon || character === semicolon || character === quotationMark || character === apostrophe || character === rightParenthesis || character === rightSquareBracket ) { nextCharacter = value.charAt(index + 1) if (!nextCharacter || whitespace(nextCharacter)) { break } } if (character === leftParenthesis || character === leftSquareBracket) { parenCount++ } if (character === rightParenthesis || character === rightSquareBracket) { parenCount-- if (parenCount < 0) { break } } queue += character index++ } if (!queue) { return } subvalue += queue content = subvalue if (protocol === mailto) { position = queue.indexOf(atSign) if (position === -1 || position === length - 1) { return } content = content.substr(mailto.length) } /* istanbul ignore if - never used (yet) */ if (silent) { return true } exit = self.enterLink() // Temporarily remove all tokenizers except text in url. tokenizers = self.inlineTokenizers self.inlineTokenizers = {text: tokenizers.text} content = self.tokenizeInline(content, eat.now()) self.inlineTokenizers = tokenizers exit() return eat(subvalue)({ type: 'link', title: null, url: decode(subvalue, {nonTerminated: false}), children: content }) } /***/ }), /* 242 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = locate var protocols = ['https://', 'http://', 'mailto:'] function locate(value, fromIndex) { var length = protocols.length var index = -1 var min = -1 var position if (!this.options.gfm) { return -1 } while (++index < length) { position = value.indexOf(protocols[index], fromIndex) if (position !== -1 && (position < min || min === -1)) { min = position } } return min } /***/ }), /* 243 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var alphabetical = __webpack_require__(80) var locate = __webpack_require__(85) var tag = __webpack_require__(84).tag module.exports = inlineHTML inlineHTML.locator = locate var lessThan = '<' var questionMark = '?' var exclamationMark = '!' var slash = '/' var htmlLinkOpenExpression = /^/i function inlineHTML(eat, value, silent) { var self = this var length = value.length var character var subvalue if (value.charAt(0) !== lessThan || length < 3) { return } character = value.charAt(1) if ( !alphabetical(character) && character !== questionMark && character !== exclamationMark && character !== slash ) { return } subvalue = value.match(tag) if (!subvalue) { return } /* istanbul ignore if - not used yet. */ if (silent) { return true } subvalue = subvalue[0] if (!self.inLink && htmlLinkOpenExpression.test(subvalue)) { self.inLink = true } else if (self.inLink && htmlLinkCloseExpression.test(subvalue)) { self.inLink = false } return eat(subvalue)({type: 'html', value: subvalue}) } /***/ }), /* 244 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var whitespace = __webpack_require__(8) var locate = __webpack_require__(86) module.exports = link link.locator = locate var lineFeed = '\n' var exclamationMark = '!' var quotationMark = '"' var apostrophe = "'" var leftParenthesis = '(' var rightParenthesis = ')' var lessThan = '<' var greaterThan = '>' var leftSquareBracket = '[' var backslash = '\\' var rightSquareBracket = ']' var graveAccent = '`' function link(eat, value, silent) { var self = this var subvalue = '' var index = 0 var character = value.charAt(0) var pedantic = self.options.pedantic var commonmark = self.options.commonmark var gfm = self.options.gfm var closed var count var opening var beforeURL var beforeTitle var subqueue var hasMarker var isImage var content var marker var length var title var depth var queue var url var now var exit var node // Detect whether this is an image. if (character === exclamationMark) { isImage = true subvalue = character character = value.charAt(++index) } // Eat the opening. if (character !== leftSquareBracket) { return } // Exit when this is a link and we’re already inside a link. if (!isImage && self.inLink) { return } subvalue += character queue = '' index++ // Eat the content. length = value.length now = eat.now() depth = 0 now.column += index now.offset += index while (index < length) { character = value.charAt(index) subqueue = character if (character === graveAccent) { // Inline-code in link content. count = 1 while (value.charAt(index + 1) === graveAccent) { subqueue += character index++ count++ } if (!opening) { opening = count } else if (count >= opening) { opening = 0 } } else if (character === backslash) { // Allow brackets to be escaped. index++ subqueue += value.charAt(index) } else if ((!opening || gfm) && character === leftSquareBracket) { // In GFM mode, brackets in code still count. In all other modes, // they don’t. depth++ } else if ((!opening || gfm) && character === rightSquareBracket) { if (depth) { depth-- } else { // Allow white-space between content and url in GFM mode. if (!pedantic) { while (index < length) { character = value.charAt(index + 1) if (!whitespace(character)) { break } subqueue += character index++ } } if (value.charAt(index + 1) !== leftParenthesis) { return } subqueue += leftParenthesis closed = true index++ break } } queue += subqueue subqueue = '' index++ } // Eat the content closing. if (!closed) { return } content = queue subvalue += queue + subqueue index++ // Eat white-space. while (index < length) { character = value.charAt(index) if (!whitespace(character)) { break } subvalue += character index++ } // Eat the URL. character = value.charAt(index) queue = '' beforeURL = subvalue if (character === lessThan) { index++ beforeURL += lessThan while (index < length) { character = value.charAt(index) if (character === greaterThan) { break } if (commonmark && character === lineFeed) { return } queue += character index++ } if (value.charAt(index) !== greaterThan) { return } subvalue += lessThan + queue + greaterThan url = queue index++ } else { character = null subqueue = '' while (index < length) { character = value.charAt(index) if ( subqueue && (character === quotationMark || character === apostrophe || (commonmark && character === leftParenthesis)) ) { break } if (whitespace(character)) { if (!pedantic) { break } subqueue += character } else { if (character === leftParenthesis) { depth++ } else if (character === rightParenthesis) { if (depth === 0) { break } depth-- } queue += subqueue subqueue = '' if (character === backslash) { queue += backslash character = value.charAt(++index) } queue += character } index++ } subvalue += queue url = queue index = subvalue.length } // Eat white-space. queue = '' while (index < length) { character = value.charAt(index) if (!whitespace(character)) { break } queue += character index++ } character = value.charAt(index) subvalue += queue // Eat the title. if ( queue && (character === quotationMark || character === apostrophe || (commonmark && character === leftParenthesis)) ) { index++ subvalue += character queue = '' marker = character === leftParenthesis ? rightParenthesis : character beforeTitle = subvalue // In commonmark-mode, things are pretty easy: the marker cannot occur // inside the title. Non-commonmark does, however, support nested // delimiters. if (commonmark) { while (index < length) { character = value.charAt(index) if (character === marker) { break } if (character === backslash) { queue += backslash character = value.charAt(++index) } index++ queue += character } character = value.charAt(index) if (character !== marker) { return } title = queue subvalue += queue + character index++ while (index < length) { character = value.charAt(index) if (!whitespace(character)) { break } subvalue += character index++ } } else { subqueue = '' while (index < length) { character = value.charAt(index) if (character === marker) { if (hasMarker) { queue += marker + subqueue subqueue = '' } hasMarker = true } else if (!hasMarker) { queue += character } else if (character === rightParenthesis) { subvalue += queue + marker + subqueue title = queue break } else if (whitespace(character)) { subqueue += character } else { queue += marker + subqueue + character subqueue = '' hasMarker = false } index++ } } } if (value.charAt(index) !== rightParenthesis) { return } /* istanbul ignore if - never used (yet) */ if (silent) { return true } subvalue += rightParenthesis url = self.decode.raw(self.unescape(url), eat(beforeURL).test().end, { nonTerminated: false }) if (title) { beforeTitle = eat(beforeTitle).test().end title = self.decode.raw(self.unescape(title), beforeTitle) } node = { type: isImage ? 'image' : 'link', title: title || null, url: url } if (isImage) { node.alt = self.decode.raw(self.unescape(content), now) || null } else { exit = self.enterLink() node.children = self.tokenizeInline(content, now) exit() } return eat(subvalue)(node) } /***/ }), /* 245 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var whitespace = __webpack_require__(8) var locate = __webpack_require__(86) var normalize = __webpack_require__(42) module.exports = reference reference.locator = locate var link = 'link' var image = 'image' var footnote = 'footnote' var shortcut = 'shortcut' var collapsed = 'collapsed' var full = 'full' var space = ' ' var exclamationMark = '!' var leftSquareBracket = '[' var backslash = '\\' var rightSquareBracket = ']' var caret = '^' function reference(eat, value, silent) { var self = this var commonmark = self.options.commonmark var character = value.charAt(0) var index = 0 var length = value.length var subvalue = '' var intro = '' var type = link var referenceType = shortcut var content var identifier var now var node var exit var queue var bracketed var depth // Check whether we’re eating an image. if (character === exclamationMark) { type = image intro = character character = value.charAt(++index) } if (character !== leftSquareBracket) { return } index++ intro += character queue = '' // Check whether we’re eating a footnote. if (self.options.footnotes && value.charAt(index) === caret) { // Exit if `![^` is found, so the `!` will be seen as text after this, // and we’ll enter this function again when `[^` is found. if (type === image) { return } intro += caret index++ type = footnote } // Eat the text. depth = 0 while (index < length) { character = value.charAt(index) if (character === leftSquareBracket) { bracketed = true depth++ } else if (character === rightSquareBracket) { if (!depth) { break } depth-- } if (character === backslash) { queue += backslash character = value.charAt(++index) } queue += character index++ } subvalue = queue content = queue character = value.charAt(index) if (character !== rightSquareBracket) { return } index++ subvalue += character queue = '' if (!commonmark) { // The original markdown syntax definition explicitly allows for whitespace // between the link text and link label; commonmark departs from this, in // part to improve support for shortcut reference links while (index < length) { character = value.charAt(index) if (!whitespace(character)) { break } queue += character index++ } } character = value.charAt(index) // Inline footnotes cannot have an identifier. if (type !== footnote && character === leftSquareBracket) { identifier = '' queue += character index++ while (index < length) { character = value.charAt(index) if (character === leftSquareBracket || character === rightSquareBracket) { break } if (character === backslash) { identifier += backslash character = value.charAt(++index) } identifier += character index++ } character = value.charAt(index) if (character === rightSquareBracket) { referenceType = identifier ? full : collapsed queue += identifier + character index++ } else { identifier = '' } subvalue += queue queue = '' } else { if (!content) { return } identifier = content } // Brackets cannot be inside the identifier. if (referenceType !== full && bracketed) { return } subvalue = intro + subvalue if (type === link && self.inLink) { return null } /* istanbul ignore if - never used (yet) */ if (silent) { return true } if (type === footnote && content.indexOf(space) !== -1) { return eat(subvalue)({ type: footnote, children: this.tokenizeInline(content, eat.now()) }) } now = eat.now() now.column += intro.length now.offset += intro.length identifier = referenceType === full ? identifier : content node = { type: type + 'Reference', identifier: normalize(identifier), label: identifier } if (type === link || type === image) { node.referenceType = referenceType } if (type === link) { exit = self.enterLink() node.children = self.tokenizeInline(content, now) exit() } else if (type === image) { node.alt = self.decode.raw(self.unescape(content), now) || null } return eat(subvalue)(node) } /***/ }), /* 246 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var trim = __webpack_require__(14) var whitespace = __webpack_require__(8) var locate = __webpack_require__(247) module.exports = strong strong.locator = locate var backslash = '\\' var asterisk = '*' var underscore = '_' function strong(eat, value, silent) { var self = this var index = 0 var character = value.charAt(index) var now var pedantic var marker var queue var subvalue var length var prev if ( (character !== asterisk && character !== underscore) || value.charAt(++index) !== character ) { return } pedantic = self.options.pedantic marker = character subvalue = marker + marker length = value.length index++ queue = '' character = '' if (pedantic && whitespace(value.charAt(index))) { return } while (index < length) { prev = character character = value.charAt(index) if ( character === marker && value.charAt(index + 1) === marker && (!pedantic || !whitespace(prev)) ) { character = value.charAt(index + 2) if (character !== marker) { if (!trim(queue)) { return } /* istanbul ignore if - never used (yet) */ if (silent) { return true } now = eat.now() now.column += 2 now.offset += 2 return eat(subvalue + queue + subvalue)({ type: 'strong', children: self.tokenizeInline(queue, now) }) } } if (!pedantic && character === backslash) { queue += character character = value.charAt(++index) } queue += character index++ } } /***/ }), /* 247 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = locate function locate(value, fromIndex) { var asterisk = value.indexOf('**', fromIndex) var underscore = value.indexOf('__', fromIndex) if (underscore === -1) { return asterisk } if (asterisk === -1) { return underscore } return underscore < asterisk ? underscore : asterisk } /***/ }), /* 248 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var trim = __webpack_require__(14) var word = __webpack_require__(249) var whitespace = __webpack_require__(8) var locate = __webpack_require__(250) module.exports = emphasis emphasis.locator = locate var asterisk = '*' var underscore = '_' var backslash = '\\' function emphasis(eat, value, silent) { var self = this var index = 0 var character = value.charAt(index) var now var pedantic var marker var queue var subvalue var length var prev if (character !== asterisk && character !== underscore) { return } pedantic = self.options.pedantic subvalue = character marker = character length = value.length index++ queue = '' character = '' if (pedantic && whitespace(value.charAt(index))) { return } while (index < length) { prev = character character = value.charAt(index) if (character === marker && (!pedantic || !whitespace(prev))) { character = value.charAt(++index) if (character !== marker) { if (!trim(queue) || prev === marker) { return } if (!pedantic && marker === underscore && word(character)) { queue += marker continue } /* istanbul ignore if - never used (yet) */ if (silent) { return true } now = eat.now() now.column++ now.offset++ return eat(subvalue + queue + marker)({ type: 'emphasis', children: self.tokenizeInline(queue, now) }) } queue += marker } if (!pedantic && character === backslash) { queue += character character = value.charAt(++index) } queue += character index++ } } /***/ }), /* 249 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = wordCharacter var fromCode = String.fromCharCode var re = /\w/ /* Check if the given character code, or the character * code at the first character, is a word character. */ function wordCharacter(character) { return re.test( typeof character === 'number' ? fromCode(character) : character.charAt(0) ) } /***/ }), /* 250 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = locate function locate(value, fromIndex) { var asterisk = value.indexOf('*', fromIndex) var underscore = value.indexOf('_', fromIndex) if (underscore === -1) { return asterisk } if (asterisk === -1) { return underscore } return underscore < asterisk ? underscore : asterisk } /***/ }), /* 251 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var whitespace = __webpack_require__(8) var locate = __webpack_require__(252) module.exports = strikethrough strikethrough.locator = locate var tilde = '~' var fence = '~~' function strikethrough(eat, value, silent) { var self = this var character = '' var previous = '' var preceding = '' var subvalue = '' var index var length var now if ( !self.options.gfm || value.charAt(0) !== tilde || value.charAt(1) !== tilde || whitespace(value.charAt(2)) ) { return } index = 1 length = value.length now = eat.now() now.column += 2 now.offset += 2 while (++index < length) { character = value.charAt(index) if ( character === tilde && previous === tilde && (!preceding || !whitespace(preceding)) ) { /* istanbul ignore if - never used (yet) */ if (silent) { return true } return eat(fence + subvalue + fence)({ type: 'delete', children: self.tokenizeInline(subvalue, now) }) } subvalue += previous preceding = previous previous = character } } /***/ }), /* 252 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = locate function locate(value, fromIndex) { return value.indexOf('~~', fromIndex) } /***/ }), /* 253 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var whitespace = __webpack_require__(8) var locate = __webpack_require__(254) module.exports = inlineCode inlineCode.locator = locate var graveAccent = '`' function inlineCode(eat, value, silent) { var length = value.length var index = 0 var queue = '' var tickQueue = '' var contentQueue var subqueue var count var openingCount var subvalue var character var found var next while (index < length) { if (value.charAt(index) !== graveAccent) { break } queue += graveAccent index++ } if (!queue) { return } subvalue = queue openingCount = index queue = '' next = value.charAt(index) count = 0 while (index < length) { character = next next = value.charAt(index + 1) if (character === graveAccent) { count++ tickQueue += character } else { count = 0 queue += character } if (count && next !== graveAccent) { if (count === openingCount) { subvalue += queue + tickQueue found = true break } queue += tickQueue tickQueue = '' } index++ } if (!found) { if (openingCount % 2 !== 0) { return } queue = '' } /* istanbul ignore if - never used (yet) */ if (silent) { return true } contentQueue = '' subqueue = '' length = queue.length index = -1 while (++index < length) { character = queue.charAt(index) if (whitespace(character)) { subqueue += character continue } if (subqueue) { if (contentQueue) { contentQueue += subqueue } subqueue = '' } contentQueue += character } return eat(subvalue)({type: 'inlineCode', value: contentQueue}) } /***/ }), /* 254 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = locate function locate(value, fromIndex) { return value.indexOf('`', fromIndex) } /***/ }), /* 255 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var locate = __webpack_require__(256) module.exports = hardBreak hardBreak.locator = locate var space = ' ' var lineFeed = '\n' var minBreakLength = 2 function hardBreak(eat, value, silent) { var length = value.length var index = -1 var queue = '' var character while (++index < length) { character = value.charAt(index) if (character === lineFeed) { if (index < minBreakLength) { return } /* istanbul ignore if - never used (yet) */ if (silent) { return true } queue += character return eat(queue)({type: 'break'}) } if (character !== space) { return } queue += character } } /***/ }), /* 256 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = locate function locate(value, fromIndex) { var index = value.indexOf('\n', fromIndex) while (index > fromIndex) { if (value.charAt(index - 1) !== ' ') { break } index-- } return index } /***/ }), /* 257 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = text function text(eat, value, silent) { var self = this var methods var tokenizers var index var length var subvalue var position var tokenizer var name var min var now /* istanbul ignore if - never used (yet) */ if (silent) { return true } methods = self.inlineMethods length = methods.length tokenizers = self.inlineTokenizers index = -1 min = value.length while (++index < length) { name = methods[index] if (name === 'text' || !tokenizers[name]) { continue } tokenizer = tokenizers[name].locator if (!tokenizer) { eat.file.fail('Missing locator: `' + name + '`') } position = tokenizer.call(self, value, 1) if (position !== -1 && position < min) { min = position } } subvalue = value.slice(0, min) now = eat.now() self.decode(subvalue, now, handler) function handler(content, position, source) { eat(source || content)({type: 'text', value: content}) } } /***/ }), /* 258 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var unherit = __webpack_require__(75) var xtend = __webpack_require__(7) var Compiler = __webpack_require__(259) module.exports = stringify stringify.Compiler = Compiler function stringify(options) { var Local = unherit(Compiler) Local.prototype.options = xtend( Local.prototype.options, this.data('settings'), options ) this.Compiler = Local } /***/ }), /* 259 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var xtend = __webpack_require__(7) var toggle = __webpack_require__(76) module.exports = Compiler // Construct a new compiler. function Compiler(tree, file) { this.inLink = false this.inTable = false this.tree = tree this.file = file this.options = xtend(this.options) this.setOptions({}) } var proto = Compiler.prototype // Enter and exit helpers. */ proto.enterLink = toggle('inLink', false) proto.enterTable = toggle('inTable', false) proto.enterLinkReference = __webpack_require__(260) // Configuration. proto.options = __webpack_require__(88) proto.setOptions = __webpack_require__(261) proto.compile = __webpack_require__(267) proto.visit = __webpack_require__(269) proto.all = __webpack_require__(270) proto.block = __webpack_require__(271) proto.visitOrderedItems = __webpack_require__(272) proto.visitUnorderedItems = __webpack_require__(273) // Expose visitors. proto.visitors = { root: __webpack_require__(274), text: __webpack_require__(275), heading: __webpack_require__(276), paragraph: __webpack_require__(277), blockquote: __webpack_require__(278), list: __webpack_require__(279), listItem: __webpack_require__(280), inlineCode: __webpack_require__(281), code: __webpack_require__(282), html: __webpack_require__(283), thematicBreak: __webpack_require__(284), strong: __webpack_require__(285), emphasis: __webpack_require__(286), break: __webpack_require__(287), delete: __webpack_require__(288), link: __webpack_require__(289), linkReference: __webpack_require__(291), imageReference: __webpack_require__(293), definition: __webpack_require__(294), image: __webpack_require__(295), footnote: __webpack_require__(296), footnoteReference: __webpack_require__(297), footnoteDefinition: __webpack_require__(298), table: __webpack_require__(299), tableCell: __webpack_require__(301) } /***/ }), /* 260 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var identity = __webpack_require__(87) module.exports = enter // Shortcut and collapsed link references need no escaping and encoding during // the processing of child nodes (it must be implied from identifier). // // This toggler turns encoding and escaping off for shortcut and collapsed // references. // // Implies `enterLink`. function enter(compiler, node) { var encode = compiler.encode var escape = compiler.escape var exitLink = compiler.enterLink() if (node.referenceType !== 'shortcut' && node.referenceType !== 'collapsed') { return exitLink } compiler.escape = identity compiler.encode = identity return exit function exit() { compiler.encode = encode compiler.escape = escape exitLink() } } /***/ }), /* 261 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var xtend = __webpack_require__(7) var encode = __webpack_require__(262) var defaults = __webpack_require__(88) var escapeFactory = __webpack_require__(265) var identity = __webpack_require__(87) module.exports = setOptions // Map of applicable enums. var maps = { entities: {true: true, false: true, numbers: true, escape: true}, bullet: {'*': true, '-': true, '+': true}, rule: {'-': true, _: true, '*': true}, listItemIndent: {tab: true, mixed: true, 1: true}, emphasis: {_: true, '*': true}, strong: {_: true, '*': true}, fence: {'`': true, '~': true} } // Expose `validate`. var validate = { boolean: validateBoolean, string: validateString, number: validateNumber, function: validateFunction } // Set options. Does not overwrite previously set options. function setOptions(options) { var self = this var current = self.options var ruleRepetition var key if (options == null) { options = {} } else if (typeof options === 'object') { options = xtend(options) } else { throw new Error('Invalid value `' + options + '` for setting `options`') } for (key in defaults) { validate[typeof defaults[key]](options, key, current[key], maps[key]) } ruleRepetition = options.ruleRepetition if (ruleRepetition && ruleRepetition < 3) { raise(ruleRepetition, 'options.ruleRepetition') } self.encode = encodeFactory(String(options.entities)) self.escape = escapeFactory(options) self.options = options return self } // Validate a value to be boolean. Defaults to `def`. Raises an exception with // `context[name]` when not a boolean. function validateBoolean(context, name, def) { var value = context[name] if (value == null) { value = def } if (typeof value !== 'boolean') { raise(value, 'options.' + name) } context[name] = value } // Validate a value to be boolean. Defaults to `def`. Raises an exception with // `context[name]` when not a boolean. function validateNumber(context, name, def) { var value = context[name] if (value == null) { value = def } if (isNaN(value)) { raise(value, 'options.' + name) } context[name] = value } // Validate a value to be in `map`. Defaults to `def`. Raises an exception // with `context[name]` when not in `map`. function validateString(context, name, def, map) { var value = context[name] if (value == null) { value = def } value = String(value) if (!(value in map)) { raise(value, 'options.' + name) } context[name] = value } // Validate a value to be function. Defaults to `def`. Raises an exception // with `context[name]` when not a function. function validateFunction(context, name, def) { var value = context[name] if (value == null) { value = def } if (typeof value !== 'function') { raise(value, 'options.' + name) } context[name] = value } // Factory to encode HTML entities. Creates a no-operation function when // `type` is `'false'`, a function which encodes using named references when // `type` is `'true'`, and a function which encodes using numbered references // when `type` is `'numbers'`. function encodeFactory(type) { var options = {} if (type === 'false') { return identity } if (type === 'true') { options.useNamedReferences = true } if (type === 'escape') { options.escapeOnly = true options.useNamedReferences = true } return wrapped // Encode HTML entities using the bound options. function wrapped(value) { return encode(value, options) } } // Throw an exception with in its `message` `value` and `name`. function raise(value, name) { throw new Error('Invalid value `' + value + '` for setting `' + name + '`') } /***/ }), /* 262 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var entities = __webpack_require__(263) var legacy = __webpack_require__(77) var hexadecimal = __webpack_require__(78) var alphanumerical = __webpack_require__(79) var dangerous = __webpack_require__(264) /* Expose. */ module.exports = encode encode.escape = escape var own = {}.hasOwnProperty /* List of enforced escapes. */ var escapes = ['"', "'", '<', '>', '&', '`'] /* Map of characters to names. */ var characters = construct() /* Default escapes. */ var defaultEscapes = toExpression(escapes) /* Surrogate pairs. */ var surrogatePair = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g /* Non-ASCII characters. */ // eslint-disable-next-line no-control-regex, unicorn/no-hex-escape var bmp = /[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g /* Encode special characters in `value`. */ function encode(value, options) { var settings = options || {} var subset = settings.subset var set = subset ? toExpression(subset) : defaultEscapes var escapeOnly = settings.escapeOnly var omit = settings.omitOptionalSemicolons value = value.replace(set, function(char, pos, val) { return one(char, val.charAt(pos + 1), settings) }) if (subset || escapeOnly) { return value } return value .replace(surrogatePair, replaceSurrogatePair) .replace(bmp, replaceBmp) function replaceSurrogatePair(pair, pos, val) { return toHexReference( (pair.charCodeAt(0) - 0xd800) * 0x400 + pair.charCodeAt(1) - 0xdc00 + 0x10000, val.charAt(pos + 2), omit ) } function replaceBmp(char, pos, val) { return one(char, val.charAt(pos + 1), settings) } } /* Shortcut to escape special characters in HTML. */ function escape(value) { return encode(value, { escapeOnly: true, useNamedReferences: true }) } /* Encode `char` according to `options`. */ function one(char, next, options) { var shortest = options.useShortestReferences var omit = options.omitOptionalSemicolons var named var numeric if ((shortest || options.useNamedReferences) && own.call(characters, char)) { named = toNamed(characters[char], next, omit, options.attribute) } if (shortest || !named) { numeric = toHexReference(char.charCodeAt(0), next, omit) } if (named && (!shortest || named.length < numeric.length)) { return named } return numeric } /* Transform `code` into an entity. */ function toNamed(name, next, omit, attribute) { var value = '&' + name if ( omit && own.call(legacy, name) && dangerous.indexOf(name) === -1 && (!attribute || (next && next !== '=' && !alphanumerical(next))) ) { return value } return value + ';' } /* Transform `code` into a hexadecimal character reference. */ function toHexReference(code, next, omit) { var value = '&#x' + code.toString(16).toUpperCase() return omit && next && !hexadecimal(next) ? value : value + ';' } /* Create an expression for `characters`. */ function toExpression(characters) { return new RegExp('[' + characters.join('') + ']', 'g') } /* Construct the map. */ function construct() { var chars = {} var name for (name in entities) { chars[entities[name]] = name } return chars } /***/ }), /* 263 */ /***/ (function(module) { module.exports = {"nbsp":" ","iexcl":"¡","cent":"¢","pound":"£","curren":"¤","yen":"¥","brvbar":"¦","sect":"§","uml":"¨","copy":"©","ordf":"ª","laquo":"«","not":"¬","shy":"­","reg":"®","macr":"¯","deg":"°","plusmn":"±","sup2":"²","sup3":"³","acute":"´","micro":"µ","para":"¶","middot":"·","cedil":"¸","sup1":"¹","ordm":"º","raquo":"»","frac14":"¼","frac12":"½","frac34":"¾","iquest":"¿","Agrave":"À","Aacute":"Á","Acirc":"Â","Atilde":"Ã","Auml":"Ä","Aring":"Å","AElig":"Æ","Ccedil":"Ç","Egrave":"È","Eacute":"É","Ecirc":"Ê","Euml":"Ë","Igrave":"Ì","Iacute":"Í","Icirc":"Î","Iuml":"Ï","ETH":"Ð","Ntilde":"Ñ","Ograve":"Ò","Oacute":"Ó","Ocirc":"Ô","Otilde":"Õ","Ouml":"Ö","times":"×","Oslash":"Ø","Ugrave":"Ù","Uacute":"Ú","Ucirc":"Û","Uuml":"Ü","Yacute":"Ý","THORN":"Þ","szlig":"ß","agrave":"à","aacute":"á","acirc":"â","atilde":"ã","auml":"ä","aring":"å","aelig":"æ","ccedil":"ç","egrave":"è","eacute":"é","ecirc":"ê","euml":"ë","igrave":"ì","iacute":"í","icirc":"î","iuml":"ï","eth":"ð","ntilde":"ñ","ograve":"ò","oacute":"ó","ocirc":"ô","otilde":"õ","ouml":"ö","divide":"÷","oslash":"ø","ugrave":"ù","uacute":"ú","ucirc":"û","uuml":"ü","yacute":"ý","thorn":"þ","yuml":"ÿ","fnof":"ƒ","Alpha":"Α","Beta":"Β","Gamma":"Γ","Delta":"Δ","Epsilon":"Ε","Zeta":"Ζ","Eta":"Η","Theta":"Θ","Iota":"Ι","Kappa":"Κ","Lambda":"Λ","Mu":"Μ","Nu":"Ν","Xi":"Ξ","Omicron":"Ο","Pi":"Π","Rho":"Ρ","Sigma":"Σ","Tau":"Τ","Upsilon":"Υ","Phi":"Φ","Chi":"Χ","Psi":"Ψ","Omega":"Ω","alpha":"α","beta":"β","gamma":"γ","delta":"δ","epsilon":"ε","zeta":"ζ","eta":"η","theta":"θ","iota":"ι","kappa":"κ","lambda":"λ","mu":"μ","nu":"ν","xi":"ξ","omicron":"ο","pi":"π","rho":"ρ","sigmaf":"ς","sigma":"σ","tau":"τ","upsilon":"υ","phi":"φ","chi":"χ","psi":"ψ","omega":"ω","thetasym":"ϑ","upsih":"ϒ","piv":"ϖ","bull":"•","hellip":"…","prime":"′","Prime":"″","oline":"‾","frasl":"⁄","weierp":"℘","image":"ℑ","real":"ℜ","trade":"™","alefsym":"ℵ","larr":"←","uarr":"↑","rarr":"→","darr":"↓","harr":"↔","crarr":"↵","lArr":"⇐","uArr":"⇑","rArr":"⇒","dArr":"⇓","hArr":"⇔","forall":"∀","part":"∂","exist":"∃","empty":"∅","nabla":"∇","isin":"∈","notin":"∉","ni":"∋","prod":"∏","sum":"∑","minus":"−","lowast":"∗","radic":"√","prop":"∝","infin":"∞","ang":"∠","and":"∧","or":"∨","cap":"∩","cup":"∪","int":"∫","there4":"∴","sim":"∼","cong":"≅","asymp":"≈","ne":"≠","equiv":"≡","le":"≤","ge":"≥","sub":"⊂","sup":"⊃","nsub":"⊄","sube":"⊆","supe":"⊇","oplus":"⊕","otimes":"⊗","perp":"⊥","sdot":"⋅","lceil":"⌈","rceil":"⌉","lfloor":"⌊","rfloor":"⌋","lang":"〈","rang":"〉","loz":"◊","spades":"♠","clubs":"♣","hearts":"♥","diams":"♦","quot":"\"","amp":"&","lt":"<","gt":">","OElig":"Œ","oelig":"œ","Scaron":"Š","scaron":"š","Yuml":"Ÿ","circ":"ˆ","tilde":"˜","ensp":" ","emsp":" ","thinsp":" ","zwnj":"‌","zwj":"‍","lrm":"‎","rlm":"‏","ndash":"–","mdash":"—","lsquo":"‘","rsquo":"’","sbquo":"‚","ldquo":"“","rdquo":"”","bdquo":"„","dagger":"†","Dagger":"‡","permil":"‰","lsaquo":"‹","rsaquo":"›","euro":"€"}; /***/ }), /* 264 */ /***/ (function(module) { module.exports = ["cent","copy","divide","gt","lt","not","para","times"]; /***/ }), /* 265 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var decimal = __webpack_require__(23) var alphanumeric = __webpack_require__(266) var whitespace = __webpack_require__(8) var escapes = __webpack_require__(81) var prefix = __webpack_require__(89) module.exports = factory var tab = '\t' var lineFeed = '\n' var space = ' ' var numberSign = '#' var ampersand = '&' var leftParenthesis = '(' var rightParenthesis = ')' var asterisk = '*' var plusSign = '+' var dash = '-' var dot = '.' var colon = ':' var lessThan = '<' var greaterThan = '>' var leftSquareBracket = '[' var backslash = '\\' var rightSquareBracket = ']' var underscore = '_' var graveAccent = '`' var verticalBar = '|' var tilde = '~' var exclamationMark = '!' var entities = { '<': '<', ':': ':', '&': '&', '|': '|', '~': '~' } var shortcut = 'shortcut' var mailto = 'mailto' var https = 'https' var http = 'http' var blankExpression = /\n\s*$/ // Factory to escape characters. function factory(options) { return escape // Escape punctuation characters in a node’s value. function escape(value, node, parent) { var self = this var gfm = options.gfm var commonmark = options.commonmark var pedantic = options.pedantic var markers = commonmark ? [dot, rightParenthesis] : [dot] var siblings = parent && parent.children var index = siblings && siblings.indexOf(node) var prev = siblings && siblings[index - 1] var next = siblings && siblings[index + 1] var length = value.length var escapable = escapes(options) var position = -1 var queue = [] var escaped = queue var afterNewLine var character var wordCharBefore var wordCharAfter var offset var replace if (prev) { afterNewLine = text(prev) && blankExpression.test(prev.value) } else { afterNewLine = !parent || parent.type === 'root' || parent.type === 'paragraph' } while (++position < length) { character = value.charAt(position) replace = false if (character === '\n') { afterNewLine = true } else if ( character === backslash || character === graveAccent || character === asterisk || (character === exclamationMark && value.charAt(position + 1) === leftSquareBracket) || character === leftSquareBracket || character === lessThan || (character === ampersand && prefix(value.slice(position)) > 0) || (character === rightSquareBracket && self.inLink) || (gfm && character === tilde && value.charAt(position + 1) === tilde) || (gfm && character === verticalBar && (self.inTable || alignment(value, position))) || (character === underscore && // Delegate leading/trailing underscores to the multinode version below. position > 0 && position < length - 1 && (pedantic || !alphanumeric(value.charAt(position - 1)) || !alphanumeric(value.charAt(position + 1)))) || (gfm && !self.inLink && character === colon && protocol(queue.join(''))) ) { replace = true } else if (afterNewLine) { if ( character === greaterThan || character === numberSign || character === asterisk || character === dash || character === plusSign ) { replace = true } else if (decimal(character)) { offset = position + 1 while (offset < length) { if (!decimal(value.charAt(offset))) { break } offset++ } if (markers.indexOf(value.charAt(offset)) !== -1) { next = value.charAt(offset + 1) if (!next || next === space || next === tab || next === lineFeed) { queue.push(value.slice(position, offset)) position = offset character = value.charAt(position) replace = true } } } } if (afterNewLine && !whitespace(character)) { afterNewLine = false } queue.push(replace ? one(character) : character) } // Multi-node versions. if (siblings && text(node)) { // Check for an opening parentheses after a link-reference (which can be // joined by white-space). if (prev && prev.referenceType === shortcut) { position = -1 length = escaped.length while (++position < length) { character = escaped[position] if (character === space || character === tab) { continue } if (character === leftParenthesis || character === colon) { escaped[position] = one(character) } break } // If the current node is all spaces / tabs, preceded by a shortcut, // and followed by a text starting with `(`, escape it. if ( text(next) && position === length && next.value.charAt(0) === leftParenthesis ) { escaped.push(backslash) } } // Ensure non-auto-links are not seen as links. This pattern needs to // check the preceding nodes too. if ( gfm && !self.inLink && text(prev) && value.charAt(0) === colon && protocol(prev.value.slice(-6)) ) { escaped[0] = one(colon) } // Escape ampersand if it would otherwise start an entity. if ( text(next) && value.charAt(length - 1) === ampersand && prefix(ampersand + next.value) !== 0 ) { escaped[escaped.length - 1] = one(ampersand) } // Escape exclamation marks immediately followed by links. if ( next && next.type === 'link' && value.charAt(length - 1) === exclamationMark ) { escaped[escaped.length - 1] = one(exclamationMark) } // Escape double tildes in GFM. if ( gfm && text(next) && value.charAt(length - 1) === tilde && next.value.charAt(0) === tilde ) { escaped.splice(escaped.length - 1, 0, backslash) } // Escape underscores, but not mid-word (unless in pedantic mode). wordCharBefore = text(prev) && alphanumeric(prev.value.slice(-1)) wordCharAfter = text(next) && alphanumeric(next.value.charAt(0)) if (length === 1) { if ( value === underscore && (pedantic || !wordCharBefore || !wordCharAfter) ) { escaped.unshift(backslash) } } else { if ( value.charAt(0) === underscore && (pedantic || !wordCharBefore || !alphanumeric(value.charAt(1))) ) { escaped.unshift(backslash) } if ( value.charAt(length - 1) === underscore && (pedantic || !wordCharAfter || !alphanumeric(value.charAt(length - 2))) ) { escaped.splice(escaped.length - 1, 0, backslash) } } } return escaped.join('') function one(character) { return escapable.indexOf(character) === -1 ? entities[character] : backslash + character } } } // Check if `index` in `value` is inside an alignment row. function alignment(value, index) { var start = value.lastIndexOf(lineFeed, index) var end = value.indexOf(lineFeed, index) var char end = end === -1 ? value.length : end while (++start < end) { char = value.charAt(start) if ( char !== colon && char !== dash && char !== space && char !== verticalBar ) { return false } } return true } // Check if `node` is a text node. function text(node) { return node && node.type === 'text' } // Check if `value` ends in a protocol. function protocol(value) { var val = value.slice(-6).toLowerCase() return val === mailto || val.slice(-5) === https || val.slice(-4) === http } /***/ }), /* 266 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = function (str) { if (typeof str !== 'string') { throw new TypeError('Expected a string'); } return !/[^0-9a-z\xDF-\xFF]/.test(str.toLowerCase()); }; /***/ }), /* 267 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var compact = __webpack_require__(268) module.exports = compile // Stringify the given tree. function compile() { return this.visit(compact(this.tree, this.options.commonmark)) } /***/ }), /* 268 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var visit = __webpack_require__(1) module.exports = compact /* Make an MDAST tree compact by merging adjacent text nodes. */ function compact(tree, commonmark) { visit(tree, visitor) return tree function visitor(child, index, parent) { var siblings = parent ? parent.children : [] var prev = index && siblings[index - 1] if ( prev && child.type === prev.type && mergeable(prev, commonmark) && mergeable(child, commonmark) ) { if (child.value) { prev.value += child.value } if (child.children) { prev.children = prev.children.concat(child.children) } siblings.splice(index, 1) if (prev.position && child.position) { prev.position.end = child.position.end } return index } } } function mergeable(node, commonmark) { var start var end if (node.type === 'text') { if (!node.position) { return true } start = node.position.start end = node.position.end /* Only merge nodes which occupy the same size as their `value`. */ return ( start.line !== end.line || end.column - start.column === node.value.length ) } return commonmark && node.type === 'blockquote' } /***/ }), /* 269 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = one function one(node, parent) { var self = this var visitors = self.visitors // Fail on unknown nodes. if (typeof visitors[node.type] !== 'function') { self.file.fail( new Error( 'Missing compiler for node of type `' + node.type + '`: `' + node + '`' ), node ) } return visitors[node.type].call(self, node, parent) } /***/ }), /* 270 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = all // Visit all children of `parent`. function all(parent) { var self = this var children = parent.children var length = children.length var results = [] var index = -1 while (++index < length) { results[index] = self.visit(children[index], parent) } return results } /***/ }), /* 271 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = block var lineFeed = '\n' var blank = lineFeed + lineFeed var triple = blank + lineFeed var comment = blank + '' + blank // Stringify a block node with block children (e.g., `root` or `blockquote`). // Knows about code following a list, or adjacent lists with similar bullets, // and places an extra line feed between them. function block(node) { var self = this var options = self.options var fences = options.fences var gap = options.commonmark ? comment : triple var values = [] var children = node.children var length = children.length var index = -1 var prev var child while (++index < length) { prev = child child = children[index] if (prev) { // A list preceding another list that are equally ordered, or a // list preceding an indented code block, need a gap between them, // so as not to see them as one list, or content of the list, // respectively. // // In commonmark, only something that breaks both up can do that, // so we opt for an empty, invisible comment. In other flavours, // two blank lines are fine. if ( prev.type === 'list' && ((child.type === 'list' && prev.ordered === child.ordered) || (child.type === 'code' && (!child.lang && !fences))) ) { values.push(gap) } else { values.push(blank) } } values.push(self.visit(child, node)) } return values.join('') } /***/ }), /* 272 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = orderedItems var lineFeed = '\n' var dot = '.' var blank = lineFeed + lineFeed // Visit ordered list items. // // Starts the list with // `node.start` and increments each following list item // bullet by one: // // 2. foo // 3. bar // // In `incrementListMarker: false` mode, does not increment // each marker and stays on `node.start`: // // 1. foo // 1. bar function orderedItems(node) { var self = this var fn = self.visitors.listItem var increment = self.options.incrementListMarker var values = [] var start = node.start var children = node.children var length = children.length var index = -1 var bullet start = start == null ? 1 : start while (++index < length) { bullet = (increment ? start + index : start) + dot values[index] = fn.call(self, children[index], node, index, bullet) } return values.join(node.spread ? blank : lineFeed) } /***/ }), /* 273 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = unorderedItems var lineFeed = '\n' var blank = lineFeed + lineFeed // Visit unordered list items. Uses `options.bullet` as each item’s bullet. function unorderedItems(node) { var self = this var bullet = self.options.bullet var fn = self.visitors.listItem var children = node.children var length = children.length var index = -1 var values = [] while (++index < length) { values[index] = fn.call(self, children[index], node, index, bullet) } return values.join(node.spread ? blank : lineFeed) } /***/ }), /* 274 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = root var lineFeed = '\n' // Stringify a root. // Adds a final newline to ensure valid POSIX files. */ function root(node) { return this.block(node) + lineFeed } /***/ }), /* 275 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = text // Stringify text. // Supports named entities in `settings.encode: true` mode: // // ```markdown // AT&T // ``` // // Supports numbered entities in `settings.encode: numbers` mode: // // ```markdown // AT&T // ``` function text(node, parent) { return this.encode(this.escape(node.value, node, parent), node) } /***/ }), /* 276 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var repeat = __webpack_require__(10) module.exports = heading var lineFeed = '\n' var space = ' ' var numberSign = '#' var dash = '-' var equalsTo = '=' // Stringify a heading. // // In `setext: true` mode and when `depth` is smaller than three, creates a // setext header: // // ```markdown // Foo // === // ``` // // Otherwise, an ATX header is generated: // // ```markdown // ### Foo // ``` // // In `closeAtx: true` mode, the header is closed with hashes: // // ```markdown // ### Foo ### // ``` function heading(node) { var self = this var depth = node.depth var setext = self.options.setext var closeAtx = self.options.closeAtx var content = self.all(node).join('') var prefix if (setext && depth < 3) { return ( content + lineFeed + repeat(depth === 1 ? equalsTo : dash, content.length) ) } prefix = repeat(numberSign, node.depth) return prefix + space + content + (closeAtx ? space + prefix : '') } /***/ }), /* 277 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = paragraph function paragraph(node) { return this.all(node).join('') } /***/ }), /* 278 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = blockquote var lineFeed = '\n' var space = ' ' var greaterThan = '>' function blockquote(node) { var values = this.block(node).split(lineFeed) var result = [] var length = values.length var index = -1 var value while (++index < length) { value = values[index] result[index] = (value ? space : '') + value } return greaterThan + result.join(lineFeed + greaterThan) } /***/ }), /* 279 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = list function list(node) { var fn = node.ordered ? this.visitOrderedItems : this.visitUnorderedItems return fn.call(this, node) } /***/ }), /* 280 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var repeat = __webpack_require__(10) var pad = __webpack_require__(90) module.exports = listItem var lineFeed = '\n' var space = ' ' var leftSquareBracket = '[' var rightSquareBracket = ']' var lowercaseX = 'x' var ceil = Math.ceil var blank = lineFeed + lineFeed var tabSize = 4 // Stringify a list item. // // Prefixes the content with a checked checkbox when `checked: true`: // // ```markdown // [x] foo // ``` // // Prefixes the content with an unchecked checkbox when `checked: false`: // // ```markdown // [ ] foo // ``` function listItem(node, parent, position, bullet) { var self = this var style = self.options.listItemIndent var marker = bullet || self.options.bullet var spread = node.spread == null ? true : node.spread var checked = node.checked var children = node.children var length = children.length var values = [] var index = -1 var value var indent var spacing while (++index < length) { values[index] = self.visit(children[index], node) } value = values.join(spread ? blank : lineFeed) if (typeof checked === 'boolean') { // Note: I’d like to be able to only add the space between the check and // the value, but unfortunately github does not support empty list-items // with a checkbox :( value = leftSquareBracket + (checked ? lowercaseX : space) + rightSquareBracket + space + value } if (style === '1' || (style === 'mixed' && value.indexOf(lineFeed) === -1)) { indent = marker.length + 1 spacing = space } else { indent = ceil((marker.length + 1) / tabSize) * tabSize spacing = repeat(space, indent - marker.length) } return value ? marker + spacing + pad(value, indent / tabSize).slice(indent) : marker } /***/ }), /* 281 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var streak = __webpack_require__(91) var repeat = __webpack_require__(10) module.exports = inlineCode var space = ' ' var graveAccent = '`' // Stringify inline code. // // Knows about internal ticks (`\``), and ensures one more tick is used to // enclose the inline code: // // ````markdown // ```foo ``bar`` baz``` // ```` // // Even knows about inital and final ticks: // // ``markdown // `` `foo `` // `` foo` `` // ``` function inlineCode(node) { var value = node.value var ticks = repeat(graveAccent, streak(value, graveAccent) + 1) var start = ticks var end = ticks if (value.charAt(0) === graveAccent) { start += space } if (value.charAt(value.length - 1) === graveAccent) { end = space + end } return start + value + end } /***/ }), /* 282 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var streak = __webpack_require__(91) var repeat = __webpack_require__(10) var pad = __webpack_require__(90) module.exports = code var lineFeed = '\n' var space = ' ' // Stringify code. // Creates indented code when: // // - No language tag exists // - Not in `fences: true` mode // - A non-empty value exists // // Otherwise, GFM fenced code is created: // // ````markdown // ```js // foo(); // ``` // ```` // // When in ``fence: `~` `` mode, uses tildes as fences: // // ```markdown // ~~~js // foo(); // ~~~ // ``` // // Knows about internal fences: // // `````markdown // ````markdown // ```javascript // foo(); // ``` // ```` // ````` function code(node, parent) { var self = this var value = node.value var options = self.options var marker = options.fence var info = node.lang || '' var fence if (info && node.meta) { info += space + node.meta } info = self.encode(self.escape(info, node)) // Without (needed) fences. if (!info && !options.fences && value) { // Throw when pedantic, in a list item which isn’t compiled using a tab. if ( parent && parent.type === 'listItem' && options.listItemIndent !== 'tab' && options.pedantic ) { self.file.fail( 'Cannot indent code properly. See https://git.io/fxKR8', node.position ) } return pad(value, 1) } fence = repeat(marker, Math.max(streak(value, marker) + 1, 3)) return fence + info + lineFeed + value + lineFeed + fence } /***/ }), /* 283 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = html function html(node) { return node.value } /***/ }), /* 284 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var repeat = __webpack_require__(10) module.exports = thematic var space = ' ' // Stringify a `thematic-break`. // The character used is configurable through `rule`: (`'_'`): // // ```markdown // ___ // ``` // // The number of repititions is defined through `ruleRepetition` (`6`): // // ```markdown // ****** // ``` // // Whether spaces delimit each character, is configured through `ruleSpaces` // (`true`): // ```markdown // * * * // ``` function thematic() { var options = this.options var rule = repeat(options.rule, options.ruleRepetition) return options.ruleSpaces ? rule.split('').join(space) : rule } /***/ }), /* 285 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var repeat = __webpack_require__(10) module.exports = strong // Stringify a `strong`. // // The marker used is configurable by `strong`, which defaults to an asterisk // (`'*'`) but also accepts an underscore (`'_'`): // // ```markdown // __foo__ // ``` function strong(node) { var marker = repeat(this.options.strong, 2) return marker + this.all(node).join('') + marker } /***/ }), /* 286 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = emphasis var underscore = '_' var asterisk = '*' // Stringify an `emphasis`. // // The marker used is configurable through `emphasis`, which defaults to an // underscore (`'_'`) but also accepts an asterisk (`'*'`): // // ```markdown // *foo* // ``` // // In `pedantic` mode, text which itself contains an underscore will cause the // marker to default to an asterisk instead: // // ```markdown // *foo_bar* // ``` function emphasis(node) { var marker = this.options.emphasis var content = this.all(node).join('') // When in pedantic mode, prevent using underscore as the marker when there // are underscores in the content. if ( this.options.pedantic && marker === underscore && content.indexOf(marker) !== -1 ) { marker = asterisk } return marker + content + marker } /***/ }), /* 287 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = lineBreak var backslash = '\\' var lineFeed = '\n' var space = ' ' var commonmark = backslash + lineFeed var normal = space + space + lineFeed function lineBreak() { return this.options.commonmark ? commonmark : normal } /***/ }), /* 288 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = strikethrough var tilde = '~' var fence = tilde + tilde function strikethrough(node) { return fence + this.all(node).join('') + fence } /***/ }), /* 289 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var uri = __webpack_require__(43) var title = __webpack_require__(44) module.exports = link var space = ' ' var leftSquareBracket = '[' var rightSquareBracket = ']' var leftParenthesis = '(' var rightParenthesis = ')' // Expression for a protocol: // See . var protocol = /^[a-z][a-z+.-]+:\/?/i // Stringify a link. // // When no title exists, the compiled `children` equal `url`, and `url` starts // with a protocol, an auto link is created: // // ```markdown // // ``` // // Otherwise, is smart about enclosing `url` (see `encloseURI()`) and `title` // (see `encloseTitle()`). // ``` // // ```markdown // [foo]( 'An "example" e-mail') // ``` // // Supports named entities in the `url` and `title` when in `settings.encode` // mode. function link(node) { var self = this var content = self.encode(node.url || '', node) var exit = self.enterLink() var escaped = self.encode(self.escape(node.url || '', node)) var value = self.all(node).join('') exit() if (node.title == null && protocol.test(content) && escaped === value) { // Backslash escapes do not work in autolinks, so we do not escape. return uri(self.encode(node.url), true) } content = uri(content) if (node.title) { content += space + title(self.encode(self.escape(node.title, node), node)) } return ( leftSquareBracket + value + rightSquareBracket + leftParenthesis + content + rightParenthesis ) } /***/ }), /* 290 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = ccount function ccount(value, character) { var count = 0 var index value = String(value) if (typeof character !== 'string' || character.length !== 1) { throw new Error('Expected character') } index = value.indexOf(character) while (index !== -1) { count++ index = value.indexOf(character, index + 1) } return count } /***/ }), /* 291 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var copy = __webpack_require__(292) var label = __webpack_require__(92) module.exports = linkReference var leftSquareBracket = '[' var rightSquareBracket = ']' var shortcut = 'shortcut' var collapsed = 'collapsed' function linkReference(node) { var self = this var type = node.referenceType var exit = self.enterLinkReference(self, node) var value = self.all(node).join('') exit() if (type === shortcut || type === collapsed) { value = copy(value, node.label || node.identifier) } return leftSquareBracket + value + rightSquareBracket + label(node) } /***/ }), /* 292 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var entityPrefixLength = __webpack_require__(89) module.exports = copy var ampersand = '&' var punctuationExppresion = /[-!"#$%&'()*+,./:;<=>?@[\\\]^`{|}~_]/ // For shortcut and collapsed reference links, the contents is also an // identifier, so we need to restore the original encoding and escaping // that were present in the source string. // // This function takes the unescaped & unencoded value from shortcut’s // child nodes and the identifier and encodes the former according to // the latter. function copy(value, identifier) { var length = value.length var count = identifier.length var result = [] var position = 0 var index = 0 var start while (index < length) { // Take next non-punctuation characters from `value`. start = index while (index < length && !punctuationExppresion.test(value.charAt(index))) { index += 1 } result.push(value.slice(start, index)) // Advance `position` to the next punctuation character. while ( position < count && !punctuationExppresion.test(identifier.charAt(position)) ) { position += 1 } // Take next punctuation characters from `identifier`. start = position while ( position < count && punctuationExppresion.test(identifier.charAt(position)) ) { if (identifier.charAt(position) === ampersand) { position += entityPrefixLength(identifier.slice(position)) } position += 1 } result.push(identifier.slice(start, position)) // Advance `index` to the next non-punctuation character. while (index < length && punctuationExppresion.test(value.charAt(index))) { index += 1 } } return result.join('') } /***/ }), /* 293 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var label = __webpack_require__(92) module.exports = imageReference var leftSquareBracket = '[' var rightSquareBracket = ']' var exclamationMark = '!' function imageReference(node) { return ( exclamationMark + leftSquareBracket + (this.encode(node.alt, node) || '') + rightSquareBracket + label(node) ) } /***/ }), /* 294 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var uri = __webpack_require__(43) var title = __webpack_require__(44) module.exports = definition var space = ' ' var colon = ':' var leftSquareBracket = '[' var rightSquareBracket = ']' // Stringify an URL definition. // // Is smart about enclosing `url` (see `encloseURI()`) and `title` (see // `encloseTitle()`). // // ```markdown // [foo]: 'An "example" e-mail' // ``` function definition(node) { var content = uri(node.url) if (node.title) { content += space + title(node.title) } return ( leftSquareBracket + (node.label || node.identifier) + rightSquareBracket + colon + space + content ) } /***/ }), /* 295 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var uri = __webpack_require__(43) var title = __webpack_require__(44) module.exports = image var space = ' ' var leftParenthesis = '(' var rightParenthesis = ')' var leftSquareBracket = '[' var rightSquareBracket = ']' var exclamationMark = '!' // Stringify an image. // // Is smart about enclosing `url` (see `encloseURI()`) and `title` (see // `encloseTitle()`). // // ```markdown // ![foo]( 'My "favourite" icon') // ``` // // Supports named entities in `url`, `alt`, and `title` when in // `settings.encode` mode. function image(node) { var self = this var content = uri(self.encode(node.url || '', node)) var exit = self.enterLink() var alt = self.encode(self.escape(node.alt || '', node)) exit() if (node.title) { content += space + title(self.encode(node.title, node)) } return ( exclamationMark + leftSquareBracket + alt + rightSquareBracket + leftParenthesis + content + rightParenthesis ) } /***/ }), /* 296 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = footnote var leftSquareBracket = '[' var rightSquareBracket = ']' var caret = '^' function footnote(node) { return ( leftSquareBracket + caret + this.all(node).join('') + rightSquareBracket ) } /***/ }), /* 297 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = footnoteReference var leftSquareBracket = '[' var rightSquareBracket = ']' var caret = '^' function footnoteReference(node) { return ( leftSquareBracket + caret + (node.label || node.identifier) + rightSquareBracket ) } /***/ }), /* 298 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var repeat = __webpack_require__(10) var lineFeed = '\n' var space = ' ' var colon = ':' var leftSquareBracket = '[' var rightSquareBracket = ']' var caret = '^' var tabSize = 4 var blank = lineFeed + lineFeed var indent = repeat(space, tabSize) module.exports = footnoteDefinition function footnoteDefinition(node) { var content = this.all(node).join(blank + indent) return ( leftSquareBracket + caret + (node.label || node.identifier) + rightSquareBracket + colon + space + content ) } /***/ }), /* 299 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var markdownTable = __webpack_require__(300) module.exports = table var space = ' ' var verticalBar = '|' // Stringify table. // // Creates a fenced table by default, but not in `looseTable: true` mode: // // ```markdown // Foo | Bar // :-: | --- // Baz | Qux // // NOTE: Be careful with `looseTable: true` mode, as a loose table inside an // indented code block on GitHub renders as an actual table! // // Creates a spaced table by default, but not in `spacedTable: false`: // // ```markdown // |Foo|Bar| // |:-:|---| // |Baz|Qux| // ``` function table(node) { var self = this var options = self.options var loose = options.looseTable var spaced = options.spacedTable var pad = options.paddedTable var stringLength = options.stringLength var rows = node.children var index = rows.length var exit = self.enterTable() var result = [] var start var end while (index--) { result[index] = self.all(rows[index]) } exit() if (loose) { start = '' end = '' } else if (spaced) { start = verticalBar + space end = space + verticalBar } else { start = verticalBar end = verticalBar } return markdownTable(result, { align: node.align, pad: pad, start: start, end: end, stringLength: stringLength, delimiter: spaced ? space + verticalBar + space : verticalBar }) } /***/ }), /* 300 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /* Expose. */ module.exports = markdownTable /* Expressions. */ var EXPRESSION_DOT = /\./ var EXPRESSION_LAST_DOT = /\.[^.]*$/ /* Allowed alignment values. */ var LEFT = 'l' var RIGHT = 'r' var CENTER = 'c' var DOT = '.' var NULL = '' var ALLIGNMENT = [LEFT, RIGHT, CENTER, DOT, NULL] var MIN_CELL_SIZE = 3 /* Characters. */ var COLON = ':' var DASH = '-' var PIPE = '|' var SPACE = ' ' var NEW_LINE = '\n' /* Create a table from a matrix of strings. */ function markdownTable(table, options) { var settings = options || {} var delimiter = settings.delimiter var start = settings.start var end = settings.end var alignment = settings.align var calculateStringLength = settings.stringLength || lengthNoop var cellCount = 0 var rowIndex = -1 var rowLength = table.length var sizes = [] var align var rule var rows var row var cells var index var position var size var value var spacing var before var after alignment = alignment ? alignment.concat() : [] if (delimiter === null || delimiter === undefined) { delimiter = SPACE + PIPE + SPACE } if (start === null || start === undefined) { start = PIPE + SPACE } if (end === null || end === undefined) { end = SPACE + PIPE } while (++rowIndex < rowLength) { row = table[rowIndex] index = -1 if (row.length > cellCount) { cellCount = row.length } while (++index < cellCount) { position = row[index] ? dotindex(row[index]) : null if (!sizes[index]) { sizes[index] = MIN_CELL_SIZE } if (position > sizes[index]) { sizes[index] = position } } } if (typeof alignment === 'string') { alignment = pad(cellCount, alignment).split('') } /* Make sure only valid alignments are used. */ index = -1 while (++index < cellCount) { align = alignment[index] if (typeof align === 'string') { align = align.charAt(0).toLowerCase() } if (ALLIGNMENT.indexOf(align) === -1) { align = NULL } alignment[index] = align } rowIndex = -1 rows = [] while (++rowIndex < rowLength) { row = table[rowIndex] index = -1 cells = [] while (++index < cellCount) { value = row[index] value = stringify(value) if (alignment[index] === DOT) { position = dotindex(value) size = sizes[index] + (EXPRESSION_DOT.test(value) ? 0 : 1) - (calculateStringLength(value) - position) cells[index] = value + pad(size - 1) } else { cells[index] = value } } rows[rowIndex] = cells } sizes = [] rowIndex = -1 while (++rowIndex < rowLength) { cells = rows[rowIndex] index = -1 while (++index < cellCount) { value = cells[index] if (!sizes[index]) { sizes[index] = MIN_CELL_SIZE } size = calculateStringLength(value) if (size > sizes[index]) { sizes[index] = size } } } rowIndex = -1 while (++rowIndex < rowLength) { cells = rows[rowIndex] index = -1 if (settings.pad !== false) { while (++index < cellCount) { value = cells[index] position = sizes[index] - (calculateStringLength(value) || 0) spacing = pad(position) if (alignment[index] === RIGHT || alignment[index] === DOT) { value = spacing + value } else if (alignment[index] === CENTER) { position /= 2 if (position % 1 === 0) { before = position after = position } else { before = position + 0.5 after = position - 0.5 } value = pad(before) + value + pad(after) } else { value += spacing } cells[index] = value } } rows[rowIndex] = cells.join(delimiter) } if (settings.rule !== false) { index = -1 rule = [] while (++index < cellCount) { /* When `pad` is false, make the rule the same size as the first row. */ if (settings.pad === false) { value = table[0][index] spacing = calculateStringLength(stringify(value)) spacing = spacing > MIN_CELL_SIZE ? spacing : MIN_CELL_SIZE } else { spacing = sizes[index] } align = alignment[index] /* When `align` is left, don't add colons. */ value = align === RIGHT || align === NULL ? DASH : COLON value += pad(spacing - 2, DASH) value += align !== LEFT && align !== NULL ? COLON : DASH rule[index] = value } rows.splice(1, 0, rule.join(delimiter)) } return start + rows.join(end + NEW_LINE + start) + end } function stringify(value) { return value === null || value === undefined ? '' : String(value) } /* Get the length of `value`. */ function lengthNoop(value) { return String(value).length } /* Get a string consisting of `length` `character`s. */ function pad(length, character) { return new Array(length + 1).join(character || SPACE) } /* Get the position of the last dot in `value`. */ function dotindex(value) { var match = EXPRESSION_LAST_DOT.exec(value) return match ? match.index + 1 : value.length } /***/ }), /* 301 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; module.exports = tableCell function tableCell(node) { return this.all(node).join('') } /***/ }), /* 302 */ /***/ (function(module) { module.exports = {"name":"remark","version":"10.0.0","description":"Markdown processor powered by plugins","license":"MIT","keywords":["markdown","abstract","syntax","tree","ast","parse","stringify","process"],"homepage":"http://remark.js.org","repository":"https://github.com/remarkjs/remark/tree/master/packages/remark","bugs":"https://github.com/remarkjs/remark/issues","author":"Titus Wormer (http://wooorm.com)","contributors":["Titus Wormer (http://wooorm.com)"],"files":["index.js"],"dependencies":{"remark-parse":"^6.0.0","remark-stringify":"^6.0.0","unified":"^7.0.0"},"devDependencies":{"tape":"^4.9.1"},"scripts":{"test":"tape test.js"},"xo":false,"_resolved":"https://registry.npmjs.org/remark/-/remark-10.0.0.tgz","_integrity":"sha512-0fZvVmd9CgDi1qHGsRTyhpJShw60r3/4OSdRpAx+I7CmE8/Jmt829T9KWHpw2Ygw3chRZ26sMorqb8aIolU9tQ==","_from":"remark@10.0.0"}; /***/ }), /* 303 */ /***/ (function(module) { module.exports = {"name":"node-lint-md-cli-rollup","description":"remark packaged for node markdown linting","version":"1.0.0","devDependencies":{"@zeit/ncc":"^0.2.0"},"dependencies":{"markdown-extensions":"^1.1.0","remark":"^10.0.0","remark-lint":"^6.0.3","remark-preset-lint-node":"^1.3.1","unified-args":"^6.0.0","unified-engine":"^5.1.0"},"main":"src/cli-entry.js","scripts":{"build":"ncc build","build-node":"npm run build && cp dist/index.js ../lint-md.js"}}; /***/ }), /* 304 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; // @see https://github.com/nodejs/node/blob/master/doc/STYLE_GUIDE.md module.exports.plugins = [ __webpack_require__(305), __webpack_require__(309), __webpack_require__(313), __webpack_require__(314), __webpack_require__(315), __webpack_require__(316), __webpack_require__(93), __webpack_require__(93), [ __webpack_require__(317), 'space' ], __webpack_require__(320), __webpack_require__(321), __webpack_require__(322), __webpack_require__(323), __webpack_require__(324), __webpack_require__(325), __webpack_require__(326), __webpack_require__(327), __webpack_require__(328), __webpack_require__(329), __webpack_require__(330), __webpack_require__(331), __webpack_require__(332), __webpack_require__(333), __webpack_require__(334), __webpack_require__(335), __webpack_require__(336), __webpack_require__(337), __webpack_require__(338), [__webpack_require__(339), 2], [ __webpack_require__(340), { 'checked': 'x', 'unchecked': ' ' } ], [__webpack_require__(341), 'fenced'], [__webpack_require__(342), '`'], [__webpack_require__(343), 'md'], [__webpack_require__(344), 1], [__webpack_require__(345), 'atx'], [ __webpack_require__(346), [ { no: 'Github', yes: 'GitHub' }, { no: 'Javascript', yes: 'JavaScript' }, { no: 'Node.JS', yes: 'Node.js' }, { no: 'v8', yes: 'V8' } ] ], [__webpack_require__(347), '*'], [__webpack_require__(348), 'padded'] ]; /***/ }), /* 305 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var control = __webpack_require__(306) module.exports = lint /* `remark-lint`. This adds support for ignoring stuff from * messages (``). * All rules are in their own packages and presets. */ function lint() { this.use(lintMessageControl) } function lintMessageControl() { return control({name: 'lint', source: 'remark-lint'}) } /***/ }), /* 306 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var control = __webpack_require__(307); var marker = __webpack_require__(308); var xtend = __webpack_require__(7); module.exports = messageControl; function messageControl(options) { var settings = options || {}; return control(xtend(options, { marker: settings.marker || marker, test: settings.test || 'html' })); } /***/ }), /* 307 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var trim = __webpack_require__(14) var location = __webpack_require__(19) var visit = __webpack_require__(1) /* Map of allowed verbs. */ var ALLOWED_VERBS = { enable: true, disable: true, ignore: true } module.exports = messageControl function messageControl(options) { var name = options && options.name var marker = options && options.marker var test = options && options.test var sources var known var reset var enable var disable if (!name) { throw new Error('Expected `name` in `options`, got `' + name + '`') } if (!marker) { throw new Error('Expected `name` in `options`, got `' + name + '`') } if (!test) { throw new Error('Expected `test` in `options`, got `' + test + '`') } known = options.known reset = options.reset enable = options.enable || [] disable = options.disable || [] sources = options.source if (!sources) { sources = [name] } else if (typeof sources === 'string') { sources = [sources] } return transformer function transformer(tree, file) { var toOffset = location(file).toOffset var initial = !reset var gaps = detectGaps(tree, file) var scope = {} var globals = [] visit(tree, test, visitor) file.messages = file.messages.filter(filter) function visitor(node, position, parent) { var mark = marker(node) var ruleIds var ruleId var verb var index var length var next var pos var tail if (!mark || mark.name !== options.name) { return } ruleIds = mark.attributes.split(/\s/g) verb = ruleIds.shift() next = parent.children[position + 1] pos = mark.node.position && mark.node.position.start tail = next && next.position && next.position.end if (!verb || !ALLOWED_VERBS[verb] === true) { file.fail( 'Unknown keyword `' + verb + '`: expected ' + "`'enable'`, `'disable'`, or `'ignore'`", mark.node ) } length = ruleIds.length index = -1 while (++index < length) { ruleId = ruleIds[index] if (isKnown(ruleId, verb, mark.node)) { toggle(pos, verb === 'enable', ruleId) if (verb === 'ignore') { toggle(tail, true, ruleId) } } } /* Apply to all rules. */ if (!length) { if (verb === 'ignore') { toggle(pos, false) toggle(tail, true) } else { toggle(pos, verb === 'enable') reset = verb !== 'enable' } } } function filter(message) { var gapIndex = gaps.length var ruleId = message.ruleId var ranges = scope[ruleId] var pos /* Keep messages from a different source. */ if (!message.source || sources.indexOf(message.source) === -1) { return true } /* We only ignore messages if they‘re disabled, * *not* when they’re not in the document. */ if (!message.line) { message.line = 1 } if (!message.column) { message.column = 1 } /* Check whether the warning is inside a gap. */ pos = toOffset(message) while (gapIndex--) { if (gaps[gapIndex].start <= pos && gaps[gapIndex].end > pos) { return false } } /* Check whether allowed by specific and global states. */ return check(message, ranges, ruleId) && check(message, globals) } /* Helper to check (and possibly warn) if a ruleId is unknown. */ function isKnown(ruleId, verb, pos) { var result = known ? known.indexOf(ruleId) !== -1 : true if (!result) { file.warn('Unknown rule: cannot ' + verb + " `'" + ruleId + "'`", pos) } return result } /* Get the latest state of a rule. When without `ruleId`, gets global state. */ function getState(ruleId) { var ranges = ruleId ? scope[ruleId] : globals if (ranges && ranges.length !== 0) { return ranges[ranges.length - 1].state } if (!ruleId) { return !reset } if (reset) { return enable.indexOf(ruleId) !== -1 } return disable.indexOf(ruleId) === -1 } /* Handle a rule. */ function toggle(pos, state, ruleId) { var markers = ruleId ? scope[ruleId] : globals var currentState var previousState if (!markers) { markers = [] scope[ruleId] = markers } previousState = getState(ruleId) currentState = state if (currentState !== previousState) { markers.push({state: currentState, position: pos}) } /* Toggle all known rules. */ if (!ruleId) { for (ruleId in scope) { toggle(pos, state, ruleId) } } } /* Check all `ranges` for `message`. */ function check(message, ranges, id) { /* Check the state at the message's position. */ var index = ranges && ranges.length var length = -1 var range while (--index > length) { range = ranges[index] /* istanbul ignore if - generated marker. */ if (!range.position || !range.position.line || !range.position.column) { continue } if ( range.position.line < message.line || (range.position.line === message.line && range.position.column < message.column) ) { return range.state === true } } /* The first marker ocurred after the first * message, so we check the initial state. */ if (!id) { return initial || reset } return reset ? enable.indexOf(id) !== -1 : disable.indexOf(id) === -1 } } } /* Detect gaps in `ast`. */ function detectGaps(tree, file) { var lastNode = tree.children[tree.children.length - 1] var offset = 0 var isGap = false var gaps = [] /* Find all gaps. */ visit(tree, one) /* Get the end of the document. * This detects if the last node was the last node. * If not, there’s an extra gap between the last node * and the end of the document. */ if ( lastNode && lastNode.position && lastNode.position.end && offset === lastNode.position.end.offset && trim(file.toString().slice(offset)) !== '' ) { update() update( tree && tree.position && tree.position.end && tree.position.end.offset - 1 ) } return gaps function one(node) { var pos = node.position update(pos && pos.start && pos.start.offset) if (!node.children) { update(pos && pos.end && pos.end.offset) } } /* Detect a new position. */ function update(latest) { if (latest === null || latest === undefined) { isGap = true return } if (offset >= latest) { return } if (isGap) { gaps.push({start: offset, end: latest}) isGap = false } offset = latest } } /***/ }), /* 308 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /* Expose. */ module.exports = marker /* HTML type. */ var T_HTML = 'html' /* Expression for eliminating extra spaces */ var SPACES = /\s+/g /* Expression for parsing parameters. */ var PARAMETERS = new RegExp( '\\s+' + '(' + '[-a-z0-9_]+' + ')' + '(?:' + '=' + '(?:' + '"' + '(' + '(?:' + '\\\\[\\s\\S]' + '|' + '[^"]' + ')+' + ')' + '"' + '|' + "'" + '(' + '(?:' + '\\\\[\\s\\S]' + '|' + "[^']" + ')+' + ')' + "'" + '|' + '(' + '(?:' + '\\\\[\\s\\S]' + '|' + '[^"\'\\s]' + ')+' + ')' + ')' + ')?', 'gi' ) var MARKER = new RegExp( '(' + '\\s*' + '' + '\\s*' + ')' ) /* Parse a comment marker */ function marker(node) { var value var match var params if (!node || node.type !== T_HTML) { return null } value = node.value match = value.match(MARKER) if (!match || match[1].length !== value.length) { return null } params = parameters(match[3] || '') if (!params) { return null } return { name: match[2], attributes: match[4] || '', parameters: params, node: node } } /* Parse `value` into an object. */ function parameters(value) { var attributes = {} var rest = value.replace(PARAMETERS, replacer) return rest.replace(SPACES, '') ? null : attributes /* eslint-disable max-params */ function replacer($0, $1, $2, $3, $4) { var result = $2 || $3 || $4 || '' if (result === 'true' || result === '') { result = true } else if (result === 'false') { result = false } else if (!isNaN(result)) { result = Number(result) } attributes[$1] = result return '' } } /***/ }), /* 309 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * @author Titus Wormer * @copyright 2015 Titus Wormer * @license MIT * @module checkbox-content-indent * @fileoverview * Warn when list item checkboxes are followed by too much white-space. * * @example {"name": "valid.md"} * * - [ ] List item * + [x] List Item * * [X] List item * - [ ] List item * * @example {"name": "invalid.md", "label": "input"} * * - [ ] List item * + [x] List item * * [X] List item * - [ ] List item * * @example {"name": "invalid.md", "label": "output"} * * 2:7-2:8: Checkboxes should be followed by a single character * 3:7-3:9: Checkboxes should be followed by a single character * 4:7-4:10: Checkboxes should be followed by a single character */ var rule = __webpack_require__(0) var vfileLocation = __webpack_require__(19) var visit = __webpack_require__(1) var position = __webpack_require__(3) var generated = __webpack_require__(2) module.exports = rule( 'remark-lint:checkbox-content-indent', checkboxContentIndent ) var start = position.start var end = position.end var reason = 'Checkboxes should be followed by a single character' function checkboxContentIndent(tree, file) { var contents = String(file) var location = vfileLocation(file) visit(tree, 'listItem', visitor) function visitor(node) { var initial var final var value /* Exit early for items without checkbox. */ if (typeof node.checked !== 'boolean' || generated(node)) { return } initial = start(node).offset /* istanbul ignore next - hard to test, couldn’t find a case. */ final = (node.children.length ? start(node.children[0]) : end(node)).offset while (/[^\S\n]/.test(contents.charAt(final))) { final++ } /* For a checkbox to be parsed, it must be followed * by a white space. */ value = contents.slice(initial, final) value = value.slice(value.indexOf(']') + 1) if (value.length !== 1) { file.message(reason, { start: location.toPosition(final - value.length + 1), end: location.toPosition(final) }) } } } /***/ }), /* 310 */ /***/ (function(module, exports, __webpack_require__) { /** * Module Dependencies */ var sliced = __webpack_require__(311); var noop = function(){}; var co = __webpack_require__(312); /** * Export `wrapped` */ module.exports = wrapped; /** * Wrap a function to support * sync, async, and gen functions. * * @param {Function} fn * @return {Function} * @api public */ function wrapped(fn) { function wrap() { var args = sliced(arguments); var last = args[args.length - 1]; var ctx = this; // done var done = typeof last == 'function' ? args.pop() : noop; // nothing if (!fn) { return done.apply(ctx, [null].concat(args)); } // generator if (generator(fn)) { return co(fn).apply(ctx, args.concat(done)); } // async if (fn.length > args.length) { // NOTE: this only handles uncaught synchronous errors try { return fn.apply(ctx, args.concat(done)); } catch (e) { return done(e); } } // sync return sync(fn, done).apply(ctx, args); } return wrap; } /** * Wrap a synchronous function execution. * * @param {Function} fn * @param {Function} done * @return {Function} * @api private */ function sync(fn, done) { return function () { var ret; try { ret = fn.apply(this, arguments); } catch (err) { return done(err); } if (promise(ret)) { ret.then(function (value) { done(null, value); }, done); } else { ret instanceof Error ? done(ret) : done(null, ret); } } } /** * Is `value` a generator? * * @param {Mixed} value * @return {Boolean} * @api private */ function generator(value) { return value && value.constructor && 'GeneratorFunction' == value.constructor.name; } /** * Is `value` a promise? * * @param {Mixed} value * @return {Boolean} * @api private */ function promise(value) { return value && 'function' == typeof value.then; } /***/ }), /* 311 */ /***/ (function(module, exports) { /** * An Array.prototype.slice.call(arguments) alternative * * @param {Object} args something with a length * @param {Number} slice * @param {Number} sliceEnd * @api public */ module.exports = function (args, slice, sliceEnd) { var ret = []; var len = args.length; if (0 === len) return ret; var start = slice < 0 ? Math.max(0, slice + len) : slice || 0; if (sliceEnd !== undefined) { len = sliceEnd < 0 ? sliceEnd + len : sliceEnd } while (len-- > start) { ret[len - start] = args[len]; } return ret; } /***/ }), /* 312 */ /***/ (function(module, exports) { /** * slice() reference. */ var slice = Array.prototype.slice; /** * Expose `co`. */ module.exports = co; /** * Wrap the given generator `fn` and * return a thunk. * * @param {Function} fn * @return {Function} * @api public */ function co(fn) { var isGenFun = isGeneratorFunction(fn); return function (done) { var ctx = this; // in toThunk() below we invoke co() // with a generator, so optimize for // this case var gen = fn; // we only need to parse the arguments // if gen is a generator function. if (isGenFun) { var args = slice.call(arguments), len = args.length; var hasCallback = len && 'function' == typeof args[len - 1]; done = hasCallback ? args.pop() : error; gen = fn.apply(this, args); } else { done = done || error; } next(); // #92 // wrap the callback in a setImmediate // so that any of its errors aren't caught by `co` function exit(err, res) { setImmediate(function(){ done.call(ctx, err, res); }); } function next(err, res) { var ret; // multiple args if (arguments.length > 2) res = slice.call(arguments, 1); // error if (err) { try { ret = gen.throw(err); } catch (e) { return exit(e); } } // ok if (!err) { try { ret = gen.next(res); } catch (e) { return exit(e); } } // done if (ret.done) return exit(null, ret.value); // normalize ret.value = toThunk(ret.value, ctx); // run if ('function' == typeof ret.value) { var called = false; try { ret.value.call(ctx, function(){ if (called) return; called = true; next.apply(ctx, arguments); }); } catch (e) { setImmediate(function(){ if (called) return; called = true; next(e); }); } return; } // invalid next(new TypeError('You may only yield a function, promise, generator, array, or object, ' + 'but the following was passed: "' + String(ret.value) + '"')); } } } /** * Convert `obj` into a normalized thunk. * * @param {Mixed} obj * @param {Mixed} ctx * @return {Function} * @api private */ function toThunk(obj, ctx) { if (isGeneratorFunction(obj)) { return co(obj.call(ctx)); } if (isGenerator(obj)) { return co(obj); } if (isPromise(obj)) { return promiseToThunk(obj); } if ('function' == typeof obj) { return obj; } if (isObject(obj) || Array.isArray(obj)) { return objectToThunk.call(ctx, obj); } return obj; } /** * Convert an object of yieldables to a thunk. * * @param {Object} obj * @return {Function} * @api private */ function objectToThunk(obj){ var ctx = this; var isArray = Array.isArray(obj); return function(done){ var keys = Object.keys(obj); var pending = keys.length; var results = isArray ? new Array(pending) // predefine the array length : new obj.constructor(); var finished; if (!pending) { setImmediate(function(){ done(null, results) }); return; } // prepopulate object keys to preserve key ordering if (!isArray) { for (var i = 0; i < pending; i++) { results[keys[i]] = undefined; } } for (var i = 0; i < keys.length; i++) { run(obj[keys[i]], keys[i]); } function run(fn, key) { if (finished) return; try { fn = toThunk(fn, ctx); if ('function' != typeof fn) { results[key] = fn; return --pending || done(null, results); } fn.call(ctx, function(err, res){ if (finished) return; if (err) { finished = true; return done(err); } results[key] = res; --pending || done(null, results); }); } catch (err) { finished = true; done(err); } } } } /** * Convert `promise` to a thunk. * * @param {Object} promise * @return {Function} * @api private */ function promiseToThunk(promise) { return function(fn){ promise.then(function(res) { fn(null, res); }, fn); } } /** * Check if `obj` is a promise. * * @param {Object} obj * @return {Boolean} * @api private */ function isPromise(obj) { return obj && 'function' == typeof obj.then; } /** * Check if `obj` is a generator. * * @param {Mixed} obj * @return {Boolean} * @api private */ function isGenerator(obj) { return obj && 'function' == typeof obj.next && 'function' == typeof obj.throw; } /** * Check if `obj` is a generator function. * * @param {Mixed} obj * @return {Boolean} * @api private */ function isGeneratorFunction(obj) { return obj && obj.constructor && 'GeneratorFunction' == obj.constructor.name; } /** * Check for plain object. * * @param {Mixed} val * @return {Boolean} * @api private */ function isObject(val) { return val && Object == val.constructor; } /** * Throw `err` in a new stack. * * This is used when co() is invoked * without supplying a callback, which * should only be for demonstrational * purposes. * * @param {Error} err * @api private */ function error(err) { if (!err) return; setImmediate(function(){ throw err; }); } /***/ }), /* 313 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * @author Titus Wormer * @copyright 2015 Titus Wormer * @license MIT * @module definition-spacing * @fileoverview * Warn when consecutive white space is used in a definition. * * @example {"name": "valid.md"} * * [example domain]: http://example.com "Example Domain" * * @example {"name": "invalid.md", "label": "input"} * * [example····domain]: http://example.com "Example Domain" * * @example {"name": "invalid.md", "label": "output"} * * 1:1-1:57: Do not use consecutive white-space in definition labels */ var rule = __webpack_require__(0) var visit = __webpack_require__(1) var position = __webpack_require__(3) var generated = __webpack_require__(2) module.exports = rule('remark-lint:definition-spacing', definitionSpacing) var label = /^\s*\[((?:\\[\s\S]|[^[\]])+)]/ var reason = 'Do not use consecutive white-space in definition labels' function definitionSpacing(tree, file) { var contents = String(file) visit(tree, ['definition', 'footnoteDefinition'], validate) function validate(node) { var start = position.start(node).offset var end = position.end(node).offset if ( !generated(node) && /[ \t\n]{2,}/.test(contents.slice(start, end).match(label)[1]) ) { file.message(reason, node) } } } /***/ }), /* 314 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * @author Titus Wormer * @copyright 2015 Titus Wormer * @license MIT * @module fenced-code-flag * @fileoverview * Check fenced code-block flags. * * Options: `Array.` or `Object`, optional. * * Providing an array is as passing `{flags: Array}`. * * The object can have an array of `'flags'` which are deemed valid. * In addition it can have the property `allowEmpty` (`boolean`, default: * `false`) which signifies whether or not to warn for fenced code-blocks * without language flags. * * @example {"name": "valid.md"} * * ```alpha * bravo(); * ``` * * @example {"name": "invalid.md", "label": "input"} * * ``` * alpha(); * ``` * * @example {"name": "invalid.md", "label": "output"} * * 1:1-3:4: Missing code-language flag * * @example {"name": "valid.md", "setting": {"allowEmpty": true}} * * ``` * alpha(); * ``` * * @example {"name": "invalid.md", "setting": {"allowEmpty": false}, "label": "input"} * * ``` * alpha(); * ``` * * @example {"name": "invalid.md", "setting": {"allowEmpty": false}, "label": "output"} * * 1:1-3:4: Missing code-language flag * * @example {"name": "valid.md", "setting": ["alpha"]} * * ```alpha * bravo(); * ``` * * @example {"name": "invalid.md", "setting": ["charlie"], "label": "input"} * * ```alpha * bravo(); * ``` * * @example {"name": "invalid.md", "setting": ["charlie"], "label": "output"} * * 1:1-3:4: Invalid code-language flag */ var rule = __webpack_require__(0) var visit = __webpack_require__(1) var position = __webpack_require__(3) var generated = __webpack_require__(2) module.exports = rule('remark-lint:fenced-code-flag', fencedCodeFlag) var start = position.start var end = position.end var fence = /^ {0,3}([~`])\1{2,}/ var reasonInvalid = 'Invalid code-language flag' var reasonMissing = 'Missing code-language flag' function fencedCodeFlag(tree, file, pref) { var contents = String(file) var allowEmpty = false var flags = [] if (typeof pref === 'object' && !('length' in pref)) { allowEmpty = Boolean(pref.allowEmpty) pref = pref.flags } if (typeof pref === 'object' && 'length' in pref) { flags = String(pref).split(',') } visit(tree, 'code', visitor) function visitor(node) { var value if (!generated(node)) { if (node.lang) { if (flags.length !== 0 && flags.indexOf(node.lang) === -1) { file.message(reasonInvalid, node) } } else { value = contents.slice(start(node).offset, end(node).offset) if (!allowEmpty && fence.test(value)) { file.message(reasonMissing, node) } } } } } /***/ }), /* 315 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * @author Titus Wormer * @copyright 2015 Titus Wormer * @license MIT * @module final-definition * @fileoverview * Warn when definitions are not placed at the end of the file. * * @example {"name": "valid.md"} * * Paragraph. * * [example]: http://example.com "Example Domain" * * @example {"name": "invalid.md", "label": "input"} * * Paragraph. * * [example]: http://example.com "Example Domain" * * Another paragraph. * * @example {"name": "invalid.md", "label": "output"} * * 3:1-3:47: Move definitions to the end of the file (after the node at line `5`) */ var rule = __webpack_require__(0) var visit = __webpack_require__(1) var position = __webpack_require__(3) var generated = __webpack_require__(2) module.exports = rule('remark-lint:final-definition', finalDefinition) var start = position.start function finalDefinition(tree, file) { var last = null visit(tree, visitor, true) function visitor(node) { var line = start(node).line /* Ignore generated nodes. */ if (node.type === 'root' || generated(node)) { return } if (node.type === 'definition') { if (last !== null && last > line) { file.message( 'Move definitions to the end of the file (after the node at line `' + last + '`)', node ) } } else if (last === null) { last = line } } } /***/ }), /* 316 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * @author Titus Wormer * @copyright 2015 Titus Wormer * @license MIT * @module final-newline * @fileoverview * Warn when a newline at the end of a file is missing. Empty files are allowed. * * See [StackExchange](http://unix.stackexchange.com/questions/18743) for why. * * ## Fix * * [`remark-stringify`](https://github.com/remarkjs/remark/tree/master/packages/remark-stringify) * always adds a final newline to files. * * See [Using remark to fix your markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown) * on how to automatically fix warnings for this rule. * * ## Example * * ##### `valid.md` * * ###### In * * Note: `␊` represents LF. * * ```markdown * Alpha␊ * ``` * * ###### Out * * No messages. * * ##### `invalid.md` * * ###### In * * Note: The below file does not have a final newline. * * ```markdown * Bravo * ``` * * ###### Out * * ```text * 1:1: Missing newline character at end of file * ``` */ var rule = __webpack_require__(0) module.exports = rule('remark-lint:final-newline', finalNewline) function finalNewline(tree, file) { var contents = String(file) var last = contents.length - 1 if (last > -1 && contents.charAt(last) !== '\n') { file.message('Missing newline character at end of file') } } /***/ }), /* 317 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * @author Titus Wormer * @copyright 2015 Titus Wormer * @license MIT * @module list-item-indent * @fileoverview * Warn when the spacing between a list item’s bullet and its content * violates a given style. * * Options: `'tab-size'`, `'mixed'`, or `'space'`, default: `'tab-size'`. * * ## Fix * * [`remark-stringify`](https://github.com/remarkjs/remark/tree/master/packages/remark-stringify) * uses `'tab-size'` (named `'tab'` there) by default to ensure markdown is * seen the same way across vendors. This can be configured with the * [`listItemIndent`](https://github.com/remarkjs/remark/tree/master/packages/remark-stringify#optionslistitemindent) * option. This rule’s `'space'` option is named `'1'` there. * * See [Using remark to fix your markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown) * on how to automatically fix warnings for this rule. * * @example {"name": "valid.md"} * * *···List * ····item. * * Paragraph. * * 11.·List * ····item. * * Paragraph. * * *···List * ····item. * * *···List * ····item. * * @example {"name": "valid.md", "setting": "mixed"} * * *·List item. * * Paragraph. * * 11.·List item * * Paragraph. * * *···List * ····item. * * *···List * ····item. * * @example {"name": "valid.md", "setting": "space"} * * *·List item. * * Paragraph. * * 11.·List item * * Paragraph. * * *·List * ··item. * * *·List * ··item. * * @example {"name": "invalid.md", "setting": "space", "label": "input"} * * *···List * ····item. * * @example {"name": "invalid.md", "setting": "space", "label": "output"} * * 1:5: Incorrect list-item indent: remove 2 spaces * * @example {"name": "invalid.md", "setting": "tab-size", "label": "input"} * * *·List * ··item. * * @example {"name": "invalid.md", "setting": "tab-size", "label": "output"} * * 1:3: Incorrect list-item indent: add 2 spaces * * @example {"name": "invalid.md", "setting": "mixed", "label": "input"} * * *···List item. * * @example {"name": "invalid.md", "setting": "mixed", "label": "output"} * * 1:5: Incorrect list-item indent: remove 2 spaces * * @example {"name": "invalid.md", "setting": "invalid", "label": "output", "config": {"positionless": true}} * * 1:1: Invalid list-item indent style `invalid`: use either `'tab-size'`, `'space'`, or `'mixed'` */ var rule = __webpack_require__(0) var plural = __webpack_require__(31) var visit = __webpack_require__(1) var position = __webpack_require__(3) var generated = __webpack_require__(2) module.exports = rule('remark-lint:list-item-indent', listItemIndent) var start = position.start var styles = {'tab-size': true, mixed: true, space: true} function listItemIndent(tree, file, pref) { var contents = String(file) pref = typeof pref === 'string' ? pref : 'tab-size' if (styles[pref] !== true) { file.fail( 'Invalid list-item indent style `' + pref + "`: use either `'tab-size'`, `'space'`, or `'mixed'`" ) } visit(tree, 'list', visitor) function visitor(node) { var spread = node.spread || node.loose if (!generated(node)) { node.children.forEach(visitItem) } function visitItem(item) { var head = item.children[0] var final = start(head) var marker var bulletSize var style var diff var reason marker = contents .slice(start(item).offset, final.offset) .replace(/\[[x ]?]\s*$/i, '') bulletSize = marker.trimRight().length style = pref === 'tab-size' || (pref === 'mixed' && spread) ? Math.ceil(bulletSize / 4) * 4 : bulletSize + 1 if (marker.length !== style) { diff = style - marker.length reason = 'Incorrect list-item indent: ' + (diff > 0 ? 'add' : 'remove') + ' ' + Math.abs(diff) + ' ' + plural('space', diff) file.message(reason, final) } } } } /***/ }), /* 318 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /* WEBPACK VAR INJECTION */(function(module) { const irregularPlurals = __webpack_require__(319); const map = new Map(); // TODO: Use Object.entries when targeting Node.js 8 for (const key of Object.keys(irregularPlurals)) { map.set(key, irregularPlurals[key]); } // Ensure nobody can modify each others Map Object.defineProperty(module, 'exports', { get() { return map; } }); /* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(46)(module))) /***/ }), /* 319 */ /***/ (function(module) { module.exports = {"addendum":"addenda","aircraft":"aircraft","alga":"algae","alumna":"alumnae","alumnus":"alumni","amoeba":"amoebae","analysis":"analyses","antenna":"antennae","antithesis":"antitheses","apex":"apices","appendix":"appendices","automaton":"automata","axis":"axes","bacillus":"bacilli","bacterium":"bacteria","barracks":"barracks","basis":"bases","beau":"beaux","bison":"bison","buffalo":"buffalo","bureau":"bureaus","cactus":"cacti","calf":"calves","carp":"carp","census":"censuses","chassis":"chassis","cherub":"cherubim","child":"children","château":"châteaus","cod":"cod","codex":"codices","concerto":"concerti","corpus":"corpora","crisis":"crises","criterion":"criteria","curriculum":"curricula","datum":"data","deer":"deer","diagnosis":"diagnoses","die":"dice","dwarf":"dwarfs","echo":"echoes","elf":"elves","elk":"elk","ellipsis":"ellipses","embargo":"embargoes","emphasis":"emphases","erratum":"errata","faux pas":"faux pas","fez":"fezes","firmware":"firmware","fish":"fish","focus":"foci","foot":"feet","formula":"formulae","fungus":"fungi","gallows":"gallows","genus":"genera","goose":"geese","graffito":"graffiti","grouse":"grouse","half":"halves","hero":"heroes","hoof":"hooves","hovercraft":"hovercraft","hypothesis":"hypotheses","index":"indices","kakapo":"kakapo","knife":"knives","larva":"larvae","leaf":"leaves","libretto":"libretti","life":"lives","loaf":"loaves","locus":"loci","louse":"lice","man":"men","matrix":"matrices","means":"means","medium":"media","memorandum":"memoranda","millennium":"millennia","minutia":"minutiae","moose":"moose","mouse":"mice","nebula":"nebulae","nemesis":"nemeses","neurosis":"neuroses","news":"news","nucleus":"nuclei","oasis":"oases","offspring":"offspring","opus":"opera","ovum":"ova","ox":"oxen","paralysis":"paralyses","parenthesis":"parentheses","person":"people","phenomenon":"phenomena","phylum":"phyla","pike":"pike","polyhedron":"polyhedra","potato":"potatoes","prognosis":"prognoses","quiz":"quizzes","radius":"radii","referendum":"referenda","salmon":"salmon","scarf":"scarves","self":"selves","series":"series","sheep":"sheep","shelf":"shelves","shrimp":"shrimp","spacecraft":"spacecraft","species":"species","spectrum":"spectra","squid":"squid","stimulus":"stimuli","stratum":"strata","swine":"swine","syllabus":"syllabi","symposium":"symposia","synopsis":"synopses","synthesis":"syntheses","tableau":"tableaus","that":"those","thesis":"theses","thief":"thieves","this":"these","tomato":"tomatoes","tooth":"teeth","trout":"trout","tuna":"tuna","vertebra":"vertebrae","vertex":"vertices","veto":"vetoes","vita":"vitae","vortex":"vortices","watercraft":"watercraft","wharf":"wharves","wife":"wives","wolf":"wolves","woman":"women"}; /***/ }), /* 320 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * @author Titus Wormer * @copyright 2015 Titus Wormer * @license MIT * @module maximum-line-length * @fileoverview * Warn when lines are too long. * * Options: `number`, default: `80`. * * Ignores nodes that cannot be wrapped, such as headings, tables, * code, and definitions. * * Ignores images, links, and inline code if they start before the wrap, end * after the wrap, and there’s no white-space after them. * * @example {"name": "valid.md", "config": {"positionless": true}} * * This line is simply not toooooooooooooooooooooooooooooooooooooooooooo * long. * * This is also fine: * * * * `alphaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJuliettKiloLimaMikeNovemberOscarPapaQuebec.romeo()` * * [foo](http://this-long-url-with-a-long-domain-is-valid.co.uk/a-long-path?query=variables) * * * * ![foo](http://this-long-url-with-a-long-domain-is-valid.co.uk/a-long-path?query=variables) * * | An | exception | is | line | length | in | long | tables | because | those | can’t | just | * | -- | --------- | -- | ---- | ------ | -- | ---- | ------ | ------- | ----- | ----- | ---- | * | be | helped | | | | | | | | | | . | * * The following is also fine, because there is no white-space. * * . * * In addition, definitions are also fine: * * [foo]: * * @example {"name": "invalid.md", "setting": 80, "label": "input", "config": {"positionless": true}} * * This line is simply not tooooooooooooooooooooooooooooooooooooooooooooooooooooooo * long. * * Just like thiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiis one. * * And this one is also very wrong: because the link starts aaaaaaafter the column: * * and such. * * And this one is also very wrong: because the code starts aaaaaaafter the column: `alpha.bravo()` * * `alphaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJuliettKiloLimaMikeNovemberOscar.papa()` and such. * * @example {"name": "invalid.md", "setting": 80, "label": "output", "config": {"positionless": true}} * * 4:86: Line must be at most 80 characters * 6:99: Line must be at most 80 characters * 8:97: Line must be at most 80 characters * 10:97: Line must be at most 80 characters * 12:99: Line must be at most 80 characters * * @example {"name": "valid-mixed-line-endings.md", "setting": 10, "config": {"positionless": true}} * * 0123456789␍␊ * 0123456789␊ * 01234␍␊ * 01234␊ * * @example {"name": "invalid-mixed-line-endings.md", "setting": 10, "label": "input", "config": {"positionless": true}} * * 012345678901␍␊ * 012345678901␊ * 01234567890␍␊ * 01234567890␊ * * @example {"name": "invalid-mixed-line-endings.md", "setting": 10, "label": "output", "config": {"positionless": true}} * * 1:13: Line must be at most 10 characters * 2:13: Line must be at most 10 characters * 3:12: Line must be at most 10 characters * 4:12: Line must be at most 10 characters */ var rule = __webpack_require__(0) var visit = __webpack_require__(1) var position = __webpack_require__(3) var generated = __webpack_require__(2) module.exports = rule('remark-lint:maximum-line-length', maximumLineLength) var start = position.start var end = position.end function maximumLineLength(tree, file, pref) { var style = typeof pref === 'number' && !isNaN(pref) ? pref : 80 var content = String(file) var lines = content.split(/\r?\n/) var length = lines.length var index = -1 var lineLength visit(tree, ['heading', 'table', 'code', 'definition'], ignore) visit(tree, ['link', 'image', 'inlineCode'], inline) /* Iterate over every line, and warn for violating lines. */ while (++index < length) { lineLength = lines[index].length if (lineLength > style) { file.message('Line must be at most ' + style + ' characters', { line: index + 1, column: lineLength + 1 }) } } /* Finally, whitelist some inline spans, but only if they occur at or after * the wrap. However, when they do, and there’s white-space after it, they * are not whitelisted. */ function inline(node, pos, parent) { var next = parent.children[pos + 1] var initial var final /* istanbul ignore if - Nothing to whitelist when generated. */ if (generated(node)) { return } initial = start(node) final = end(node) /* No whitelisting when starting after the border, or ending before it. */ if (initial.column > style || final.column < style) { return } /* No whitelisting when there’s white-space after * the link. */ if ( next && start(next).line === initial.line && (!next.value || /^(.+?[ \t].+?)/.test(next.value)) ) { return } whitelist(initial.line - 1, final.line) } function ignore(node) { /* istanbul ignore else - Hard to test, as we only run this case on `position: true` */ if (!generated(node)) { whitelist(start(node).line - 1, end(node).line) } } /* Whitelist from `initial` to `final`, zero-based. */ function whitelist(initial, final) { while (initial < final) { lines[initial++] = '' } } } /***/ }), /* 321 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * @author Titus Wormer * @copyright 2015 Titus Wormer * @license MIT * @module no-auto-link-without-protocol * @fileoverview * Warn for angle-bracketed links without protocol. * * ## Fix * * [`remark-stringify`](https://github.com/remarkjs/remark/tree/master/packages/remark-stringify) * adds a protocol where needed. * * See [Using remark to fix your markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown) * on how to automatically fix warnings for this rule. * * @example {"name": "valid.md"} * * * * * Most markdown vendors don’t recognize the following as a link: * * * @example {"name": "invalid.md", "label": "input"} * * * * @example {"name": "invalid.md", "label": "output"} * * 1:1-1:14: All automatic links must start with a protocol */ var rule = __webpack_require__(0) var visit = __webpack_require__(1) var position = __webpack_require__(3) var generated = __webpack_require__(2) var toString = __webpack_require__(45) module.exports = rule( 'remark-lint:no-auto-link-without-protocol', noAutoLinkWithoutProtocol ) var start = position.start var end = position.end /* Protocol expression. See: * http://en.wikipedia.org/wiki/URI_scheme#Generic_syntax */ var protocol = /^[a-z][a-z+.-]+:\/?/i var reason = 'All automatic links must start with a protocol' function noAutoLinkWithoutProtocol(tree, file) { visit(tree, 'link', visitor) function visitor(node) { var children if (!generated(node)) { children = node.children if ( start(node).column === start(children[0]).column - 1 && end(node).column === end(children[children.length - 1]).column + 1 && !protocol.test(toString(node)) ) { file.message(reason, node) } } } } /***/ }), /* 322 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * @author Titus Wormer * @copyright 2015 Titus Wormer * @license MIT * @module no-blockquote-without-marker * @fileoverview * Warn when blank lines without markers (`>`) are found in a blockquote. * * ## Fix * * [`remark-stringify`](https://github.com/remarkjs/remark/tree/master/packages/remark-stringify) * adds markers to every line in a blockquote. * * See [Using remark to fix your markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown) * on how to automatically fix warnings for this rule. * * @example {"name": "valid.md"} * * > Foo... * > * > ...Bar. * * @example {"name": "invalid.md", "label": "input"} * * > Foo... * * > ...Bar. * * @example {"name": "invalid.md", "label": "output"} * * 2:1: Missing marker in blockquote */ var rule = __webpack_require__(0) var vfileLocation = __webpack_require__(19) var visit = __webpack_require__(1) var position = __webpack_require__(3) var generated = __webpack_require__(2) module.exports = rule( 'remark-lint:no-blockquote-without-marker', noBlockquoteWithoutMarker ) var reason = 'Missing marker in blockquote' function noBlockquoteWithoutMarker(tree, file) { var contents = String(file) var location = vfileLocation(file) var last = contents.length visit(tree, 'blockquote', visitor) function visitor(node) { var indent = node.position && node.position.indent var start var length var index var line var offset var character var pos if (generated(node) || !indent || indent.length === 0) { return } start = position.start(node).line length = indent.length index = -1 while (++index < length) { line = start + index + 1 pos = {line: line, column: indent[index]} offset = location.toOffset(pos) - 1 while (++offset < last) { character = contents.charAt(offset) if (character === '>') { break } /* istanbul ignore else - just for safety */ if (character !== ' ' && character !== '\t') { file.message(reason, pos) break } } } } } /***/ }), /* 323 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * @author Titus Wormer * @copyright 2015 Titus Wormer * @license MIT * @module no-duplicate-definitions * @fileoverview * Warn when duplicate definitions are found. * * @example {"name": "valid.md"} * * [foo]: bar * [baz]: qux * * @example {"name": "invalid.md", "label": "input"} * * [foo]: bar * [foo]: qux * * @example {"name": "invalid.md", "label": "output"} * * 2:1-2:11: Do not use definitions with the same identifier (1:1) */ var rule = __webpack_require__(0) var position = __webpack_require__(3) var generated = __webpack_require__(2) var stringify = __webpack_require__(27) var visit = __webpack_require__(1) module.exports = rule( 'remark-lint:no-duplicate-definitions', noDuplicateDefinitions ) var reason = 'Do not use definitions with the same identifier' function noDuplicateDefinitions(tree, file) { var map = {} visit(tree, ['definition', 'footnoteDefinition'], validate) function validate(node) { var identifier var duplicate if (!generated(node)) { identifier = node.identifier duplicate = map[identifier] if (duplicate && duplicate.type) { file.message( reason + ' (' + stringify(position.start(duplicate)) + ')', node ) } map[identifier] = node } } } /***/ }), /* 324 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * @author Titus Wormer * @copyright 2015 Titus Wormer * @license MIT * @module no-file-name-articles * @fileoverview * Warn when file name start with an article. * * @example {"name": "title.md"} * * @example {"name": "a-title.md", "label": "output", "config": {"positionless": true}} * * 1:1: Do not start file names with `a` * * @example {"name": "the-title.md", "label": "output", "config": {"positionless": true}} * * 1:1: Do not start file names with `the` * * @example {"name": "teh-title.md", "label": "output", "config": {"positionless": true}} * * 1:1: Do not start file names with `teh` * * @example {"name": "an-article.md", "label": "output", "config": {"positionless": true}} * * 1:1: Do not start file names with `an` */ var rule = __webpack_require__(0) module.exports = rule('remark-lint:no-file-name-articles', noFileNameArticles) function noFileNameArticles(tree, file) { var match = file.stem && file.stem.match(/^(the|teh|an?)\b/i) if (match) { file.message('Do not start file names with `' + match[0] + '`') } } /***/ }), /* 325 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * @author Titus Wormer * @copyright 2015 Titus Wormer * @license MIT * @module no-file-name-consecutive-dashes * @fileoverview * Warn when file names contain consecutive dashes. * * @example {"name": "plug-ins.md"} * * @example {"name": "plug--ins.md", "label": "output", "config": {"positionless": true}} * * 1:1: Do not use consecutive dashes in a file name */ var rule = __webpack_require__(0) module.exports = rule( 'remark-lint:no-file-name-consecutive-dashes', noFileNameConsecutiveDashes ) var reason = 'Do not use consecutive dashes in a file name' function noFileNameConsecutiveDashes(tree, file) { if (file.stem && /-{2,}/.test(file.stem)) { file.message(reason) } } /***/ }), /* 326 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * @author Titus Wormer * @copyright 2015 Titus Wormer * @license MIT * @module no-file-name-outer-dashes * @fileoverview * Warn when file names contain initial or final dashes. * * @example {"name": "readme.md"} * * @example {"name": "-readme.md", "label": "output", "config": {"positionless": true}} * * 1:1: Do not use initial or final dashes in a file name * * @example {"name": "readme-.md", "label": "output", "config": {"positionless": true}} * * 1:1: Do not use initial or final dashes in a file name */ var rule = __webpack_require__(0) module.exports = rule( 'remark-lint:no-file-name-outer-dashes', noFileNameOuterDashes ) var reason = 'Do not use initial or final dashes in a file name' function noFileNameOuterDashes(tree, file) { if (file.stem && /^-|-$/.test(file.stem)) { file.message(reason) } } /***/ }), /* 327 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * @author Titus Wormer * @copyright 2015 Titus Wormer * @license MIT * @module no-heading-content-indent * @fileoverview * Warn when a heading’s content is indented. * * ## Fix * * [`remark-stringify`](https://github.com/remarkjs/remark/tree/master/packages/remark-stringify) * removes all unneeded padding around a heading’s content. * * See [Using remark to fix your markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown) * on how to automatically fix warnings for this rule. * * @example {"name": "valid.md"} * * #·Foo * * ## Bar·## * * ##·Baz * * Setext headings are not affected. * * Baz * === * * @example {"name": "invalid.md", "label": "input"} * * #··Foo * * ## Bar··## * * ##··Baz * * @example {"name": "invalid.md", "label": "output"} * * 1:4: Remove 1 space before this heading’s content * 3:7: Remove 1 space after this heading’s content * 5:7: Remove 1 space before this heading’s content * * @example {"name": "empty-heading.md"} * * #·· * * @example {"name": "tight.md", "config":{"pedantic":true}, "label": "input"} * * In pedantic mode, headings without spacing can also be detected: * * ##No spacing left, too much right··## * * @example {"name": "tight.md", "label": "output"} * * 3:3: Add 1 space before this heading’s content * 3:34: Remove 1 space after this heading’s content */ var rule = __webpack_require__(0) var visit = __webpack_require__(1) var style = __webpack_require__(94) var plural = __webpack_require__(31) var position = __webpack_require__(3) var generated = __webpack_require__(2) module.exports = rule( 'remark-lint:no-heading-content-indent', noHeadingContentIndent ) var start = position.start var end = position.end function noHeadingContentIndent(tree, file) { var contents = String(file) visit(tree, 'heading', visitor) function visitor(node) { var depth var children var type var head var initial var final var diff var index var char var reason if (generated(node)) { return } depth = node.depth children = node.children type = style(node, 'atx') if (type === 'atx' || type === 'atx-closed') { initial = start(node) index = initial.offset char = contents.charAt(index) while (char && char !== '#') { char = contents.charAt(++index) } /* istanbul ignore if - CR/LF bug: remarkjs/remark#195. */ if (!char) { return } index = depth + (index - initial.offset) head = start(children[0]).column /* Ignore empty headings. */ if (!head) { return } diff = head - initial.column - 1 - index if (diff) { reason = (diff > 0 ? 'Remove' : 'Add') + ' ' + Math.abs(diff) + ' ' + plural('space', diff) + ' before this heading’s content' file.message(reason, start(children[0])) } } /* Closed ATX-heading always must have a space * between their content and the final hashes, * thus, there is no `add x spaces`. */ if (type === 'atx-closed') { final = end(children[children.length - 1]) diff = end(node).column - final.column - 1 - depth if (diff) { reason = 'Remove ' + diff + ' ' + plural('space', diff) + ' after this heading’s content' file.message(reason, final) } } } } /***/ }), /* 328 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * @author Titus Wormer * @copyright 2015 Titus Wormer * @license MIT * @module no-heading-indent * @fileoverview * Warn when a heading is indented. * * ## Fix * * [`remark-stringify`](https://github.com/remarkjs/remark/tree/master/packages/remark-stringify) * removes all unneeded indentation around headings. * * See [Using remark to fix your markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown) * on how to automatically fix warnings for this rule. * * @example {"name": "valid.md"} * * #·Hello world * * Foo * ----- * * #·Hello world·# * * Bar * ===== * * @example {"name": "invalid.md", "label": "input"} * * ···# Hello world * * ·Foo * ----- * * ·# Hello world # * * ···Bar * ===== * * @example {"name": "invalid.md", "label": "output"} * * 1:4: Remove 3 spaces before this heading * 3:2: Remove 1 space before this heading * 6:2: Remove 1 space before this heading * 8:4: Remove 3 spaces before this heading */ var rule = __webpack_require__(0) var plural = __webpack_require__(31) var visit = __webpack_require__(1) var position = __webpack_require__(3) var generated = __webpack_require__(2) module.exports = rule('remark-lint:no-heading-indent', noHeadingIndent) var start = position.start function noHeadingIndent(tree, file) { var contents = String(file) var length = contents.length visit(tree, 'heading', visitor) function visitor(node) { var initial var begin var index var character var diff if (generated(node)) { return } initial = start(node) begin = initial.offset index = begin - 1 while (++index < length) { character = contents.charAt(index) if (character !== ' ' && character !== '\t') { break } } diff = index - begin if (diff) { file.message( 'Remove ' + diff + ' ' + plural('space', diff) + ' before this heading', { line: initial.line, column: initial.column + diff } ) } } } /***/ }), /* 329 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * @author Titus Wormer * @copyright 2015 Titus Wormer * @license MIT * @module no-inline-padding * @fileoverview * Warn when inline nodes are padded with spaces between their markers and * content. * * Warns for emphasis, strong, delete, images, and links. * * @example {"name": "valid.md"} * * Alpha, *bravo*, _charlie_, [delta](http://echo.fox/trot) * * @example {"name": "invalid.md", "label": "input"} * * Alpha, * bravo *, _ charlie _, [ delta ](http://echo.fox/trot) * * @example {"name": "invalid.md", "label": "output"} * * 1:8-1:17: Don’t pad `emphasis` with inner spaces * 1:19-1:30: Don’t pad `emphasis` with inner spaces * 1:32-1:63: Don’t pad `link` with inner spaces */ var rule = __webpack_require__(0) var visit = __webpack_require__(1) var generated = __webpack_require__(2) var toString = __webpack_require__(45) module.exports = rule('remark-lint:no-inline-padding', noInlinePadding) function noInlinePadding(tree, file) { visit(tree, ['emphasis', 'strong', 'delete', 'image', 'link'], visitor) function visitor(node) { var contents if (!generated(node)) { contents = toString(node) if ( contents.charAt(0) === ' ' || contents.charAt(contents.length - 1) === ' ' ) { file.message('Don’t pad `' + node.type + '` with inner spaces', node) } } } } /***/ }), /* 330 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * @author Titus Wormer * @copyright 2015 Titus Wormer * @license MIT * @module no-multiple-toplevel-headings * @fileoverview * Warn when multiple top-level headings are used. * * Options: `number`, default: `1`. * * @example {"name": "valid.md", "setting": 1} * * # Foo * * ## Bar * * @example {"name": "invalid.md", "setting": 1, "label": "input"} * * # Foo * * # Bar * * @example {"name": "invalid.md", "setting": 1, "label": "output"} * * 3:1-3:6: Don’t use multiple top level headings (1:1) */ var rule = __webpack_require__(0) var visit = __webpack_require__(1) var start = __webpack_require__(3).start var generated = __webpack_require__(2) var stringify = __webpack_require__(27) module.exports = rule( 'remark-lint:no-multiple-toplevel-headings', noMultipleToplevelHeadings ) function noMultipleToplevelHeadings(tree, file, pref) { var style = pref ? pref : 1 var duplicate visit(tree, 'heading', visitor) function visitor(node) { if (!generated(node) && node.depth === style) { if (duplicate) { file.message( 'Don’t use multiple top level headings (' + duplicate + ')', node ) } else { duplicate = stringify(start(node)) } } } } /***/ }), /* 331 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * @author Titus Wormer * @copyright 2015 Titus Wormer * @license MIT * @module no-shell-dollars * @fileoverview * Warn when shell code is prefixed by dollar-characters. * * Ignores indented code blocks and fenced code blocks without language flag. * * @example {"name": "valid.md"} * * ```sh * echo a * echo a > file * ``` * * ```zsh * $ echo a * a * $ echo a > file * ``` * * Some empty code: * * ```command * ``` * * It’s fine to use dollars in non-shell code. * * ```js * $('div').remove(); * ``` * * @example {"name": "invalid.md", "label": "input"} * * ```bash * $ echo a * $ echo a > file * ``` * * @example {"name": "invalid.md", "label": "output"} * * 1:1-4:4: Do not use dollar signs before shell-commands */ var rule = __webpack_require__(0) var visit = __webpack_require__(1) var generated = __webpack_require__(2) module.exports = rule('remark-lint:no-shell-dollars', noShellDollars) var reason = 'Do not use dollar signs before shell-commands' /* List of shell script file extensions (also used as code * flags for syntax highlighting on GitHub): * https://github.com/github/linguist/blob/5bf8cf5/lib/ * linguist/languages.yml#L3002. */ var flags = [ 'sh', 'bash', 'bats', 'cgi', 'command', 'fcgi', 'ksh', 'tmux', 'tool', 'zsh' ] function noShellDollars(tree, file) { visit(tree, 'code', visitor) function visitor(node) { var lines var line var length var index /* Check both known shell-code and unknown code. */ if (!generated(node) && node.lang && flags.indexOf(node.lang) !== -1) { lines = node.value.split('\n') length = lines.length index = -1 if (length <= 1) { return } while (++index < length) { line = lines[index] if (line.trim() && !line.match(/^\s*\$\s*/)) { return } } file.message(reason, node) } } } /***/ }), /* 332 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * @author Titus Wormer * @copyright 2015 Titus Wormer * @license MIT * @module no-shortcut-reference-image * @fileoverview * Warn when shortcut reference images are used. * * Shortcut references render as images when a definition is found, and as * plain text without definition. Sometimes, you don’t intend to create an * image from the reference, but this rule still warns anyway. In that case, * you can escape the reference like so: `!\[foo]`. * * @example {"name": "valid.md"} * * ![foo][] * * [foo]: http://foo.bar/baz.png * * @example {"name": "invalid.md", "label": "input"} * * ![foo] * * [foo]: http://foo.bar/baz.png * * @example {"name": "invalid.md", "label": "output"} * * 1:1-1:7: Use the trailing [] on reference images */ var rule = __webpack_require__(0) var visit = __webpack_require__(1) var generated = __webpack_require__(2) module.exports = rule( 'remark-lint:no-shortcut-reference-image', noShortcutReferenceImage ) var reason = 'Use the trailing [] on reference images' function noShortcutReferenceImage(tree, file) { visit(tree, 'imageReference', visitor) function visitor(node) { if (!generated(node) && node.referenceType === 'shortcut') { file.message(reason, node) } } } /***/ }), /* 333 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * @author Titus Wormer * @copyright 2015 Titus Wormer * @license MIT * @module no-table-indentation * @fileoverview * Warn when tables are indented. * * ## Fix * * [`remark-stringify`](https://github.com/remarkjs/remark/tree/master/packages/remark-stringify) * removes all unneeded indentation before tables. * * See [Using remark to fix your markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown) * on how to automatically fix warnings for this rule. * * @example {"name": "valid.md"} * * Paragraph. * * | A | B | * | ----- | ----- | * | Alpha | Bravo | * * @example {"name": "invalid.md", "label": "input"} * * Paragraph. * * ···| A | B | * ···| ----- | ----- | * ···| Alpha | Bravo | * * @example {"name": "invalid.md", "label": "output"} * * 3:1-3:21: Do not indent table rows * 5:1-5:21: Do not indent table rows */ var rule = __webpack_require__(0) var visit = __webpack_require__(1) var position = __webpack_require__(3) var generated = __webpack_require__(2) module.exports = rule('remark-lint:no-table-indentation', noTableIndentation) var reason = 'Do not indent table rows' function noTableIndentation(tree, file) { var contents = String(file) visit(tree, 'table', visitor) function visitor(node) { if (!generated(node)) { node.children.forEach(each) } return visit.SKIP } function each(row) { var fence = contents.slice( position.start(row).offset, position.start(row.children[0]).offset ) if (fence.indexOf('|') > 1) { file.message(reason, row) } } } /***/ }), /* 334 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * @author Titus Wormer * @copyright 2015 Titus Wormer * @license MIT * @module no-tabs * @fileoverview * Warn when hard tabs are used instead of spaces. * * ## Fix * * [`remark-stringify`](https://github.com/remarkjs/remark/tree/master/packages/remark-stringify) * uses spaces where tabs are used for indentation, but retains tabs used in * content. * * See [Using remark to fix your markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown) * on how to automatically fix warnings for this rule. * * @example {"name": "valid.md"} * * Foo Bar * * ····Foo * * @example {"name": "invalid.md", "label": "input", "config": {"positionless": true}} * * »Here's one before a code block. * * Here's a tab:», and here is another:». * * And this is in `inline»code`. * * >»This is in a block quote. * * *»And... * * »1.»in a list. * * And this is a tab as the last character.» * * @example {"name": "invalid.md", "label": "output"} * * 1:1: Use spaces instead of hard-tabs * 3:14: Use spaces instead of hard-tabs * 3:37: Use spaces instead of hard-tabs * 5:23: Use spaces instead of hard-tabs * 7:2: Use spaces instead of hard-tabs * 9:2: Use spaces instead of hard-tabs * 11:1: Use spaces instead of hard-tabs * 11:4: Use spaces instead of hard-tabs * 13:41: Use spaces instead of hard-tabs */ var rule = __webpack_require__(0) var location = __webpack_require__(19) module.exports = rule('remark-lint:no-tabs', noTabs) var reason = 'Use spaces instead of hard-tabs' function noTabs(tree, file) { var content = String(file) var position = location(file).toPosition var index = content.indexOf('\t') while (index !== -1) { file.message(reason, position(index)) index = content.indexOf('\t', index + 1) } } /***/ }), /* 335 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var rule = __webpack_require__(0); module.exports = rule('remark-lint:no-trailing-spaces', noTrailingSpaces); /** * Lines that are just space characters are not present in * the AST, which is why we loop through lines manually. */ function noTrailingSpaces(ast, file) { var lines = file.toString().split('\n'); for (var i = 0; i < lines.length; i++) { var currentLine = lines[i]; var lineIndex = i + 1; if (/\s$/.test(currentLine)) { file.message('Remove trailing whitespace', { position: { start: { line: lineIndex, column: currentLine.length + 1 }, end: { line: lineIndex } } }); } } } /***/ }), /* 336 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * @author Titus Wormer * @copyright 2016 Titus Wormer * @license MIT * @module no-unused-definitions * @fileoverview * Warn when unused definitions are found. * * @example {"name": "valid.md"} * * [foo][] * * [foo]: https://example.com * * @example {"name": "invalid.md", "label": "input"} * * [bar]: https://example.com * * @example {"name": "invalid.md", "label": "output"} * * 1:1-1:27: Found unused definition */ var rule = __webpack_require__(0) var generated = __webpack_require__(2) var visit = __webpack_require__(1) module.exports = rule('remark-lint:no-unused-definitions', noUnusedDefinitions) var reason = 'Found unused definition' function noUnusedDefinitions(tree, file) { var map = {} var identifier var entry visit(tree, ['definition', 'footnoteDefinition'], find) visit(tree, ['imageReference', 'linkReference', 'footnoteReference'], mark) for (identifier in map) { entry = map[identifier] if (!entry.used) { file.message(reason, entry.node) } } function find(node) { if (!generated(node)) { map[node.identifier.toUpperCase()] = {node: node, used: false} } } function mark(node) { var info = map[node.identifier.toUpperCase()] if (!generated(node) && info) { info.used = true } } } /***/ }), /* 337 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * @author Titus Wormer * @copyright 2015 Titus Wormer * @license MIT * @module rule-style * @fileoverview * Warn when the horizontal rules violate a given or detected style. * * Options: `string`, either a valid markdown rule, or `'consistent'`, * default: `'consistent'`. * * `'consistent'` detects the first used rule style and warns when subsequent * rules use different styles. * * Note: horizontal rules are also called “thematic break”. * * ## Fix * * [`remark-stringify`](https://github.com/remarkjs/remark/tree/master/packages/remark-stringify) * has three settings that define how rules are created: * * * [`rule`](https://github.com/remarkjs/remark/tree/master/packages/remark-stringify#optionsrule) * (default: `*`) — Marker to use * * [`ruleRepetition`](https://github.com/remarkjs/remark/tree/master/packages/remark-stringify#optionsrulerepetition) * (default: `3`) — Number of markers to use * * [`ruleSpaces`](https://github.com/remarkjs/remark/tree/master/packages/remark-stringify#optionsrulespaces) * (default: `true`) — Whether to pad markers with spaces * * See [Using remark to fix your markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown) * on how to automatically fix warnings for this rule. * * @example {"name": "valid.md", "setting": "* * *"} * * * * * * * * * * * * @example {"name": "valid.md", "setting": "_______"} * * _______ * * _______ * * @example {"name": "invalid.md", "label": "input"} * * *** * * * * * * * @example {"name": "invalid.md", "label": "output"} * * 3:1-3:6: Rules should use `***` * * @example {"name": "invalid.md", "label": "output", "setting": "!!!", "config": {"positionless": true}} * * 1:1: Invalid preferred rule-style: provide a valid markdown rule, or `'consistent'` */ var rule = __webpack_require__(0) var visit = __webpack_require__(1) var position = __webpack_require__(3) var generated = __webpack_require__(2) module.exports = rule('remark-lint:rule-style', ruleStyle) var start = position.start var end = position.end function ruleStyle(tree, file, pref) { var contents = String(file) pref = typeof pref === 'string' && pref !== 'consistent' ? pref : null if (pref !== null && /[^-_* ]/.test(pref)) { file.fail( "Invalid preferred rule-style: provide a valid markdown rule, or `'consistent'`" ) } visit(tree, 'thematicBreak', visitor) function visitor(node) { var initial = start(node).offset var final = end(node).offset var rule if (!generated(node)) { rule = contents.slice(initial, final) if (pref) { if (rule !== pref) { file.message('Rules should use `' + pref + '`', node) } } else { pref = rule } } } } /***/ }), /* 338 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * @author Titus Wormer * @copyright 2015 Titus Wormer * @license MIT * @module table-pipes * @fileoverview * Warn when table rows are not fenced with pipes. * * ## Fix * * [`remark-stringify`](https://github.com/remarkjs/remark/tree/master/packages/remark-stringify) * creates fenced rows with initial and final pipes by default. Pass * [`looseTable: true`](https://github.com/remarkjs/remark/tree/master/packages/remark-stringify#optionsloosetable) * to not use row fences. * * See [Using remark to fix your markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown) * on how to automatically fix warnings for this rule. * * @example {"name": "valid.md"} * * | A | B | * | ----- | ----- | * | Alpha | Bravo | * * @example {"name": "invalid.md", "label": "input"} * * A | B * ----- | ----- * Alpha | Bravo * * @example {"name": "invalid.md", "label": "output"} * * 1:1: Missing initial pipe in table fence * 1:10: Missing final pipe in table fence * 3:1: Missing initial pipe in table fence * 3:14: Missing final pipe in table fence */ var rule = __webpack_require__(0) var visit = __webpack_require__(1) var position = __webpack_require__(3) var generated = __webpack_require__(2) module.exports = rule('remark-lint:table-pipes', tablePipes) var start = position.start var end = position.end var reasonStart = 'Missing initial pipe in table fence' var reasonEnd = 'Missing final pipe in table fence' function tablePipes(tree, file) { var contents = String(file) visit(tree, 'table', visitor) function visitor(node) { var rows = node.children var length = rows.length var index = -1 var row var cells var head var tail var initial var final while (++index < length) { row = rows[index] if (!generated(row)) { cells = row.children head = cells[0] tail = cells[cells.length - 1] initial = contents.slice(start(row).offset, start(head).offset) final = contents.slice(end(tail).offset, end(row).offset) if (initial.indexOf('|') === -1) { file.message(reasonStart, start(row)) } if (final.indexOf('|') === -1) { file.message(reasonEnd, end(row)) } } } } } /***/ }), /* 339 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * @author Titus Wormer * @copyright 2015 Titus Wormer * @license MIT * @module blockquote-indentation * @fileoverview * Warn when blockquotes are indented too much or too little. * * Options: `number` or `'consistent'`, default: `'consistent'`. * * `'consistent'` detects the first used indentation and will warn when * other blockquotes use a different indentation. * * @example {"name": "valid.md", "setting": 4} * * > Hello * * Paragraph. * * > World * * @example {"name": "valid.md", "setting": 2} * * > Hello * * Paragraph. * * > World * * @example {"name": "invalid.md", "label": "input"} * * > Hello * * Paragraph. * * > World * * Paragraph. * * > World * * @example {"name": "invalid.md", "label": "output"} * * 5:3: Remove 1 space between blockquote and content * 9:3: Add 1 space between blockquote and content */ var rule = __webpack_require__(0) var plural = __webpack_require__(31) var visit = __webpack_require__(1) var position = __webpack_require__(3) var generated = __webpack_require__(2) var toString = __webpack_require__(45) module.exports = rule( 'remark-lint:blockquote-indentation', blockquoteIndentation ) function blockquoteIndentation(tree, file, pref) { pref = typeof pref === 'number' && !isNaN(pref) ? pref : null visit(tree, 'blockquote', visitor) function visitor(node) { var diff var reason if (generated(node) || node.children.length === 0) { return } if (pref) { diff = pref - check(node) if (diff !== 0) { reason = (diff > 0 ? 'Add' : 'Remove') + ' ' + Math.abs(diff) + ' ' + plural('space', diff) + ' between blockquote and content' file.message(reason, position.start(node.children[0])) } } else { pref = check(node) } } } function check(node) { var head = node.children[0] var indentation = position.start(head).column - position.start(node).column var padding = toString(head).match(/^ +/) if (padding) { indentation += padding[0].length } return indentation } /***/ }), /* 340 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * @author Titus Wormer * @copyright 2015 Titus Wormer * @license MIT * @module checkbox-character-style * @fileoverview * Warn when list item checkboxes violate a given style. * * Options: `Object` or `'consistent'`, default: `'consistent'`. * * `'consistent'` detects the first used checked and unchecked checkbox * styles and warns when subsequent checkboxes use different styles. * * Styles can also be passed in like so: * * ```js * { checked: 'x', unchecked: ' ' } * ``` * * ## Fix * * [`remark-stringify`](https://github.com/remarkjs/remark/tree/master/packages/remark-stringify) * formats checked checkboxes using `x` and unchecked checkboxes as ` `. * * See [Using remark to fix your markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown) * on how to automatically fix warnings for this rule. * * @example {"name": "valid.md", "setting": {"checked": "x"}} * * - [x] List item * - [x] List item * * @example {"name": "valid.md", "setting": {"checked": "X"}} * * - [X] List item * - [X] List item * * @example {"name": "valid.md", "setting": {"unchecked": " "}} * * - [ ] List item * - [ ] List item * - [ ]·· * - [ ] * * @example {"name": "valid.md", "setting": {"unchecked": "\t"}} * * - [»] List item * - [»] List item * * @example {"name": "invalid.md", "label": "input"} * * - [x] List item * - [X] List item * - [ ] List item * - [»] List item * * @example {"name": "invalid.md", "label": "output"} * * 2:4-2:5: Checked checkboxes should use `x` as a marker * 4:4-4:5: Unchecked checkboxes should use ` ` as a marker * * @example {"setting": {"unchecked": "!"}, "name": "invalid.md", "label": "output", "config": {"positionless": true}} * * 1:1: Invalid unchecked checkbox marker `!`: use either `'\t'`, or `' '` * * @example {"setting": {"checked": "!"}, "name": "invalid.md", "label": "output", "config": {"positionless": true}} * * 1:1: Invalid checked checkbox marker `!`: use either `'x'`, or `'X'` */ var rule = __webpack_require__(0) var vfileLocation = __webpack_require__(19) var visit = __webpack_require__(1) var position = __webpack_require__(3) var generated = __webpack_require__(2) module.exports = rule( 'remark-lint:checkbox-character-style', checkboxCharacterStyle ) var start = position.start var end = position.end var checked = {x: true, X: true} var unchecked = {' ': true, '\t': true} var types = {true: 'checked', false: 'unchecked'} function checkboxCharacterStyle(tree, file, pref) { var contents = String(file) var location = vfileLocation(file) pref = typeof pref === 'object' ? pref : {} if (pref.unchecked && unchecked[pref.unchecked] !== true) { file.fail( 'Invalid unchecked checkbox marker `' + pref.unchecked + "`: use either `'\\t'`, or `' '`" ) } if (pref.checked && checked[pref.checked] !== true) { file.fail( 'Invalid checked checkbox marker `' + pref.checked + "`: use either `'x'`, or `'X'`" ) } visit(tree, 'listItem', visitor) function visitor(node) { var type var initial var final var value var style var character var reason /* Exit early for items without checkbox. */ if (typeof node.checked !== 'boolean' || generated(node)) { return } type = types[node.checked] initial = start(node).offset final = (node.children.length ? start(node.children[0]) : end(node)).offset /* For a checkbox to be parsed, it must be followed by a white space. */ value = contents .slice(initial, final) .trimRight() .slice(0, -1) /* The checkbox character is behind a square bracket. */ character = value.charAt(value.length - 1) style = pref[type] if (style) { if (character !== style) { reason = type.charAt(0).toUpperCase() + type.slice(1) + ' checkboxes should use `' + style + '` as a marker' file.message(reason, { start: location.toPosition(initial + value.length - 1), end: location.toPosition(initial + value.length) }) } } else { pref[type] = character } } } /***/ }), /* 341 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * @author Titus Wormer * @copyright 2015 Titus Wormer * @license MIT * @module code-block-style * @fileoverview * Warn when code-blocks do not adhere to a given style. * * Options: `'consistent'`, `'fenced'`, or `'indented'`, default: `'consistent'`. * * `'consistent'` detects the first used code-block style and warns when * subsequent code-blocks uses different styles. * * ## Fix * * [`remark-stringify`](https://github.com/remarkjs/remark/tree/master/packages/remark-stringify) * formats code blocks using a fence if they have a language flag and * indentation if not. Pass * [`fences: true`](https://github.com/remarkjs/remark/tree/master/packages/remark-stringify#optionsfences) * to always use fences for code blocks. * * See [Using remark to fix your markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown) * on how to automatically fix warnings for this rule. * * @example {"setting": "indented", "name": "valid.md"} * * alpha(); * * Paragraph. * * bravo(); * * @example {"setting": "indented", "name": "invalid.md", "label": "input"} * * ``` * alpha(); * ``` * * Paragraph. * * ``` * bravo(); * ``` * * @example {"setting": "indented", "name": "invalid.md", "label": "output"} * * 1:1-3:4: Code blocks should be indented * 7:1-9:4: Code blocks should be indented * * @example {"setting": "fenced", "name": "valid.md"} * * ``` * alpha(); * ``` * * Paragraph. * * ``` * bravo(); * ``` * * @example {"setting": "fenced", "name": "invalid.md", "label": "input"} * * alpha(); * * Paragraph. * * bravo(); * * @example {"setting": "fenced", "name": "invalid.md", "label": "output"} * * 1:1-1:13: Code blocks should be fenced * 5:1-5:13: Code blocks should be fenced * * @example {"name": "invalid.md", "label": "input"} * * alpha(); * * Paragraph. * * ``` * bravo(); * ``` * * @example {"name": "invalid.md", "label": "output"} * * 5:1-7:4: Code blocks should be indented * * @example {"setting": "invalid", "name": "invalid.md", "label": "output", "config": {"positionless": true}} * * 1:1: Invalid code block style `invalid`: use either `'consistent'`, `'fenced'`, or `'indented'` */ var rule = __webpack_require__(0) var visit = __webpack_require__(1) var position = __webpack_require__(3) var generated = __webpack_require__(2) module.exports = rule('remark-lint:code-block-style', codeBlockStyle) var start = position.start var end = position.end var styles = {null: true, fenced: true, indented: true} function codeBlockStyle(tree, file, pref) { var contents = String(file) pref = typeof pref === 'string' && pref !== 'consistent' ? pref : null if (styles[pref] !== true) { file.fail( 'Invalid code block style `' + pref + "`: use either `'consistent'`, `'fenced'`, or `'indented'`" ) } visit(tree, 'code', visitor) function visitor(node) { var current = check(node) if (current) { if (!pref) { pref = current } else if (pref !== current) { file.message('Code blocks should be ' + pref, node) } } } /* Get the style of `node`. */ function check(node) { var initial = start(node).offset var final = end(node).offset if (generated(node)) { return null } return node.lang || /^\s*([~`])\1{2,}/.test(contents.slice(initial, final)) ? 'fenced' : 'indented' } } /***/ }), /* 342 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * @author Titus Wormer * @copyright 2015 Titus Wormer * @license MIT * @module fenced-code-marker * @fileoverview * Warn for violating fenced code markers. * * Options: `` '`' ``, `'~'`, or `'consistent'`, default: `'consistent'`. * * `'consistent'` detects the first used fenced code marker style and warns * when subsequent fenced code-blocks use different styles. * * ## Fix * * [`remark-stringify`](https://github.com/remarkjs/remark/tree/master/packages/remark-stringify) * formats fences using a backtick (`` '`' ``) by default. Pass * [`fence: '~'`](https://github.com/remarkjs/remark/tree/master/packages/remark-stringify#optionsfence) * to use tildes instead. * * See [Using remark to fix your markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown) * on how to automatically fix warnings for this rule. * * @example {"name": "valid.md"} * * Indented code blocks are not affected by this rule: * * bravo(); * * @example {"name": "valid.md", "setting": "`"} * * ```alpha * bravo(); * ``` * * ``` * charlie(); * ``` * * @example {"name": "valid.md", "setting": "~"} * * ~~~alpha * bravo(); * ~~~ * * ~~~ * charlie(); * ~~~ * * @example {"name": "invalid.md", "label": "input"} * * ```alpha * bravo(); * ``` * * ~~~ * charlie(); * ~~~ * * @example {"name": "invalid.md", "label": "output"} * * 5:1-7:4: Fenced code should use ` as a marker * * @example {"name": "invalid.md", "setting": "!", "label": "output", "config": {"positionless": true}} * * 1:1: Invalid fenced code marker `!`: use either `'consistent'`, `` '`' ``, or `'~'` */ var rule = __webpack_require__(0) var visit = __webpack_require__(1) var position = __webpack_require__(3) var generated = __webpack_require__(2) module.exports = rule('remark-lint:fenced-code-marker', fencedCodeMarker) var markers = { '`': true, '~': true, null: true } function fencedCodeMarker(tree, file, pref) { var contents = String(file) pref = typeof pref === 'string' && pref !== 'consistent' ? pref : null if (markers[pref] !== true) { file.fail( 'Invalid fenced code marker `' + pref + "`: use either `'consistent'`, `` '`' ``, or `'~'`" ) } visit(tree, 'code', visitor) function visitor(node) { var marker if (!generated(node)) { marker = contents .substr(position.start(node).offset, 4) .trimLeft() .charAt(0) /* Ignore unfenced code blocks. */ if (markers[marker] === true) { if (pref) { if (marker !== pref) { file.message( 'Fenced code should use ' + pref + ' as a marker', node ) } } else { pref = marker } } } } } /***/ }), /* 343 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * @author Titus Wormer * @copyright 2015 Titus Wormer * @license MIT * @module file-extension * @fileoverview * Warn when the file extension differ from the preferred extension. * * Does not warn when given documents have no file extensions (such as * `AUTHORS` or `LICENSE`). * * Options: `string`, default: `'md'` — Expected file extension. * * @example {"name": "readme.md"} * * @example {"name": "readme"} * * @example {"name": "readme.mkd", "label": "output", "config": {"positionless": true}} * * 1:1: Invalid extension: use `md` * * @example {"name": "readme.mkd", "setting": "mkd"} */ var rule = __webpack_require__(0) module.exports = rule('remark-lint:file-extension', fileExtension) function fileExtension(tree, file, pref) { var ext = file.extname pref = typeof pref === 'string' ? pref : 'md' if (ext && ext.slice(1) !== pref) { file.message('Invalid extension: use `' + pref + '`') } } /***/ }), /* 344 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * @author Titus Wormer * @copyright 2015 Titus Wormer * @license MIT * @module first-heading-level * @fileoverview * Warn when the first heading has a level other than a specified value. * * Options: `number`, default: `1`. * * @example {"name": "valid.md"} * * # The default is to expect a level one heading * * @example {"name": "valid-html.md"} * *

An HTML heading is also seen by this rule.

* * @example {"name": "valid-delayed.md"} * * You can use markdown content before the heading. * *
Or non-heading HTML
* *

So the first heading, be it HTML or markdown, is checked

* * @example {"name": "invalid.md", "label": "input"} * * ## Bravo * * Paragraph. * * @example {"name": "invalid.md", "label": "output"} * * 1:1-1:9: First heading level should be `1` * * @example {"name": "invalid-html.md", "label": "input"} * *

Charlie

* * Paragraph. * * @example {"name": "invalid-html.md", "label": "output"} * * 1:1-1:17: First heading level should be `1` * * @example {"name": "valid.md", "setting": 2} * * ## Delta * * Paragraph. * * @example {"name": "valid-html.md", "setting": 2} * *

Echo

* * Paragraph. * * @example {"name": "invalid.md", "setting": 2, "label": "input"} * * # Foxtrot * * Paragraph. * * @example {"name": "invalid.md", "setting": 2, "label": "output"} * * 1:1-1:10: First heading level should be `2` * * @example {"name": "invalid-html.md", "setting": 2, "label": "input"} * *

Golf

* * Paragraph. * * @example {"name": "invalid-html.md", "setting": 2, "label": "output"} * * 1:1-1:14: First heading level should be `2` */ var rule = __webpack_require__(0) var visit = __webpack_require__(1) var generated = __webpack_require__(2) module.exports = rule('remark-lint:first-heading-level', firstHeadingLevel) var re = / { if (testProhibited(val, content)) { file.message(`Use "${val.yes}" instead of "${val.no}"`, node); } }); } } /***/ }), /* 347 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * @author Titus Wormer * @copyright 2015 Titus Wormer * @license MIT * @module strong-marker * @fileoverview * Warn for violating strong markers. * * Options: `'consistent'`, `'*'`, or `'_'`, default: `'consistent'`. * * `'consistent'` detects the first used strong style and warns when subsequent * strongs use different styles. * * Note: strong is also called “importance”. * * ## Fix * * [`remark-stringify`](https://github.com/remarkjs/remark/tree/master/packages/remark-stringify) * formats importance using an asterisk (`*`) by default. Pass * [`strong: '_'`](https://github.com/remarkjs/remark/tree/master/packages/remark-stringify#optionsstrong) * to use underscores instead. * * See [Using remark to fix your markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown) * on how to automatically fix warnings for this rule. * * @example {"name": "valid.md"} * * **foo** and **bar**. * * @example {"name": "also-valid.md"} * * __foo__ and __bar__. * * @example {"name": "valid.md", "setting": "*"} * * **foo**. * * @example {"name": "valid.md", "setting": "_"} * * __foo__. * * @example {"name": "invalid.md", "label": "input"} * * **foo** and __bar__. * * @example {"name": "invalid.md", "label": "output"} * * 1:13-1:20: Strong should use `*` as a marker * * @example {"name": "invalid.md", "label": "output", "setting": "!", "config": {"positionless": true}} * * 1:1: Invalid strong marker `!`: use either `'consistent'`, `'*'`, or `'_'` */ var rule = __webpack_require__(0) var visit = __webpack_require__(1) var position = __webpack_require__(3) var generated = __webpack_require__(2) module.exports = rule('remark-lint:strong-marker', strongMarker) var markers = {'*': true, _: true, null: true} function strongMarker(tree, file, pref) { var contents = String(file) pref = typeof pref === 'string' && pref !== 'consistent' ? pref : null if (markers[pref] !== true) { file.fail( 'Invalid strong marker `' + pref + "`: use either `'consistent'`, `'*'`, or `'_'`" ) } visit(tree, 'strong', visitor) function visitor(node) { var marker = contents.charAt(position.start(node).offset) if (!generated(node)) { if (pref) { if (marker !== pref) { file.message('Strong should use `' + pref + '` as a marker', node) } } else { pref = marker } } } } /***/ }), /* 348 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; /** * @author Titus Wormer * @copyright 2015 Titus Wormer * @license MIT * @module table-cell-padding * @fileoverview * Warn when table cells are incorrectly padded. * * Options: `'consistent'`, `'padded'`, or `'compact'`, default: `'consistent'`. * * `'consistent'` detects the first used cell padding style and warns when * subsequent cells use different styles. * * ## Fix * * [`remark-stringify`](https://github.com/remarkjs/remark/tree/master/packages/remark-stringify) * formats tables with padding by default. Pass * [`spacedTable: false`](https://github.com/remarkjs/remark/tree/master/packages/remark-stringify#optionsspacedtable) * to not use padding. * * See [Using remark to fix your markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown) * on how to automatically fix warnings for this rule. * * @example {"name": "valid.md", "setting": "padded"} * * | A | B | * | ----- | ----- | * | Alpha | Bravo | * * @example {"name": "invalid.md", "label": "input", "setting": "padded"} * * | A | B | * | :----|----: | * | Alpha|Bravo | * * | C | D | * | :----- | ---: | * |Charlie | Delta| * * Too much padding isn’t good either: * * | E | F | G | H | * | :---- | -------- | :----: | -----: | * | Echo | Foxtrot | Golf | Hotel | * * @example {"name": "invalid.md", "label": "output", "setting": "padded"} * * 3:8: Cell should be padded * 3:9: Cell should be padded * 7:2: Cell should be padded * 7:17: Cell should be padded * 13:23: Cell should be padded with 1 space, not 2 * 13:32: Cell should be padded with 1 space, not 2 * * @example {"name": "valid.md", "setting": "compact"} * * |A |B | * |-----|-----| * |Alpha|Bravo| * * @example {"name": "invalid.md", "label": "input", "setting": "compact"} * * | A | B | * | -----| -----| * | Alpha| Bravo| * * |C | D| * |:------|-----:| * |Charlie|Delta | * * @example {"name": "invalid.md", "label": "output", "setting": "compact"} * * 3:5: Cell should be compact * 3:12: Cell should be compact * 7:15: Cell should be compact * * @example {"name": "valid-padded.md", "setting": "consistent"} * * | A | B | * | ----- | ----- | * | Alpha | Bravo | * * | C | D | * | ------- | ----- | * | Charlie | Delta | * * @example {"name": "invalid-padded.md", "label": "input", "setting": "consistent"} * * | A | B | * | ----- | ----- | * | Alpha | Bravo | * * | C | D | * | :----- | ----: | * |Charlie | Delta | * * @example {"name": "invalid-padded.md", "label": "output", "setting": "consistent"} * * 7:2: Cell should be padded * * @example {"name": "valid-compact.md", "setting": "consistent"} * * |A |B | * |-----|-----| * |Alpha|Bravo| * * |C |D | * |-------|-----| * |Charlie|Delta| * * @example {"name": "invalid-compact.md", "label": "input", "setting": "consistent"} * * |A |B | * |-----|-----| * |Alpha|Bravo| * * |C | D| * |:------|-----:| * |Charlie|Delta | * * @example {"name": "invalid-compact.md", "label": "output", "setting": "consistent"} * * 7:15: Cell should be compact * * @example {"name": "invalid.md", "label": "output", "setting": "invalid", "config": {"positionless": true}} * * 1:1: Invalid table-cell-padding style `invalid` * * @example {"name": "empty.md", "label": "input", "setting": "padded"} * * * * | | Alpha | Bravo| * | ------ | ----- | ---: | * | Charlie| | Echo| * * @example {"name": "empty.md", "label": "output", "setting": "padded"} * * 3:25: Cell should be padded * 5:10: Cell should be padded * 5:25: Cell should be padded * * @example {"name": "missing-body.md", "setting": "padded"} * * * * | Alpha | Bravo | Charlie | * | ----- | -------- | ------- | * | Delta | * | Echo | Foxtrott | */ var rule = __webpack_require__(0) var visit = __webpack_require__(1) var position = __webpack_require__(3) var generated = __webpack_require__(2) module.exports = rule('remark-lint:table-cell-padding', tableCellPadding) var start = position.start var end = position.end var styles = {null: true, padded: true, compact: true} function tableCellPadding(tree, file, pref) { var contents = String(file) pref = typeof pref === 'string' && pref !== 'consistent' ? pref : null if (styles[pref] !== true) { file.fail('Invalid table-cell-padding style `' + pref + '`') } visit(tree, 'table', visitor) function visitor(node) { var rows = node.children var sizes = new Array(node.align.length) var length = generated(node) ? -1 : rows.length var index = -1 var entries = [] var style var row var cells var column var cellCount var cell var next var fence var pos var entry var final /* Check rows. */ while (++index < length) { row = rows[index] cells = row.children cellCount = cells.length column = -2 /* Start without a first cell */ next = null final = undefined /* Check fences (before, between, and after cells) */ while (++column < cellCount) { cell = next next = cells[column + 1] fence = contents.slice( cell ? end(cell).offset : start(row).offset, next ? start(next).offset : end(row).offset ) pos = fence.indexOf('|') if (cell && cell.children.length !== 0 && final !== undefined) { entries.push({node: cell, start: final, end: pos, index: column}) /* Detect max space per column. */ sizes[column] = Math.max(sizes[column] || 0, size(cell)) } else { final = undefined } if (next && next.children.length !== 0) { final = fence.length - pos - 1 } else { final = undefined } } } if (pref) { style = pref === 'padded' ? 1 : 0 } else { style = entries[0] && (!entries[0].start || !entries[0].end) ? 0 : 1 } index = -1 length = entries.length while (++index < length) { entry = entries[index] checkSide('start', entry, style, sizes) checkSide('end', entry, style, sizes) } return visit.SKIP } function checkSide(side, entry, style, sizes) { var cell = entry.node var spacing = entry[side] var index = entry.index var reason if (spacing === undefined || spacing === style) { return } reason = 'Cell should be ' if (style === 0) { reason += 'compact' /* Ignore every cell except the biggest in the column. */ if (size(cell) < sizes[index]) { return } } else { reason += 'padded' if (spacing > style) { reason += ' with 1 space, not ' + spacing /* May be right or center aligned. */ if (size(cell) < sizes[index]) { return } } } file.message(reason, cell.position[side]) } } function size(node) { return end(node).offset - start(node).offset } /***/ }) /******/ ]); //# sourceMappingURL=index.js.map