summaryrefslogtreecommitdiff
path: root/tools/lint-md.js
diff options
context:
space:
mode:
authorRich Trott <rtrott@gmail.com>2018-12-03 11:58:59 -0800
committerRich Trott <rtrott@gmail.com>2018-12-05 14:02:17 -0800
commit630fed8f072b3a54e81b186155b883580d1a0c3e (patch)
treec724aa21df9e8b9a62fa9dc70d7e3cb8381586a0 /tools/lint-md.js
parent76afdffdf4aed0ce944867d32545505d25b77118 (diff)
downloadandroid-node-v8-630fed8f072b3a54e81b186155b883580d1a0c3e.tar.gz
android-node-v8-630fed8f072b3a54e81b186155b883580d1a0c3e.tar.bz2
android-node-v8-630fed8f072b3a54e81b186155b883580d1a0c3e.zip
tools: replace rollup with ncc
Replace rollup + plugins + config file with zeit/ncc package designed to do the particular task that we're leveraging rollup for but with zero-ish configuration. (rollup can do a whole lot more, but we're using a tiny portion of its functionality.) PR-URL: https://github.com/nodejs/node/pull/24813 Reviewed-By: Guy Bedford <guybedford@gmail.com> Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Diffstat (limited to 'tools/lint-md.js')
-rw-r--r--tools/lint-md.js47365
1 files changed, 26571 insertions, 20794 deletions
diff --git a/tools/lint-md.js b/tools/lint-md.js
index 03d12efbd2..ab0eea8a3f 100644
--- a/tools/lint-md.js
+++ b/tools/lint-md.js
@@ -1,214 +1,633 @@
-'use strict';
+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)
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+ /* istanbul ignore if - possibly useful if externalised later. */
+ if (!ruleId) {
+ ruleId = source
+ source = null
+ }
-var util = _interopDefault(require('util'));
-var os = _interopDefault(require('os'));
-var tty = _interopDefault(require('tty'));
-var path = _interopDefault(require('path'));
-var module$1 = _interopDefault(require('module'));
-var fs = _interopDefault(require('fs'));
-var assert = _interopDefault(require('assert'));
-var events = _interopDefault(require('events'));
-var stream = _interopDefault(require('stream'));
+ attacher.displayName = id
-var vfileStatistics = statistics;
+ return attacher
-/* Get stats for a file, list of files, or list of messages. */
-function statistics(files) {
- var result = {true: 0, false: 0, null: 0};
+ function attacher(raw) {
+ var config = coerce(ruleId, raw)
+ var severity = config[0]
+ var options = config[1]
+ var fatal = severity === 2
- count(files);
+ return severity ? transformer : undefined
- return {
- fatal: result.true,
- nonfatal: result.false + result.null,
- warn: result.false,
- info: result.null,
- total: result.true + result.false + result.null
- }
+ function transformer(tree, file, next) {
+ var index = file.messages.length
- function count(value) {
- if (value) {
- if (value[0] && value[0].messages) {
- /* Multiple vfiles */
- countInAll(value);
- } else {
- /* One vfile / messages */
- countAll(value.messages || value);
+ 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()
}
}
}
+}
- function countInAll(files) {
- var length = files.length;
- var index = -1;
+/* Coerce a value to a severity--options tuple. */
+function coerce(name, value) {
+ var def = 1
+ var result
+ var level
- while (++index < length) {
- count(files[index].messages);
- }
+ /* 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]
}
- function countAll(messages) {
- var length = messages.length;
- var index = -1;
- var fatal;
+ level = result[0]
- while (++index < length) {
- fatal = messages[index].fatal;
- result[fatal === null || fatal === undefined ? null : Boolean(fatal)]++;
+ 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
}
-var slice = [].slice;
-var wrap_1 = wrap;
+/***/ }),
+/* 1 */
+/***/ (function(module, exports, __webpack_require__) {
-/* 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;
+"use strict";
- return wrapped
- function wrapped() {
- var params = slice.call(arguments, 0);
- var callback = fn.length > params.length;
- var result;
+module.exports = visit
- if (callback) {
- params.push(done);
- }
+var visitParents = __webpack_require__(221)
- 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
- }
+var CONTINUE = visitParents.CONTINUE
+var SKIP = visitParents.SKIP
+var EXIT = visitParents.EXIT
- return done(err)
- }
+visit.CONTINUE = CONTINUE
+visit.SKIP = SKIP
+visit.EXIT = EXIT
- if (!callback) {
- if (result && typeof result.then === 'function') {
- result.then(then, done);
- } else if (result instanceof Error) {
- done(result);
- } else {
- then(result);
- }
- }
+function visit(tree, test, visitor, reverse) {
+ if (typeof test === 'function' && typeof visitor !== 'function') {
+ reverse = visitor
+ visitor = test
+ test = null
}
- /* Invoke `next`, only once. */
- function done() {
- if (!invoked) {
- invoked = true;
+ visitParents(tree, test, overload, reverse)
- callback.apply(null, arguments);
- }
+ function overload(node, parents) {
+ var parent = parents[parents.length - 1]
+ var index = parent ? parent.children.indexOf(node) : null
+ return visitor(node, index, parent)
}
+}
- /* Invoke `done` with one value.
- * Tracks if an error is passed, too. */
- function then(value) {
- done(null, value);
+
+/***/ }),
+/* 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
+ }
}
}
-var trough_1 = trough;
-trough.wrap = wrap_1;
+/***/ }),
+/* 4 */
+/***/ (function(module, exports) {
-var slice$1 = [].slice;
+module.exports = require("path");
-/* Create new middleware. */
-function trough() {
- var fns = [];
- var middleware = {};
+/***/ }),
+/* 5 */
+/***/ (function(module, exports, __webpack_require__) {
- middleware.run = run;
- middleware.use = use;
+"use strict";
- return middleware
- /* Run `fns`. Last argument must be
- * a completion handler. */
- function run() {
- var index = -1;
- var input = slice$1.call(arguments, 0, -1);
- var done = arguments[arguments.length - 1];
+var YAMLException = __webpack_require__(20);
- if (typeof done !== 'function') {
- throw new Error('Expected function as last argument, not ' + done)
+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);
- next.apply(null, [null].concat(input));
+ if (YAML_NODE_KINDS.indexOf(this.kind) === -1) {
+ throw new YAMLException('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.');
+ }
+}
- /* Run the next `fn`, if any. */
- function next(err) {
- var fn = fns[++index];
- var params = slice$1.call(arguments, 0);
- var values = params.slice(1);
- var length = input.length;
- var pos = -1;
+module.exports = Type;
- 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];
+/***/ }),
+/* 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]
+ }
}
- }
+ }
- input = values;
+ return target
+}
- /* Next or done. */
- if (fn) {
- wrap_1(fn, next).apply(null, input);
+
+/***/ }),
+/* 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 <https://github.com/jonschlinkert/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 {
- done.apply(null, [null].concat(input));
+ /* One vfile / messages */
+ countAll(value.messages || value)
}
}
}
- /* Add `fn` to the list. */
- function use(fn) {
- if (typeof fn !== 'function') {
- throw new Error('Expected `fn` to be a function, not ' + fn)
+ function countInAll(files) {
+ var length = files.length
+ var index = -1
+
+ while (++index < length) {
+ count(files[index].messages)
}
+ }
- fns.push(fn);
+ function countAll(messages) {
+ var length = messages.length
+ var index = -1
+ var fatal
- return middleware
+ while (++index < length) {
+ fatal = messages[index].fatal
+ result[fatal === null || fatal === undefined ? null : Boolean(fatal)]++
+ }
}
}
-function commonjsRequire () {
- throw new Error('Dynamic requires are not currently supported by rollup-plugin-commonjs');
-}
-function unwrapExports (x) {
- return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+/***/ }),
+/* 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);
}
-function createCommonjsModule(fn, module) {
- return module = { exports: {} }, fn(module, module.exports), module.exports;
+
+/***/ }),
+/* 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);
}
@@ -259,24 +678,372 @@ function isNegativeZero(number) {
}
-var isNothing_1 = isNothing;
-var isObject_1 = isObject;
-var toArray_1 = toArray;
-var repeat_1 = repeat;
-var isNegativeZero_1 = isNegativeZero;
-var extend_1 = extend;
+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.
+
+
+
+/*<replacement>*/
+
+var pna = __webpack_require__(28);
+/*</replacement>*/
+
+/*<replacement>*/
+var objectKeys = Object.keys || function (obj) {
+ var keys = [];
+ for (var key in obj) {
+ keys.push(key);
+ }return keys;
+};
+/*</replacement>*/
+
+module.exports = Duplex;
+
+/*<replacement>*/
+var util = __webpack_require__(22);
+util.inherits = __webpack_require__(13);
+/*</replacement>*/
+
+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();
-var common = {
- isNothing: isNothing_1,
- isObject: isObject_1,
- toArray: toArray_1,
- repeat: repeat_1,
- isNegativeZero: isNegativeZero_1,
- extend: extend_1
+ 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);
@@ -315,1187 +1082,8331 @@ YAMLException.prototype.toString = function toString(compact) {
};
-var exception = YAMLException;
+module.exports = YAMLException;
-function Mark(name, buffer, position, line, column) {
- this.name = name;
- this.buffer = buffer;
- this.position = position;
- this.line = line;
- this.column = column;
+
+/***/ }),
+/* 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;
-Mark.prototype.getSnippet = function getSnippet(indent, maxLength) {
- var head, start, tail, end, snippet;
+function isNull(arg) {
+ return arg === null;
+}
+exports.isNull = isNull;
- if (!this.buffer) return null;
+function isNullOrUndefined(arg) {
+ return arg == null;
+}
+exports.isNullOrUndefined = isNullOrUndefined;
- indent = indent || 4;
- maxLength = maxLength || 75;
+function isNumber(arg) {
+ return typeof arg === 'number';
+}
+exports.isNumber = isNumber;
- head = '';
- start = this.position;
+function isString(arg) {
+ return typeof arg === 'string';
+}
+exports.isString = isString;
- 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;
+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)
}
- }
- tail = '';
- end = this.position;
+ next.apply(null, [null].concat(input))
- 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;
+ /* 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))
+ }
}
}
- snippet = this.buffer.slice(start, end);
+ /* Add `fn` to the list. */
+ function use(fn) {
+ if (typeof fn !== 'function') {
+ throw new Error('Expected `fn` to be a function, not ' + fn)
+ }
- return common.repeat(' ', indent) + head + snippet + tail + '\n' +
- common.repeat(' ', indent + this.position - start + head.length) + '^';
-};
+ fns.push(fn)
+
+ return middleware
+ }
+}
-Mark.prototype.toString = function toString(compact) {
- var snippet, where = '';
+/***/ }),
+/* 25 */
+/***/ (function(module, exports, __webpack_require__) {
- if (this.name) {
- where += 'in "' + this.name + '" ';
+"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
}
- where += 'at line ' + (this.line + 1) + ', column ' + (this.column + 1);
+ /* Node. */
+ if (own.call(value, 'position') || own.call(value, 'type')) {
+ return position(value.position)
+ }
- if (!compact) {
- snippet = this.getSnippet();
+ /* Position. */
+ if (own.call(value, 'start') || own.call(value, 'end')) {
+ return position(value)
+ }
- if (snippet) {
- where += ':\n' + snippet;
- }
+ /* Point. */
+ if (own.call(value, 'line') || own.call(value, 'column')) {
+ return point(value)
}
- return where;
-};
+ /* ? */
+ return null
+}
+function point(point) {
+ if (!point || typeof point !== 'object') {
+ point = {}
+ }
-var mark = Mark;
+ return index(point.line) + ':' + index(point.column)
+}
-var TYPE_CONSTRUCTOR_OPTIONS = [
- 'kind',
- 'resolve',
- 'construct',
- 'instanceOf',
- 'predicate',
- 'represent',
- 'defaultStyle',
- 'styleAliases'
-];
+function position(pos) {
+ if (!pos || typeof pos !== 'object') {
+ pos = {}
+ }
-var YAML_NODE_KINDS = [
- 'scalar',
- 'sequence',
- 'mapping'
-];
+ return point(pos.start) + '-' + point(pos.end)
+}
-function compileStyleAliases(map) {
- var result = {};
+function index(value) {
+ return value && typeof value === 'number' ? value : 1
+}
- if (map !== null) {
- Object.keys(map).forEach(function (style) {
- map[style].forEach(function (alias) {
- result[String(alias)] = style;
- });
+
+/***/ }),
+/* 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
+}
- return result;
+function SafeBuffer (arg, encodingOrOffset, length) {
+ return Buffer(arg, encodingOrOffset, length)
}
-function Type(tag, options) {
- options = options || {};
+// Copy static methods from Buffer
+copyProps(Buffer, SafeBuffer)
- Object.keys(options).forEach(function (name) {
- if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) {
- throw new exception('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.');
+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
+}
- // 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);
+SafeBuffer.allocUnsafe = function (size) {
+ if (typeof size !== 'number') {
+ throw new TypeError('Argument must be a number')
+ }
+ return Buffer(size)
+}
- if (YAML_NODE_KINDS.indexOf(this.kind) === -1) {
- throw new exception('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.');
+SafeBuffer.allocUnsafeSlow = function (size) {
+ if (typeof size !== 'number') {
+ throw new TypeError('Argument must be a number')
}
+ return buffer.SlowBuffer(size)
}
-var type = Type;
-/*eslint-disable max-len*/
+/***/ }),
+/* 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
-function compileList(schema, name, result) {
- var exclude = [];
+/* Default settings. */
+var defaults = {
+ warning: null,
+ reference: null,
+ text: null,
+ warningContext: null,
+ referenceContext: null,
+ textContext: null,
+ position: {},
+ additional: null,
+ attribute: false,
+ nonTerminated: true
+}
- schema.include.forEach(function (includedSchema) {
- result = compileList(includedSchema, name, result);
- });
+/* Reference types. */
+var NAMED = 'named'
+var HEXADECIMAL = 'hexadecimal'
+var DECIMAL = 'decimal'
- schema[name].forEach(function (currentType) {
- result.forEach(function (previousType, previousIndex) {
- if (previousType.tag === currentType.tag && previousType.kind === currentType.kind) {
- exclude.push(previousIndex);
- }
- });
+/* Map of bases. */
+var BASE = {}
- result.push(currentType);
- });
+BASE[HEXADECIMAL] = 16
+BASE[DECIMAL] = 10
- return result.filter(function (type$$1, index) {
- return exclude.indexOf(index) === -1;
- });
-}
+/* 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
-function compileMap(/* lists... */) {
- var result = {
- scalar: {},
- sequence: {},
- mapping: {},
- fallback: {}
- }, index, length;
+/* 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
- function collectType(type$$1) {
- result[type$$1.kind][type$$1.tag] = result['fallback'][type$$1.tag] = type$$1;
+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 (index = 0, length = arguments.length; index < length; index += 1) {
- arguments[index].forEach(collectType);
+ for (key in defaults) {
+ option = options[key]
+ settings[key] =
+ option === null || option === undefined ? defaults[key] : option
}
- return result;
+
+ 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
-function Schema(definition) {
- this.include = definition.include || [];
- this.implicit = definition.implicit || [];
- this.explicit = definition.explicit || [];
+ /* 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++
- this.implicit.forEach(function (type$$1) {
- if (type$$1.loadKind && type$$1.loadKind !== 'scalar') {
- throw new exception('There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.');
+ while (++index < length) {
+ /* If the previous character was a newline. */
+ if (character === '\n') {
+ column = indent[lines] || 1
}
- });
- this.compiledImplicit = compileList(this, 'implicit', []);
- this.compiledExplicit = compileList(this, 'explicit', []);
- this.compiledTypeMap = compileMap(this.compiledImplicit, this.compiledExplicit);
-}
+ character = at(index)
+ /* Handle anything other than an ampersand,
+ * including newlines and EOF. */
+ if (character !== '&') {
+ if (character === '\n') {
+ line++
+ lines++
+ column = 0
+ }
-Schema.DEFAULT = null;
+ 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++
-Schema.create = function createSchema() {
- var schemas, types;
+ continue
+ }
- switch (arguments.length) {
- case 1:
- schemas = Schema.DEFAULT;
- types = arguments[0];
- break;
+ start = index + 1
+ begin = start
+ end = start
- case 2:
- schemas = arguments[0];
- types = arguments[1];
- break;
+ /* Numerical entity. */
+ if (following !== '#') {
+ type = NAMED
+ } else {
+ end = ++begin
- default:
- throw new exception('Wrong number of arguments for Schema.create function');
+ /* 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
+ }
+ }
}
- schemas = common.toArray(schemas);
- types = common.toArray(types);
+ /* Return the reduced nodes, and any possible warnings. */
+ return result.join('')
- if (!schemas.every(function (schema) { return schema instanceof Schema; })) {
- throw new exception('Specified list of super schemas (or a single Schema object) contains a non-Schema object.');
+ /* Get current position. */
+ function now() {
+ return {
+ line: line,
+ column: column,
+ offset: index + (pos.offset || 0)
+ }
}
- if (!types.every(function (type$$1) { return type$$1 instanceof type; })) {
- throw new exception('Specified list of YAML types (or a single Type object) contains a non-Type object.');
+ /* “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)
}
- return new Schema({
- include: schemas,
- explicit: types
- });
+ /* 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;
};
-var schema = Schema;
+/***/ }),
+/* 32 */
+/***/ (function(module, exports) {
-var str = new type('tag:yaml.org,2002:str', {
- kind: 'scalar',
- construct: function (data) { return data !== null ? data : ''; }
-});
+module.exports = require("stream");
-var seq = new type('tag:yaml.org,2002:seq', {
- kind: 'sequence',
- construct: function (data) { return data !== null ? data : []; }
-});
+/***/ }),
+/* 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);
-var map = new type('tag:yaml.org,2002:map', {
- kind: 'mapping',
- construct: function (data) { return data !== null ? data : {}; }
-});
-var failsafe = new schema({
+module.exports = new Schema({
explicit: [
- str,
- seq,
- map
+ __webpack_require__(105),
+ __webpack_require__(106),
+ __webpack_require__(107)
]
});
-function resolveYamlNull(data) {
- if (data === null) return true;
- var max = data.length;
+/***/ }),
+/* 34 */
+/***/ (function(module, exports, __webpack_require__) {
- return (max === 1 && data === '~') ||
- (max === 4 && (data === 'null' || data === 'Null' || data === 'NULL'));
-}
+"use strict";
-function constructYamlNull() {
- return null;
+
+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)
+ }
}
-function isNull(object) {
- return object === null;
+
+/***/ }),
+/* 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: ')' }
}
-var _null = 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'
-});
+// any single thing other than /
+// don't need to escape / when using new RegExp()
+var qmark = '[^/]'
-function resolveYamlBoolean(data) {
- if (data === null) return false;
+// * => any number of characters
+var star = qmark + '*?'
- var max = data.length;
+// ** 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})($|\\\/)).)*?'
- return (max === 4 && (data === 'true' || data === 'True' || data === 'TRUE')) ||
- (max === 5 && (data === 'false' || data === 'False' || data === 'FALSE'));
+// 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
+ }, {})
}
-function constructYamlBoolean(data) {
- return data === 'true' ||
- data === 'True' ||
- data === 'TRUE';
+// normalizes slashes.
+var slashSplit = /\/+/
+
+minimatch.filter = filter
+function filter (pattern, options) {
+ options = options || {}
+ return function (p, i, list) {
+ return minimatch(p, pattern, options)
+ }
}
-function isBoolean(object) {
- return Object.prototype.toString.call(object) === '[object Boolean]';
+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
}
-var bool = 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'
-});
+minimatch.defaults = function (def) {
+ if (!def || !Object.keys(def).length) return minimatch
-function isHexCode(c) {
- return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) ||
- ((0x41/* A */ <= c) && (c <= 0x46/* F */)) ||
- ((0x61/* a */ <= c) && (c <= 0x66/* f */));
+ 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
}
-function isOctCode(c) {
- return ((0x30/* 0 */ <= c) && (c <= 0x37/* 7 */));
+Minimatch.defaults = function (def) {
+ if (!def || !Object.keys(def).length) return Minimatch
+ return minimatch.defaults(def).Minimatch
}
-function isDecCode(c) {
- return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */));
+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 resolveYamlInteger(data) {
- if (data === null) return false;
+function Minimatch (pattern, options) {
+ if (!(this instanceof Minimatch)) {
+ return new Minimatch(pattern, options)
+ }
- var max = data.length,
- index = 0,
- hasDigits = false,
- ch;
+ if (typeof pattern !== 'string') {
+ throw new TypeError('glob pattern string required')
+ }
- if (!max) return false;
+ if (!options) options = {}
+ pattern = pattern.trim()
- ch = data[index];
+ // windows support: need to use /, not \
+ if (path.sep !== '/') {
+ pattern = pattern.split(path.sep).join('/')
+ }
- // sign
- if (ch === '-' || ch === '+') {
- ch = data[++index];
+ 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
}
- if (ch === '0') {
- // 0
- if (index + 1 === max) return true;
- ch = data[++index];
+ // step 1: figure out negation, etc.
+ this.parseNegate()
- // base 2, base 8, base 16
+ // step 2: expand braces
+ var set = this.globSet = this.braceExpand()
- if (ch === 'b') {
- // base 2
- index++;
+ if (options.debug) this.debug = console.error
- for (; index < max; index++) {
- ch = data[index];
- if (ch === '_') continue;
- if (ch !== '0' && ch !== '1') return false;
- hasDigits = true;
- }
- return hasDigits && ch !== '_';
+ 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 (ch === 'x') {
- // base 16
- index++;
+ if (typeof pattern === 'undefined') {
+ throw new TypeError('undefined pattern')
+ }
- for (; index < max; index++) {
- ch = data[index];
- if (ch === '_') continue;
- if (!isHexCode(data.charCodeAt(index))) return false;
- hasDigits = true;
+ 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
}
- return hasDigits && ch !== '_';
+ self.debug('clearStateChar %j %j', stateChar, re)
+ stateChar = false
}
+ }
- // base 8
- for (; index < max; index++) {
- ch = data[index];
- if (ch === '_') continue;
- if (!isOctCode(data.charCodeAt(index))) return false;
- hasDigits = true;
+ 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
}
- return hasDigits && ch !== '_';
+
+ 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 (?:<pattern>)<type>
+ 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]
}
- // base 10 (except 0) or base 60
+ // 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 = '\\'
+ }
- // value should not start with `_`;
- if (ch === '_') return false;
+ // 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 + '|'
+ })
- for (; index < max; index++) {
- ch = data[index];
- if (ch === '_') continue;
- if (ch === ':') break;
- if (!isDecCode(data.charCodeAt(index))) {
- return false;
- }
- hasDigits = true;
+ 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
}
- // Should have digits and should not end with `_`
- if (!hasDigits || ch === '_') return false;
+ // handle trailing things that only matter at the very end.
+ clearStateChar()
+ if (escaping) {
+ // trailing \\
+ re += '\\\\'
+ }
- // if !base60 - done;
- if (ch !== ':') return true;
+ // 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
+ }
- // base60 almost not used, no needs to optimize
- return /^(:[0-5]?[0-9])+$/.test(data.slice(index));
-}
+ // 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]
-function constructYamlInteger(data) {
- var value = data, sign = 1, ch, base, digits = [];
+ 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)
- if (value.indexOf('_') !== -1) {
- value = value.replace(/_/g, '');
+ 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
}
- ch = value[0];
+ // 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 (ch === '-' || ch === '+') {
- if (ch === '-') sign = -1;
- value = value.slice(1);
- ch = value[0];
+ if (addPatternStart) {
+ re = patternStart + re
}
- if (value === '0') return 0;
+ // parsing just a piece of a larger pattern.
+ if (isSub === SUBPARSE) {
+ return [re, hasMagic]
+ }
- 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);
+ // 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)
}
- if (value.indexOf(':') !== -1) {
- value.split(':').forEach(function (v) {
- digits.unshift(parseInt(v, 10));
- });
+ 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('$.')
+ }
- value = 0;
- base = 1;
+ regExp._glob = pattern
+ regExp._src = re
- digits.forEach(function (d) {
- value += (d * base);
- base *= 60;
- });
+ return regExp
+}
- return sign * value;
+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
- return sign * parseInt(value, 10);
+ 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
}
-function isInteger(object) {
- return (Object.prototype.toString.call(object)) === '[object Number]' &&
- (object % 1 === 0 && !common.isNegativeZero(object));
+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
}
-var int_1 = 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' ]
+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('/')
}
-});
-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))$');
+ // treat the test path as a set of pathparts.
+ f = f.split(slashSplit)
+ this.debug(this.pattern, 'split', f)
-function resolveYamlFloat(data) {
- if (data === null) return false;
+ // 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.
- 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;
+ 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
}
- return true;
+ 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
}
-function constructYamlFloat(data) {
- var value, sign, base, digits;
+// 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
- value = data.replace(/_/g, '').toLowerCase();
- sign = value[0] === '-' ? -1 : 1;
- digits = [];
+ this.debug('matchOne',
+ { 'this': this, file: file, pattern: pattern })
- if ('+-'.indexOf(value[0]) >= 0) {
- value = value.slice(1);
+ 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
}
- if (value === '.inf') {
- return (sign === 1) ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+ // 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/*
- } else if (value === '.nan') {
- return NaN;
+ // 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
+ }
- } else if (value.indexOf(':') >= 0) {
- value.split(':').forEach(function (v) {
- digits.unshift(parseFloat(v, 10));
- });
+ // should be unreachable.
+ throw new Error('wtf?')
+}
- value = 0.0;
- base = 1;
+// replace stuff like \* with *
+function globUnescape (s) {
+ return s.replace(/\\(.)/g, '$1')
+}
- digits.forEach(function (d) {
- value += d * base;
- base *= 60;
- });
+function regExpEscape (s) {
+ return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&')
+}
- return sign * value;
+/***/ }),
+/* 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 sign * parseFloat(value, 10);
+
+ return val.slice(0, index + 1)
}
-var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;
+/***/ }),
+/* 41 */
+/***/ (function(module, exports, __webpack_require__) {
-function representYamlFloat(object, style) {
- var res;
+"use strict";
- if (isNaN(object)) {
- switch (style) {
- case 'lowercase': return '.nan';
- case 'uppercase': return '.NAN';
- case 'camelcase': return '.NaN';
+
+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
}
- } else if (Number.POSITIVE_INFINITY === object) {
- switch (style) {
- case 'lowercase': return '.inf';
- case 'uppercase': return '.INF';
- case 'camelcase': return '.Inf';
+
+ if (
+ config.commonmark !== undefined &&
+ config.commonmark !== ctx.options.commonmark
+ ) {
+ continue
}
- } else if (Number.NEGATIVE_INFINITY === object) {
- switch (style) {
- case 'lowercase': return '-.inf';
- case 'uppercase': return '-.INF';
- case 'camelcase': return '-.Inf';
+
+ if (tokenizers[interruptor[0]].apply(ctx, params)) {
+ return true
}
- } else if (common.isNegativeZero(object)) {
- return '-0.0';
}
- res = object.toString(10);
+ return false
+}
- // 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;
+/***/ }),
+/* 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()
}
-function isFloat(object) {
- return (Object.prototype.toString.call(object) === '[object Number]') &&
- (object % 1 !== 0 || common.isNegativeZero(object));
+
+/***/ }),
+/* 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
}
-var float_1 = new type('tag:yaml.org,2002:float', {
- kind: 'scalar',
- resolve: resolveYamlFloat,
- construct: constructYamlFloat,
- predicate: isFloat,
- represent: representYamlFloat,
- defaultStyle: 'lowercase'
+
+/***/ }),
+/* 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)
+ ]
});
-var json = new schema({
+
+/***/ }),
+/* 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: [
- failsafe
+ __webpack_require__(33)
],
implicit: [
- _null,
- bool,
- int_1,
- float_1
+ __webpack_require__(108),
+ __webpack_require__(109),
+ __webpack_require__(110),
+ __webpack_require__(111)
]
});
-var core = new schema({
- include: [
- json
- ]
+
+/***/ }),
+/* 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')
});
-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
+module.exports = (input, reviver, filename) => {
+ if (typeof reviver === 'string') {
+ filename = reviver;
+ reviver = null;
+ }
-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
+ try {
+ try {
+ return JSON.parse(input, reviver);
+ } catch (err) {
+ fallback(input, reviver);
-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;
+ 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;
}
-function constructYamlTimestamp(data) {
- var match, year, month, day, hour, minute, second, fraction = 0,
- delta = null, tz_hour, tz_minute, date;
+module.exports = setup;
- 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
+/***/ }),
+/* 53 */
+/***/ (function(module, exports, __webpack_require__) {
- year = +(match[1]);
- month = +(match[2]) - 1; // JS month starts with 0
- day = +(match[3]);
+"use strict";
- if (!match[4]) { // no hour
- return new Date(Date.UTC(year, month, day));
+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:
+ * <https://docs.npmjs.com/files/folders#node-modules>
+ * <https://github.com/sindresorhus/resolve-from>
+ *
+ * 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()]
}
- // match: [4] hour [5] minute [6] second [7] fraction
+ /* Non-path. */
+ if (name.indexOf(path.sep) === -1 && name.charAt(0) !== '.') {
+ if (settings.global == null ? globally : settings.global) {
+ sources.push(globals)
+ }
- hour = +(match[4]);
- minute = +(match[5]);
- second = +(match[6]);
+ /* Unprefix module. */
+ if (prefix) {
+ prefix = prefix.charAt(prefix.length - 1) === '-' ? prefix : prefix + '-'
- if (match[7]) {
- fraction = match[7].slice(0, 3);
- while (fraction.length < 3) { // milli-seconds
- fraction += '0';
+ if (name.slice(0, prefix.length) !== prefix) {
+ plugin = prefix + name
+ }
}
- fraction = +fraction;
}
- // match: [8] tz [9] tz_sign [10] tz_hour [11] tz_minute
+ length = sources.length
+ index = -1
- 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;
+ while (++index < length) {
+ cwd = sources[index]
+ filePath = (plugin && resolve(cwd, plugin)) || resolve(cwd, name)
+
+ if (filePath) {
+ return filePath
+ }
}
- date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
+ return null
+}
- if (delta) date.setTime(date.getTime() - delta);
- return date;
+/***/ }),
+/* 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 representYamlTimestamp(object /*, style*/) {
- return object.toISOString();
+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);
}
-var timestamp = new type('tag:yaml.org,2002:timestamp', {
- kind: 'scalar',
- resolve: resolveYamlTimestamp,
- construct: constructYamlTimestamp,
- instanceOf: Date,
- represent: representYamlTimestamp
-});
-function resolveYamlMerge(data) {
- return data === '<<' || data === null;
+
+/***/ }),
+/* 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);
+ }
}
-var merge = new type('tag:yaml.org,2002:merge', {
- kind: 'scalar',
- resolve: resolveYamlMerge
-});
+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;
-/*eslint-disable no-bitwise*/
+ if (givenFilePath) {
+ if (givenFile) {
+ apply(callback, givenFile);
+ } else {
+ givenFile = [callback];
+ self.givenFile = givenFile;
+ debug('Checking given file `%s`', givenFilePath);
+ read(givenFilePath, loadGiven);
+ }
-var NodeBuffer;
+ return;
+ }
-try {
- // A trick for browserified version, to not include `Buffer` shim
- var _require = commonjsRequire;
- NodeBuffer = _require('buffer').Buffer;
-} catch (__) {}
+ 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;
-// [ 64, 65, 66 ] -> [ padding, CR, LF ]
-var BASE64_MAP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r';
+ 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 resolveYamlBinary(data) {
- if (data === null) return false;
+ function find(directory) {
+ var index = -1;
+ var length = names.length;
- var code, idx, bitlen = 0, max = data.length, map = BASE64_MAP;
+ next();
- // Convert one by one.
- for (idx = 0; idx < max; idx++) {
- code = map.indexOf(data.charAt(idx));
+ function next() {
+ var parent;
- // Skip CR/LF
- if (code > 64) continue;
+ /* 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);
- // Fail on illegal characters
- if (code < 0) return false;
+ 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);
+ }
+ }
+ }
- bitlen += 6;
+ 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);
+ }
}
- // If there are any bits left, source was corrupted
- return (bitlen % 8) === 0;
+ 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);
+ }
+ }
}
-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)
+/***/ }),
+/* 58 */
+/***/ (function(module, exports, __webpack_require__) {
- 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);
+// 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 {<filename>: 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()
+ }
}
+ }
+}
- bits = (bits << 6) | map.indexOf(input.charAt(idx));
+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()
}
+}
- // Dump tail
+Glob.prototype._realpathSet = function (index, cb) {
+ var matchset = this.matches[index]
+ if (!matchset)
+ return cb()
- tailbits = (max % 4) * 6;
+ var found = Object.keys(matchset)
+ var self = this
+ var n = found.length
- 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);
+ 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')
}
+}
- // 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);
+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])
+ }
+ }
}
+}
- return result;
+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)
}
-function representYamlBinary(object /*, style*/) {
- var result = '', bits = 0, idx, tail,
- max = object.length,
- map = BASE64_MAP;
+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)
+ })
+}
- // Convert every three bytes to 4 ASCII characters.
+Glob.prototype._processReaddir2 = function (prefix, read, abs, remain, index, inGlobStar, entries, cb) {
- 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];
+ // 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)
}
+ }
- bits = (bits << 8) + object[idx];
+ //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()
}
- // Dump tail
+ // 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()
+}
- tail = max % 3;
+Glob.prototype._emitMatch = function (index, e) {
+ if (this.aborted)
+ return
- 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];
+ if (isIgnored(this, e))
+ return
+
+ if (this.paused) {
+ this._emitQueue.push([index, e])
+ return
}
- return result;
+ 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)
}
-function isBinary(object) {
- return NodeBuffer && NodeBuffer.isBuffer(object);
+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)
+ }
}
-var binary = new type('tag:yaml.org,2002:binary', {
- kind: 'scalar',
- resolve: resolveYamlBinary,
- construct: constructYamlBinary,
- predicate: isBinary,
- represent: representYamlBinary
-});
+Glob.prototype._readdir = function (abs, inGlobStar, cb) {
+ if (this.aborted)
+ return
-var _hasOwnProperty = Object.prototype.hasOwnProperty;
-var _toString = Object.prototype.toString;
+ cb = inflight('readdir\0'+abs+'\0'+inGlobStar, cb)
+ if (!cb)
+ return
-function resolveYamlOmap(data) {
- if (data === null) return true;
+ //console.error('RD %j %j', +inGlobStar, abs)
+ if (inGlobStar && !ownProp(this.symlinks, abs))
+ return this._readdirInGlobStar(abs, cb)
- var objectKeys = [], index, length, pair, pairKey, pairHasKey,
- object = data;
+ if (ownProp(this.cache, abs)) {
+ var c = this.cache[abs]
+ if (!c || c === 'FILE')
+ return cb()
- for (index = 0, length = object.length; index < length; index += 1) {
- pair = object[index];
- pairHasKey = false;
+ if (Array.isArray(c))
+ return cb(null, c)
+ }
- if (_toString.call(pair) !== '[object Object]') return false;
+ var self = this
+ fs.readdir(abs, readdirCb(this, abs, cb))
+}
- for (pairKey in pair) {
- if (_hasOwnProperty.call(pair, pairKey)) {
- if (!pairHasKey) pairHasKey = true;
- else return false;
+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 (!pairHasKey) return false;
+ if (process.platform === 'win32')
+ prefix = prefix.replace(/\\/g, '/')
- if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey);
- else return false;
+ // 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.
}
- return true;
+ 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)
+ }
+ }
}
-function constructYamlOmap(data) {
- return data !== null ? data : [];
+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)
}
-var omap = new type('tag:yaml.org,2002:omap', {
- kind: 'sequence',
- resolve: resolveYamlOmap,
- construct: constructYamlOmap
-});
-var _toString$1 = Object.prototype.toString;
+/***/ }),
+/* 59 */
+/***/ (function(module, exports, __webpack_require__) {
-function resolveYamlPairs(data) {
- if (data === null) return true;
+module.exports = realpath
+realpath.realpath = realpath
+realpath.sync = realpathSync
+realpath.realpathSync = realpathSync
+realpath.monkeypatch = monkeypatch
+realpath.unmonkeypatch = unmonkeypatch
- var index, length, pair, keys, result,
- object = data;
+var fs = __webpack_require__(6)
+var origRealpath = fs.realpath
+var origRealpathSync = fs.realpathSync
- result = new Array(object.length);
+var version = process.version
+var ok = /^v[0-5]\./.test(version)
+var old = __webpack_require__(148)
- for (index = 0, length = object.length; index < length; index += 1) {
- pair = object[index];
+function newError (er) {
+ return er && er.syscall === 'realpath' && (
+ er.code === 'ELOOP' ||
+ er.code === 'ENOMEM' ||
+ er.code === 'ENAMETOOLONG'
+ )
+}
- if (_toString$1.call(pair) !== '[object Object]') return false;
+function realpath (p, cache, cb) {
+ if (ok) {
+ return origRealpath(p, cache, cb)
+ }
- keys = Object.keys(pair);
+ 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)
+ }
+ })
+}
- if (keys.length !== 1) return false;
+function realpathSync (p, cache) {
+ if (ok) {
+ return origRealpathSync(p, cache)
+ }
- result[index] = [ keys[0], pair[keys[0]] ];
+ try {
+ return origRealpathSync(p, cache)
+ } catch (er) {
+ if (newError(er)) {
+ return old.realpathSync(p, cache)
+ } else {
+ throw er
+ }
}
+}
- return true;
+function monkeypatch () {
+ fs.realpath = realpath
+ fs.realpathSync = realpathSync
}
-function constructYamlPairs(data) {
- if (data === null) return [];
+function unmonkeypatch () {
+ fs.realpath = origRealpath
+ fs.realpathSync = origRealpathSync
+}
- var index, length, pair, keys, result,
- object = data;
- result = new Array(object.length);
+/***/ }),
+/* 60 */
+/***/ (function(module, exports) {
- for (index = 0, length = object.length; index < length; index += 1) {
- pair = object[index];
+module.exports = require("assert");
- keys = Object.keys(pair);
+/***/ }),
+/* 61 */
+/***/ (function(module, exports, __webpack_require__) {
- result[index] = [ keys[0], pair[keys[0]] ];
+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)
}
+}
- return result;
+// 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
+ }
}
-var pairs = new type('tag:yaml.org,2002:pairs', {
- kind: 'sequence',
- resolve: resolveYamlPairs,
- construct: constructYamlPairs
-});
+function setopts (self, pattern, options) {
+ if (!options)
+ options = {}
-var _hasOwnProperty$1 = Object.prototype.hasOwnProperty;
+ // 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
+ }
-function resolveYamlSet(data) {
- if (data === null) return true;
+ 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
+ }
- var key, object = data;
+ self.root = options.root || path.resolve(self.cwd, "/")
+ self.root = path.resolve(self.root)
+ if (process.platform === "win32")
+ self.root = self.root.replace(/\\/g, "/")
- for (key in object) {
- if (_hasOwnProperty$1.call(object, key)) {
- if (object[key] !== null) return false;
+ // 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
+ })
}
}
- return 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 constructYamlSet(data) {
- return data !== null ? data : {};
+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
}
-var set = new type('tag:yaml.org,2002:set', {
- kind: 'mapping',
- resolve: resolveYamlSet,
- construct: constructYamlSet
-});
+// 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)
+ }
-var default_safe = new schema({
- include: [
- core
- ],
- implicit: [
- timestamp,
- merge
- ],
- explicit: [
- binary,
- omap,
- pairs,
- set
- ]
-});
+ if (process.platform === 'win32')
+ abs = abs.replace(/\\/g, '/')
-function resolveJavascriptUndefined() {
- return true;
+ return abs
}
-function constructJavascriptUndefined() {
- /*eslint-disable no-undefined*/
- return undefined;
+
+// 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 representJavascriptUndefined() {
- return '';
+function childrenIgnored (self, path) {
+ if (!self.ignore.length)
+ return false
+
+ return self.ignore.some(function(item) {
+ return !!(item.gmatcher && item.gmatcher.match(path))
+ })
}
-function isUndefined(object) {
- return typeof object === 'undefined';
+
+/***/ }),
+/* 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
+ }
}
-var _undefined = new type('tag:yaml.org,2002:js/undefined', {
- kind: 'scalar',
- resolve: resolveJavascriptUndefined,
- construct: constructJavascriptUndefined,
- predicate: isUndefined,
- represent: representJavascriptUndefined
+
+/***/ }),
+/* 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 <https://feross.org>
+ * @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.
+
+
+
+/*<replacement>*/
+
+var pna = __webpack_require__(28);
+/*</replacement>*/
+
+module.exports = Readable;
+
+/*<replacement>*/
+var isArray = __webpack_require__(163);
+/*</replacement>*/
+
+/*<replacement>*/
+var Duplex;
+/*</replacement>*/
+
+Readable.ReadableState = ReadableState;
+
+/*<replacement>*/
+var EE = __webpack_require__(37).EventEmitter;
+
+var EElistenerCount = function (emitter, type) {
+ return emitter.listeners(type).length;
+};
+/*</replacement>*/
+
+/*<replacement>*/
+var Stream = __webpack_require__(68);
+/*</replacement>*/
+
+/*<replacement>*/
+
+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;
+}
+
+/*</replacement>*/
+
+/*<replacement>*/
+var util = __webpack_require__(22);
+util.inherits = __webpack_require__(13);
+/*</replacement>*/
+
+/*<replacement>*/
+var debugUtil = __webpack_require__(11);
+var debug = void 0;
+if (debugUtil && debugUtil.debuglog) {
+ debug = debugUtil.debuglog('stream');
+} else {
+ debug = function () {};
+}
+/*</replacement>*/
+
+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;
+ }
});
-function resolveJavascriptRegExp(data) {
- if (data === null) return false;
- if (data.length === 0) return false;
+Readable.prototype.destroy = destroyImpl.destroy;
+Readable.prototype._undestroy = destroyImpl.undestroy;
+Readable.prototype._destroy = function (err, cb) {
+ this.push(null);
+ cb(err);
+};
- var regexp = data,
- tail = /\/([gim]*)$/.exec(data),
- modifiers = '';
+// 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 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 (!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;
+ }
- 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 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 true;
+ return needMoreData(state);
}
-function constructJavascriptRegExp(data) {
- var regexp = data,
- tail = /\/([gim]*)$/.exec(data),
- modifiers = '';
+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);
- // `/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);
+ if (state.needReadable) emitReadable(stream);
}
+ maybeReadMore(stream, state);
+}
- return new RegExp(regexp, modifiers);
+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;
}
-function representJavascriptRegExp(object /*, style*/) {
- var result = '/' + object.source + '/';
+// 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);
+}
- if (object.global) result += 'g';
- if (object.multiline) result += 'm';
- if (object.ignoreCase) result += 'i';
+Readable.prototype.isPaused = function () {
+ return this._readableState.flowing === false;
+};
- return result;
+// 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);
}
-function isRegExp(object) {
- return Object.prototype.toString.call(object) === '[object RegExp]';
+// 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);
+ }
}
-var regexp = new type('tag:yaml.org,2002:js/regexp', {
- kind: 'scalar',
- resolve: resolveJavascriptRegExp,
- construct: constructJavascriptRegExp,
- predicate: isRegExp,
- represent: representJavascriptRegExp
+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;
+ }
});
-var esprima;
+// 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);
+ }
-// Browserified version does not have esprima
+ 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";
+
+
+/*<replacement>*/
+
+var pna = __webpack_require__(28);
+/*</replacement>*/
+
+// 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.
//
-// 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.
+// 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:
//
-try {
- // workaround to exclude package from browserify list.
- var _require$1 = commonjsRequire;
- esprima = _require$1('esprima');
-} catch (_) {
- /*global window */
- if (typeof window !== 'undefined') esprima = window.esprima;
+// 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.
+
+
+
+/*<replacement>*/
+
+var pna = __webpack_require__(28);
+/*</replacement>*/
+
+module.exports = Writable;
+
+/* <replacement> */
+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);
+ };
+}
+/* </replacement> */
-function resolveJavascriptFunction(data) {
- if (data === null) return false;
+/*<replacement>*/
+var asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;
+/*</replacement>*/
+
+/*<replacement>*/
+var Duplex;
+/*</replacement>*/
+
+Writable.WritableState = WritableState;
+
+/*<replacement>*/
+var util = __webpack_require__(22);
+util.inherits = __webpack_require__(13);
+/*</replacement>*/
+
+/*<replacement>*/
+var internalUtil = {
+ deprecate: __webpack_require__(165)
+};
+/*</replacement>*/
+
+/*<replacement>*/
+var Stream = __webpack_require__(68);
+/*</replacement>*/
+
+/*<replacement>*/
+
+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;
+}
+
+/*</replacement>*/
+
+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 {
- var source = '(' + data + ')',
- ast = esprima.parse(source, { range: true });
+ Object.defineProperty(WritableState.prototype, 'buffer', {
+ get: internalUtil.deprecate(function () {
+ return this.getBuffer();
+ }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')
+ });
+ } catch (_) {}
+})();
- 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')) {
+// 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) {
+ /*<replacement>*/
+ asyncWrite(afterWrite, stream, state, finished, cb);
+ /*</replacement>*/
+ } 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;
+ }
- return true;
- } catch (err) {
- return false;
+ // 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.
+
+
+
+/*<replacement>*/
+
+var Buffer = __webpack_require__(29).Buffer;
+/*</replacement>*/
+
+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);
}
-function constructJavascriptFunction(data) {
- /*jslint evil:true*/
+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 || '';
+};
- var source = '(' + data + ')',
- ast = esprima.parse(source, { range: true }),
- params = [],
- body;
+StringDecoder.prototype.end = utf8End;
- 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');
+// 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;
+};
- ast.body[0].expression.params.forEach(function (param) {
- params.push(param.name);
+// 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);
+
+/*<replacement>*/
+var util = __webpack_require__(22);
+util.inherits = __webpack_require__(13);
+/*</replacement>*/
+
+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');
});
+};
- body = ast.body[0].expression.body.range;
+function done(stream, er, data) {
+ if (er) return stream.emit('error', er);
- // 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));
+ 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
+ }
+ }
}
- // 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]));
+
+ // Anything else...
+ return false
}
-function representJavascriptFunction(object /*, style*/) {
- return object.toString();
+/**
+ * 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)
+ }
}
-function isFunction(object) {
- return Object.prototype.toString.call(object) === '[object Function]';
+
+/***/ }),
+/* 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
+ }
+ }
}
-var _function = new type('tag:yaml.org,2002:js/function', {
- kind: 'scalar',
- resolve: resolveJavascriptFunction,
- construct: constructJavascriptFunction,
- predicate: isFunction,
- represent: representJavascriptFunction
-});
-var default_full = schema.DEFAULT = new schema({
- include: [
- default_safe
- ],
- explicit: [
- _undefined,
- regexp,
- _function
- ]
+/***/ }),
+/* 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 = '<![A-Za-z]+\\s+[^>]*>'
+var cdata = '<!\\[CDATA\\[[\\s\\S]*?\\]\\]>'
+
+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);
});
-/*eslint-disable max-len,no-use-before-define*/
+/***/ }),
+/* 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);
+ }
-var _hasOwnProperty$2 = Object.prototype.hasOwnProperty;
+ 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;
@@ -1617,7 +9528,7 @@ function State(input, options) {
this.input = input;
this.filename = options['filename'] || null;
- this.schema = options['schema'] || default_full;
+ this.schema = options['schema'] || DEFAULT_FULL_SCHEMA;
this.onWarning = options['onWarning'] || null;
this.legacy = options['legacy'] || false;
this.json = options['json'] || false;
@@ -1648,9 +9559,9 @@ function State(input, options) {
function generateError(state, message) {
- return new exception(
+ return new YAMLException(
message,
- new mark(state.filename, state.input, state.position, state.line, (state.position - state.lineStart)));
+ new Mark(state.filename, state.input, state.position, state.line, (state.position - state.lineStart)));
}
function throwError(state, message) {
@@ -1714,7 +9625,7 @@ var directiveHandlers = {
throwError(state, 'ill-formed tag handle (first argument) of the TAG directive');
}
- if (_hasOwnProperty$2.call(state.tagMap, handle)) {
+ if (_hasOwnProperty.call(state.tagMap, handle)) {
throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle');
}
@@ -1761,7 +9672,7 @@ function mergeMappings(state, destination, source, overridableKeys) {
for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
key = sourceKeys[index];
- if (!_hasOwnProperty$2.call(destination, key)) {
+ if (!_hasOwnProperty.call(destination, key)) {
destination[key] = source[key];
overridableKeys[key] = true;
}
@@ -1787,8 +9698,8 @@ function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valu
}
} else {
if (!state.json &&
- !_hasOwnProperty$2.call(overridableKeys, keyNode) &&
- _hasOwnProperty$2.call(_result, keyNode)) {
+ !_hasOwnProperty.call(overridableKeys, keyNode) &&
+ _hasOwnProperty.call(_result, keyNode)) {
state.line = startLine || state.line;
state.position = startPos || state.position;
throwError(state, 'duplicated mapping key');
@@ -2667,7 +10578,7 @@ function readTagProperty(state) {
if (isVerbatim) {
state.tag = tagName;
- } else if (_hasOwnProperty$2.call(state.tagMap, tagHandle)) {
+ } else if (_hasOwnProperty.call(state.tagMap, tagHandle)) {
state.tag = state.tagMap[tagHandle] + tagName;
} else if (tagHandle === '!') {
@@ -2868,7 +10779,7 @@ function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact
break;
}
}
- } else if (_hasOwnProperty$2.call(state.typeMap[state.kind || 'fallback'], state.tag)) {
+ } 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) {
@@ -2955,7 +10866,7 @@ function readDocument(state) {
if (ch !== 0) readLineBreak(state);
- if (_hasOwnProperty$2.call(directiveHandlers, directiveName)) {
+ if (_hasOwnProperty.call(directiveHandlers, directiveName)) {
directiveHandlers[directiveName](state, directiveName, directiveArgs);
} else {
throwWarning(state, 'unknown document directive "' + directiveName + '"');
@@ -3060,45 +10971,7875 @@ function load(input, options) {
} else if (documents.length === 1) {
return documents[0];
}
- throw new exception('expected a single document in the stream, but found more');
+ 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 }, options));
+ loadAll(input, output, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options));
} else {
- return loadAll(input, common.extend({ schema: default_safe }, options));
+ return loadAll(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options));
}
}
function safeLoad(input, options) {
- return load(input, common.extend({ schema: default_safe }, options));
+ return load(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options));
}
-var loadAll_1 = loadAll;
-var load_1 = load;
-var safeLoadAll_1 = safeLoadAll;
-var safeLoad_1 = safeLoad;
+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);
-var loader = {
- loadAll: loadAll_1,
- load: load_1,
- safeLoadAll: safeLoadAll_1,
- safeLoad: safeLoad_1
+ return common.repeat(' ', indent) + head + snippet + tail + '\n' +
+ common.repeat(' ', indent + this.position - start + head.length) + '^';
};
-/*eslint-disable no-use-before-define*/
+
+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 _toString$2 = Object.prototype.toString;
-var _hasOwnProperty$3 = Object.prototype.hasOwnProperty;
+
+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 <COPYRIGHT HOLDER> 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. <svg:path> 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. '&#123;'
+ numeric = (ch === '#');
+ break;
+ case 3:
+ if (numeric) {
+ // e.g. '&#x41;'
+ 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. '&#x41;' 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 {<foo as bar>} ...;
+ 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 <foo> ...;
+ 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; // `<!--`
+ var comment = this.skipSingleLineComment(4);
+ if (this.trackComment) {
+ comments = comments.concat(comment);
+ }
+ }
+ else {
+ break;
+ }
+ }
+ else {
+ break;
+ }
+ }
+ return comments;
+ };
+ // https://tc39.github.io/ecma262/#sec-future-reserved-words
+ Scanner.prototype.isFutureReservedWord = function (id) {
+ switch (id) {
+ case 'enum':
+ case 'export':
+ case 'import':
+ case 'super':
+ return true;
+ default:
+ return false;
+ }
+ };
+ Scanner.prototype.isStrictModeReservedWord = function (id) {
+ switch (id) {
+ case 'implements':
+ case 'interface':
+ case 'package':
+ case 'private':
+ case 'protected':
+ case 'public':
+ case 'static':
+ case 'yield':
+ case 'let':
+ return true;
+ default:
+ return false;
+ }
+ };
+ Scanner.prototype.isRestrictedWord = function (id) {
+ return id === 'eval' || id === 'arguments';
+ };
+ // https://tc39.github.io/ecma262/#sec-keywords
+ Scanner.prototype.isKeyword = function (id) {
+ switch (id.length) {
+ case 2:
+ return (id === 'if') || (id === 'in') || (id === 'do');
+ case 3:
+ return (id === 'var') || (id === 'for') || (id === 'new') ||
+ (id === 'try') || (id === 'let');
+ case 4:
+ return (id === 'this') || (id === 'else') || (id === 'case') ||
+ (id === 'void') || (id === 'with') || (id === 'enum');
+ case 5:
+ return (id === 'while') || (id === 'break') || (id === 'catch') ||
+ (id === 'throw') || (id === 'const') || (id === 'yield') ||
+ (id === 'class') || (id === 'super');
+ case 6:
+ return (id === 'return') || (id === 'typeof') || (id === 'delete') ||
+ (id === 'switch') || (id === 'export') || (id === 'import');
+ case 7:
+ return (id === 'default') || (id === 'finally') || (id === 'extends');
+ case 8:
+ return (id === 'function') || (id === 'continue') || (id === 'debugger');
+ case 10:
+ return (id === 'instanceof');
+ default:
+ return false;
+ }
+ };
+ Scanner.prototype.codePointAt = function (i) {
+ var cp = this.source.charCodeAt(i);
+ if (cp >= 0xD800 && cp <= 0xDBFF) {
+ var second = this.source.charCodeAt(i + 1);
+ if (second >= 0xDC00 && second <= 0xDFFF) {
+ var first = cp;
+ cp = (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;
+ }
+ }
+ return cp;
+ };
+ Scanner.prototype.scanHexEscape = function (prefix) {
+ var len = (prefix === 'u') ? 4 : 2;
+ var code = 0;
+ for (var i = 0; i < len; ++i) {
+ if (!this.eof() && character_1.Character.isHexDigit(this.source.charCodeAt(this.index))) {
+ code = code * 16 + hexValue(this.source[this.index++]);
+ }
+ else {
+ return null;
+ }
+ }
+ return String.fromCharCode(code);
+ };
+ Scanner.prototype.scanUnicodeCodePointEscape = function () {
+ var ch = this.source[this.index];
+ var code = 0;
+ // At least, one hex digit is required.
+ if (ch === '}') {
+ this.throwUnexpectedToken();
+ }
+ while (!this.eof()) {
+ ch = this.source[this.index++];
+ if (!character_1.Character.isHexDigit(ch.charCodeAt(0))) {
+ break;
+ }
+ code = code * 16 + hexValue(ch);
+ }
+ if (code > 0x10FFFF || ch !== '}') {
+ this.throwUnexpectedToken();
+ }
+ return character_1.Character.fromCodePoint(code);
+ };
+ Scanner.prototype.getIdentifier = function () {
+ var start = this.index++;
+ while (!this.eof()) {
+ var ch = this.source.charCodeAt(this.index);
+ if (ch === 0x5C) {
+ // Blackslash (U+005C) marks Unicode escape sequence.
+ this.index = start;
+ return this.getComplexIdentifier();
+ }
+ else if (ch >= 0xD800 && ch < 0xDFFF) {
+ // Need to handle surrogate pairs.
+ this.index = start;
+ return this.getComplexIdentifier();
+ }
+ if (character_1.Character.isIdentifierPart(ch)) {
+ ++this.index;
+ }
+ else {
+ break;
+ }
+ }
+ return this.source.slice(start, this.index);
+ };
+ Scanner.prototype.getComplexIdentifier = function () {
+ var cp = this.codePointAt(this.index);
+ var id = character_1.Character.fromCodePoint(cp);
+ this.index += id.length;
+ // '\u' (U+005C, U+0075) denotes an escaped character.
+ var ch;
+ if (cp === 0x5C) {
+ if (this.source.charCodeAt(this.index) !== 0x75) {
+ this.throwUnexpectedToken();
+ }
+ ++this.index;
+ if (this.source[this.index] === '{') {
+ ++this.index;
+ ch = this.scanUnicodeCodePointEscape();
+ }
+ else {
+ ch = this.scanHexEscape('u');
+ if (ch === null || ch === '\\' || !character_1.Character.isIdentifierStart(ch.charCodeAt(0))) {
+ this.throwUnexpectedToken();
+ }
+ }
+ id = ch;
+ }
+ while (!this.eof()) {
+ cp = this.codePointAt(this.index);
+ if (!character_1.Character.isIdentifierPart(cp)) {
+ break;
+ }
+ ch = character_1.Character.fromCodePoint(cp);
+ id += ch;
+ this.index += ch.length;
+ // '\u' (U+005C, U+0075) denotes an escaped character.
+ if (cp === 0x5C) {
+ id = id.substr(0, id.length - 1);
+ if (this.source.charCodeAt(this.index) !== 0x75) {
+ this.throwUnexpectedToken();
+ }
+ ++this.index;
+ if (this.source[this.index] === '{') {
+ ++this.index;
+ ch = this.scanUnicodeCodePointEscape();
+ }
+ else {
+ ch = this.scanHexEscape('u');
+ if (ch === null || ch === '\\' || !character_1.Character.isIdentifierPart(ch.charCodeAt(0))) {
+ this.throwUnexpectedToken();
+ }
+ }
+ id += ch;
+ }
+ }
+ return id;
+ };
+ Scanner.prototype.octalToDecimal = function (ch) {
+ // \0 is not octal escape sequence
+ var octal = (ch !== '0');
+ var code = octalValue(ch);
+ if (!this.eof() && character_1.Character.isOctalDigit(this.source.charCodeAt(this.index))) {
+ octal = true;
+ code = code * 8 + octalValue(this.source[this.index++]);
+ // 3 digits are only allowed when string starts
+ // with 0, 1, 2, 3
+ if ('0123'.indexOf(ch) >= 0 && !this.eof() && character_1.Character.isOctalDigit(this.source.charCodeAt(this.index))) {
+ code = code * 8 + octalValue(this.source[this.index++]);
+ }
+ }
+ return {
+ code: code,
+ octal: octal
+ };
+ };
+ // https://tc39.github.io/ecma262/#sec-names-and-keywords
+ Scanner.prototype.scanIdentifier = function () {
+ var type;
+ var start = this.index;
+ // Backslash (U+005C) starts an escaped character.
+ var id = (this.source.charCodeAt(start) === 0x5C) ? this.getComplexIdentifier() : this.getIdentifier();
+ // There is no keyword or literal with only one character.
+ // Thus, it must be an identifier.
+ if (id.length === 1) {
+ type = 3 /* Identifier */;
+ }
+ else if (this.isKeyword(id)) {
+ type = 4 /* Keyword */;
+ }
+ else if (id === 'null') {
+ type = 5 /* NullLiteral */;
+ }
+ else if (id === 'true' || id === 'false') {
+ type = 1 /* BooleanLiteral */;
+ }
+ else {
+ type = 3 /* Identifier */;
+ }
+ if (type !== 3 /* Identifier */ && (start + id.length !== this.index)) {
+ var restore = this.index;
+ this.index = start;
+ this.tolerateUnexpectedToken(messages_1.Messages.InvalidEscapedReservedWord);
+ this.index = restore;
+ }
+ return {
+ type: type,
+ value: id,
+ lineNumber: this.lineNumber,
+ lineStart: this.lineStart,
+ start: start,
+ end: this.index
+ };
+ };
+ // https://tc39.github.io/ecma262/#sec-punctuators
+ Scanner.prototype.scanPunctuator = function () {
+ var start = this.index;
+ // Check for most common single-character punctuators.
+ var str = this.source[this.index];
+ switch (str) {
+ case '(':
+ case '{':
+ if (str === '{') {
+ this.curlyStack.push('{');
+ }
+ ++this.index;
+ break;
+ case '.':
+ ++this.index;
+ if (this.source[this.index] === '.' && this.source[this.index + 1] === '.') {
+ // Spread operator: ...
+ this.index += 2;
+ str = '...';
+ }
+ break;
+ case '}':
+ ++this.index;
+ this.curlyStack.pop();
+ break;
+ case ')':
+ case ';':
+ case ',':
+ case '[':
+ case ']':
+ case ':':
+ case '?':
+ case '~':
+ ++this.index;
+ break;
+ default:
+ // 4-character punctuator.
+ str = this.source.substr(this.index, 4);
+ if (str === '>>>=') {
+ this.index += 4;
+ }
+ else {
+ // 3-character punctuators.
+ str = str.substr(0, 3);
+ if (str === '===' || str === '!==' || str === '>>>' ||
+ str === '<<=' || str === '>>=' || str === '**=') {
+ this.index += 3;
+ }
+ else {
+ // 2-character punctuators.
+ str = str.substr(0, 2);
+ if (str === '&&' || str === '||' || str === '==' || str === '!=' ||
+ str === '+=' || str === '-=' || str === '*=' || str === '/=' ||
+ str === '++' || str === '--' || str === '<<' || str === '>>' ||
+ str === '&=' || str === '|=' || str === '^=' || str === '%=' ||
+ str === '<=' || str === '>=' || str === '=>' || str === '**') {
+ this.index += 2;
+ }
+ else {
+ // 1-character punctuators.
+ str = this.source[this.index];
+ if ('<>=!+-*%&|^/'.indexOf(str) >= 0) {
+ ++this.index;
+ }
+ }
+ }
+ }
+ }
+ if (this.index === start) {
+ this.throwUnexpectedToken();
+ }
+ return {
+ type: 7 /* Punctuator */,
+ value: str,
+ lineNumber: this.lineNumber,
+ lineStart: this.lineStart,
+ start: start,
+ end: this.index
+ };
+ };
+ // https://tc39.github.io/ecma262/#sec-literals-numeric-literals
+ Scanner.prototype.scanHexLiteral = function (start) {
+ var num = '';
+ while (!this.eof()) {
+ if (!character_1.Character.isHexDigit(this.source.charCodeAt(this.index))) {
+ break;
+ }
+ num += this.source[this.index++];
+ }
+ if (num.length === 0) {
+ this.throwUnexpectedToken();
+ }
+ if (character_1.Character.isIdentifierStart(this.source.charCodeAt(this.index))) {
+ this.throwUnexpectedToken();
+ }
+ return {
+ type: 6 /* NumericLiteral */,
+ value: parseInt('0x' + num, 16),
+ lineNumber: this.lineNumber,
+ lineStart: this.lineStart,
+ start: start,
+ end: this.index
+ };
+ };
+ Scanner.prototype.scanBinaryLiteral = function (start) {
+ var num = '';
+ var ch;
+ while (!this.eof()) {
+ ch = this.source[this.index];
+ if (ch !== '0' && ch !== '1') {
+ break;
+ }
+ num += this.source[this.index++];
+ }
+ if (num.length === 0) {
+ // only 0b or 0B
+ this.throwUnexpectedToken();
+ }
+ if (!this.eof()) {
+ ch = this.source.charCodeAt(this.index);
+ /* istanbul ignore else */
+ if (character_1.Character.isIdentifierStart(ch) || character_1.Character.isDecimalDigit(ch)) {
+ this.throwUnexpectedToken();
+ }
+ }
+ return {
+ type: 6 /* NumericLiteral */,
+ value: parseInt(num, 2),
+ lineNumber: this.lineNumber,
+ lineStart: this.lineStart,
+ start: start,
+ end: this.index
+ };
+ };
+ Scanner.prototype.scanOctalLiteral = function (prefix, start) {
+ var num = '';
+ var octal = false;
+ if (character_1.Character.isOctalDigit(prefix.charCodeAt(0))) {
+ octal = true;
+ num = '0' + this.source[this.index++];
+ }
+ else {
+ ++this.index;
+ }
+ while (!this.eof()) {
+ if (!character_1.Character.isOctalDigit(this.source.charCodeAt(this.index))) {
+ break;
+ }
+ num += this.source[this.index++];
+ }
+ if (!octal && num.length === 0) {
+ // only 0o or 0O
+ this.throwUnexpectedToken();
+ }
+ if (character_1.Character.isIdentifierStart(this.source.charCodeAt(this.index)) || character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
+ this.throwUnexpectedToken();
+ }
+ return {
+ type: 6 /* NumericLiteral */,
+ value: parseInt(num, 8),
+ octal: octal,
+ lineNumber: this.lineNumber,
+ lineStart: this.lineStart,
+ start: start,
+ end: this.index
+ };
+ };
+ Scanner.prototype.isImplicitOctalLiteral = function () {
+ // Implicit octal, unless there is a non-octal digit.
+ // (Annex B.1.1 on Numeric Literals)
+ for (var i = this.index + 1; i < this.length; ++i) {
+ var ch = this.source[i];
+ if (ch === '8' || ch === '9') {
+ return false;
+ }
+ if (!character_1.Character.isOctalDigit(ch.charCodeAt(0))) {
+ return true;
+ }
+ }
+ return true;
+ };
+ Scanner.prototype.scanNumericLiteral = function () {
+ var start = this.index;
+ var ch = this.source[start];
+ assert_1.assert(character_1.Character.isDecimalDigit(ch.charCodeAt(0)) || (ch === '.'), 'Numeric literal must start with a decimal digit or a decimal point');
+ var num = '';
+ if (ch !== '.') {
+ num = this.source[this.index++];
+ ch = this.source[this.index];
+ // Hex number starts with '0x'.
+ // Octal number starts with '0'.
+ // Octal number in ES6 starts with '0o'.
+ // Binary number in ES6 starts with '0b'.
+ if (num === '0') {
+ if (ch === 'x' || ch === 'X') {
+ ++this.index;
+ return this.scanHexLiteral(start);
+ }
+ if (ch === 'b' || ch === 'B') {
+ ++this.index;
+ return this.scanBinaryLiteral(start);
+ }
+ if (ch === 'o' || ch === 'O') {
+ return this.scanOctalLiteral(ch, start);
+ }
+ if (ch && character_1.Character.isOctalDigit(ch.charCodeAt(0))) {
+ if (this.isImplicitOctalLiteral()) {
+ return this.scanOctalLiteral(ch, start);
+ }
+ }
+ }
+ while (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
+ num += this.source[this.index++];
+ }
+ ch = this.source[this.index];
+ }
+ if (ch === '.') {
+ num += this.source[this.index++];
+ while (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
+ num += this.source[this.index++];
+ }
+ ch = this.source[this.index];
+ }
+ if (ch === 'e' || ch === 'E') {
+ num += this.source[this.index++];
+ ch = this.source[this.index];
+ if (ch === '+' || ch === '-') {
+ num += this.source[this.index++];
+ }
+ if (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
+ while (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
+ num += this.source[this.index++];
+ }
+ }
+ else {
+ this.throwUnexpectedToken();
+ }
+ }
+ if (character_1.Character.isIdentifierStart(this.source.charCodeAt(this.index))) {
+ this.throwUnexpectedToken();
+ }
+ return {
+ type: 6 /* NumericLiteral */,
+ value: parseFloat(num),
+ lineNumber: this.lineNumber,
+ lineStart: this.lineStart,
+ start: start,
+ end: this.index
+ };
+ };
+ // https://tc39.github.io/ecma262/#sec-literals-string-literals
+ Scanner.prototype.scanStringLiteral = function () {
+ var start = this.index;
+ var quote = this.source[start];
+ assert_1.assert((quote === '\'' || quote === '"'), 'String literal must starts with a quote');
+ ++this.index;
+ var octal = false;
+ var str = '';
+ while (!this.eof()) {
+ var ch = this.source[this.index++];
+ if (ch === quote) {
+ quote = '';
+ break;
+ }
+ else if (ch === '\\') {
+ ch = this.source[this.index++];
+ if (!ch || !character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
+ switch (ch) {
+ case 'u':
+ if (this.source[this.index] === '{') {
+ ++this.index;
+ str += this.scanUnicodeCodePointEscape();
+ }
+ else {
+ var unescaped_1 = this.scanHexEscape(ch);
+ if (unescaped_1 === null) {
+ this.throwUnexpectedToken();
+ }
+ str += unescaped_1;
+ }
+ break;
+ case 'x':
+ var unescaped = this.scanHexEscape(ch);
+ if (unescaped === null) {
+ this.throwUnexpectedToken(messages_1.Messages.InvalidHexEscapeSequence);
+ }
+ str += unescaped;
+ break;
+ case 'n':
+ str += '\n';
+ break;
+ case 'r':
+ str += '\r';
+ break;
+ case 't':
+ str += '\t';
+ break;
+ case 'b':
+ str += '\b';
+ break;
+ case 'f':
+ str += '\f';
+ break;
+ case 'v':
+ str += '\x0B';
+ break;
+ case '8':
+ case '9':
+ str += ch;
+ this.tolerateUnexpectedToken();
+ break;
+ default:
+ if (ch && character_1.Character.isOctalDigit(ch.charCodeAt(0))) {
+ var octToDec = this.octalToDecimal(ch);
+ octal = octToDec.octal || octal;
+ str += String.fromCharCode(octToDec.code);
+ }
+ else {
+ str += ch;
+ }
+ break;
+ }
+ }
+ else {
+ ++this.lineNumber;
+ if (ch === '\r' && this.source[this.index] === '\n') {
+ ++this.index;
+ }
+ this.lineStart = this.index;
+ }
+ }
+ else if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
+ break;
+ }
+ else {
+ str += ch;
+ }
+ }
+ if (quote !== '') {
+ this.index = start;
+ this.throwUnexpectedToken();
+ }
+ return {
+ type: 8 /* StringLiteral */,
+ value: str,
+ octal: octal,
+ lineNumber: this.lineNumber,
+ lineStart: this.lineStart,
+ start: start,
+ end: this.index
+ };
+ };
+ // https://tc39.github.io/ecma262/#sec-template-literal-lexical-components
+ Scanner.prototype.scanTemplate = function () {
+ var cooked = '';
+ var terminated = false;
+ var start = this.index;
+ var head = (this.source[start] === '`');
+ var tail = false;
+ var rawOffset = 2;
+ ++this.index;
+ while (!this.eof()) {
+ var ch = this.source[this.index++];
+ if (ch === '`') {
+ rawOffset = 1;
+ tail = true;
+ terminated = true;
+ break;
+ }
+ else if (ch === '$') {
+ if (this.source[this.index] === '{') {
+ this.curlyStack.push('${');
+ ++this.index;
+ terminated = true;
+ break;
+ }
+ cooked += ch;
+ }
+ else if (ch === '\\') {
+ ch = this.source[this.index++];
+ if (!character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
+ switch (ch) {
+ case 'n':
+ cooked += '\n';
+ break;
+ case 'r':
+ cooked += '\r';
+ break;
+ case 't':
+ cooked += '\t';
+ break;
+ case 'u':
+ if (this.source[this.index] === '{') {
+ ++this.index;
+ cooked += this.scanUnicodeCodePointEscape();
+ }
+ else {
+ var restore = this.index;
+ var unescaped_2 = this.scanHexEscape(ch);
+ if (unescaped_2 !== null) {
+ cooked += unescaped_2;
+ }
+ else {
+ this.index = restore;
+ cooked += ch;
+ }
+ }
+ break;
+ case 'x':
+ var unescaped = this.scanHexEscape(ch);
+ if (unescaped === null) {
+ this.throwUnexpectedToken(messages_1.Messages.InvalidHexEscapeSequence);
+ }
+ cooked += unescaped;
+ break;
+ case 'b':
+ cooked += '\b';
+ break;
+ case 'f':
+ cooked += '\f';
+ break;
+ case 'v':
+ cooked += '\v';
+ break;
+ default:
+ if (ch === '0') {
+ if (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
+ // Illegal: \01 \02 and so on
+ this.throwUnexpectedToken(messages_1.Messages.TemplateOctalLiteral);
+ }
+ cooked += '\0';
+ }
+ else if (character_1.Character.isOctalDigit(ch.charCodeAt(0))) {
+ // Illegal: \1 \2
+ this.throwUnexpectedToken(messages_1.Messages.TemplateOctalLiteral);
+ }
+ else {
+ cooked += ch;
+ }
+ break;
+ }
+ }
+ else {
+ ++this.lineNumber;
+ if (ch === '\r' && this.source[this.index] === '\n') {
+ ++this.index;
+ }
+ this.lineStart = this.index;
+ }
+ }
+ else if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
+ ++this.lineNumber;
+ if (ch === '\r' && this.source[this.index] === '\n') {
+ ++this.index;
+ }
+ this.lineStart = this.index;
+ cooked += '\n';
+ }
+ else {
+ cooked += ch;
+ }
+ }
+ if (!terminated) {
+ this.throwUnexpectedToken();
+ }
+ if (!head) {
+ this.curlyStack.pop();
+ }
+ return {
+ type: 10 /* Template */,
+ value: this.source.slice(start + 1, this.index - rawOffset),
+ cooked: cooked,
+ head: head,
+ tail: tail,
+ lineNumber: this.lineNumber,
+ lineStart: this.lineStart,
+ start: start,
+ end: this.index
+ };
+ };
+ // https://tc39.github.io/ecma262/#sec-literals-regular-expression-literals
+ Scanner.prototype.testRegExp = function (pattern, flags) {
+ // The BMP character to use as a replacement for astral symbols when
+ // translating an ES6 "u"-flagged pattern to an ES5-compatible
+ // approximation.
+ // Note: replacing with '\uFFFF' enables false positives in unlikely
+ // scenarios. For example, `[\u{1044f}-\u{10440}]` is an invalid
+ // pattern that would not be detected by this substitution.
+ var astralSubstitute = '\uFFFF';
+ var tmp = pattern;
+ var self = this;
+ if (flags.indexOf('u') >= 0) {
+ tmp = tmp
+ .replace(/\\u\{([0-9a-fA-F]+)\}|\\u([a-fA-F0-9]{4})/g, function ($0, $1, $2) {
+ var codePoint = parseInt($1 || $2, 16);
+ if (codePoint > 0x10FFFF) {
+ self.throwUnexpectedToken(messages_1.Messages.InvalidRegExp);
+ }
+ if (codePoint <= 0xFFFF) {
+ return String.fromCharCode(codePoint);
+ }
+ return astralSubstitute;
+ })
+ .replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, astralSubstitute);
+ }
+ // First, detect invalid regular expressions.
+ try {
+ RegExp(tmp);
+ }
+ catch (e) {
+ this.throwUnexpectedToken(messages_1.Messages.InvalidRegExp);
+ }
+ // Return a regular expression object for this pattern-flag pair, or
+ // `null` in case the current environment doesn't support the flags it
+ // uses.
+ try {
+ return new RegExp(pattern, flags);
+ }
+ catch (exception) {
+ /* istanbul ignore next */
+ return null;
+ }
+ };
+ Scanner.prototype.scanRegExpBody = function () {
+ var ch = this.source[this.index];
+ assert_1.assert(ch === '/', 'Regular expression literal must start with a slash');
+ var str = this.source[this.index++];
+ var classMarker = false;
+ var terminated = false;
+ while (!this.eof()) {
+ ch = this.source[this.index++];
+ str += ch;
+ if (ch === '\\') {
+ ch = this.source[this.index++];
+ // https://tc39.github.io/ecma262/#sec-literals-regular-expression-literals
+ if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
+ this.throwUnexpectedToken(messages_1.Messages.UnterminatedRegExp);
+ }
+ str += ch;
+ }
+ else if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
+ this.throwUnexpectedToken(messages_1.Messages.UnterminatedRegExp);
+ }
+ else if (classMarker) {
+ if (ch === ']') {
+ classMarker = false;
+ }
+ }
+ else {
+ if (ch === '/') {
+ terminated = true;
+ break;
+ }
+ else if (ch === '[') {
+ classMarker = true;
+ }
+ }
+ }
+ if (!terminated) {
+ this.throwUnexpectedToken(messages_1.Messages.UnterminatedRegExp);
+ }
+ // Exclude leading and trailing slash.
+ return str.substr(1, str.length - 2);
+ };
+ Scanner.prototype.scanRegExpFlags = function () {
+ var str = '';
+ var flags = '';
+ while (!this.eof()) {
+ var ch = this.source[this.index];
+ if (!character_1.Character.isIdentifierPart(ch.charCodeAt(0))) {
+ break;
+ }
+ ++this.index;
+ if (ch === '\\' && !this.eof()) {
+ ch = this.source[this.index];
+ if (ch === 'u') {
+ ++this.index;
+ var restore = this.index;
+ var char = this.scanHexEscape('u');
+ if (char !== null) {
+ flags += char;
+ for (str += '\\u'; restore < this.index; ++restore) {
+ str += this.source[restore];
+ }
+ }
+ else {
+ this.index = restore;
+ flags += 'u';
+ str += '\\u';
+ }
+ this.tolerateUnexpectedToken();
+ }
+ else {
+ str += '\\';
+ this.tolerateUnexpectedToken();
+ }
+ }
+ else {
+ flags += ch;
+ str += ch;
+ }
+ }
+ return flags;
+ };
+ Scanner.prototype.scanRegExp = function () {
+ var start = this.index;
+ var pattern = this.scanRegExpBody();
+ var flags = this.scanRegExpFlags();
+ var value = this.testRegExp(pattern, flags);
+ return {
+ type: 9 /* RegularExpression */,
+ value: '',
+ pattern: pattern,
+ flags: flags,
+ regex: value,
+ lineNumber: this.lineNumber,
+ lineStart: this.lineStart,
+ start: start,
+ end: this.index
+ };
+ };
+ Scanner.prototype.lex = function () {
+ if (this.eof()) {
+ return {
+ type: 2 /* EOF */,
+ value: '',
+ lineNumber: this.lineNumber,
+ lineStart: this.lineStart,
+ start: this.index,
+ end: this.index
+ };
+ }
+ var cp = this.source.charCodeAt(this.index);
+ if (character_1.Character.isIdentifierStart(cp)) {
+ return this.scanIdentifier();
+ }
+ // Very common: ( and ) and ;
+ if (cp === 0x28 || cp === 0x29 || cp === 0x3B) {
+ return this.scanPunctuator();
+ }
+ // String literal starts with single quote (U+0027) or double quote (U+0022).
+ if (cp === 0x27 || cp === 0x22) {
+ return this.scanStringLiteral();
+ }
+ // Dot (.) U+002E can also start a floating-point number, hence the need
+ // to check the next character.
+ if (cp === 0x2E) {
+ if (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index + 1))) {
+ return this.scanNumericLiteral();
+ }
+ return this.scanPunctuator();
+ }
+ if (character_1.Character.isDecimalDigit(cp)) {
+ return this.scanNumericLiteral();
+ }
+ // Template literals start with ` (U+0060) for template head
+ // or } (U+007D) for template middle or template tail.
+ if (cp === 0x60 || (cp === 0x7D && this.curlyStack[this.curlyStack.length - 1] === '${')) {
+ return this.scanTemplate();
+ }
+ // Possible identifier start in a surrogate pair.
+ if (cp >= 0xD800 && cp < 0xDFFF) {
+ if (character_1.Character.isIdentifierStart(this.codePointAt(this.index))) {
+ return this.scanIdentifier();
+ }
+ }
+ return this.scanPunctuator();
+ };
+ return Scanner;
+ }());
+ exports.Scanner = Scanner;
+
+
+/***/ },
+/* 13 */
+/***/ function(module, exports) {
+
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.TokenName = {};
+ exports.TokenName[1 /* BooleanLiteral */] = 'Boolean';
+ exports.TokenName[2 /* EOF */] = '<end>';
+ exports.TokenName[3 /* Identifier */] = 'Identifier';
+ exports.TokenName[4 /* Keyword */] = 'Keyword';
+ exports.TokenName[5 /* NullLiteral */] = 'Null';
+ exports.TokenName[6 /* NumericLiteral */] = 'Numeric';
+ exports.TokenName[7 /* Punctuator */] = 'Punctuator';
+ exports.TokenName[8 /* StringLiteral */] = 'String';
+ exports.TokenName[9 /* RegularExpression */] = 'RegularExpression';
+ exports.TokenName[10 /* Template */] = 'Template';
+
+
+/***/ },
+/* 14 */
+/***/ function(module, exports) {
+
+ "use strict";
+ // Generated by generate-xhtml-entities.js. DO NOT MODIFY!
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.XHTMLEntities = {
+ quot: '\u0022',
+ amp: '\u0026',
+ apos: '\u0027',
+ gt: '\u003E',
+ nbsp: '\u00A0',
+ iexcl: '\u00A1',
+ cent: '\u00A2',
+ pound: '\u00A3',
+ curren: '\u00A4',
+ yen: '\u00A5',
+ brvbar: '\u00A6',
+ sect: '\u00A7',
+ uml: '\u00A8',
+ copy: '\u00A9',
+ ordf: '\u00AA',
+ laquo: '\u00AB',
+ not: '\u00AC',
+ shy: '\u00AD',
+ reg: '\u00AE',
+ macr: '\u00AF',
+ deg: '\u00B0',
+ plusmn: '\u00B1',
+ sup2: '\u00B2',
+ sup3: '\u00B3',
+ acute: '\u00B4',
+ micro: '\u00B5',
+ para: '\u00B6',
+ middot: '\u00B7',
+ cedil: '\u00B8',
+ sup1: '\u00B9',
+ ordm: '\u00BA',
+ raquo: '\u00BB',
+ frac14: '\u00BC',
+ frac12: '\u00BD',
+ frac34: '\u00BE',
+ iquest: '\u00BF',
+ Agrave: '\u00C0',
+ Aacute: '\u00C1',
+ Acirc: '\u00C2',
+ Atilde: '\u00C3',
+ Auml: '\u00C4',
+ Aring: '\u00C5',
+ AElig: '\u00C6',
+ Ccedil: '\u00C7',
+ Egrave: '\u00C8',
+ Eacute: '\u00C9',
+ Ecirc: '\u00CA',
+ Euml: '\u00CB',
+ Igrave: '\u00CC',
+ Iacute: '\u00CD',
+ Icirc: '\u00CE',
+ Iuml: '\u00CF',
+ ETH: '\u00D0',
+ Ntilde: '\u00D1',
+ Ograve: '\u00D2',
+ Oacute: '\u00D3',
+ Ocirc: '\u00D4',
+ Otilde: '\u00D5',
+ Ouml: '\u00D6',
+ times: '\u00D7',
+ Oslash: '\u00D8',
+ Ugrave: '\u00D9',
+ Uacute: '\u00DA',
+ Ucirc: '\u00DB',
+ Uuml: '\u00DC',
+ Yacute: '\u00DD',
+ THORN: '\u00DE',
+ szlig: '\u00DF',
+ agrave: '\u00E0',
+ aacute: '\u00E1',
+ acirc: '\u00E2',
+ atilde: '\u00E3',
+ auml: '\u00E4',
+ aring: '\u00E5',
+ aelig: '\u00E6',
+ ccedil: '\u00E7',
+ egrave: '\u00E8',
+ eacute: '\u00E9',
+ ecirc: '\u00EA',
+ euml: '\u00EB',
+ igrave: '\u00EC',
+ iacute: '\u00ED',
+ icirc: '\u00EE',
+ iuml: '\u00EF',
+ eth: '\u00F0',
+ ntilde: '\u00F1',
+ ograve: '\u00F2',
+ oacute: '\u00F3',
+ ocirc: '\u00F4',
+ otilde: '\u00F5',
+ ouml: '\u00F6',
+ divide: '\u00F7',
+ oslash: '\u00F8',
+ ugrave: '\u00F9',
+ uacute: '\u00FA',
+ ucirc: '\u00FB',
+ uuml: '\u00FC',
+ yacute: '\u00FD',
+ thorn: '\u00FE',
+ yuml: '\u00FF',
+ OElig: '\u0152',
+ oelig: '\u0153',
+ Scaron: '\u0160',
+ scaron: '\u0161',
+ Yuml: '\u0178',
+ fnof: '\u0192',
+ circ: '\u02C6',
+ tilde: '\u02DC',
+ Alpha: '\u0391',
+ Beta: '\u0392',
+ Gamma: '\u0393',
+ Delta: '\u0394',
+ Epsilon: '\u0395',
+ Zeta: '\u0396',
+ Eta: '\u0397',
+ Theta: '\u0398',
+ Iota: '\u0399',
+ Kappa: '\u039A',
+ Lambda: '\u039B',
+ Mu: '\u039C',
+ Nu: '\u039D',
+ Xi: '\u039E',
+ Omicron: '\u039F',
+ Pi: '\u03A0',
+ Rho: '\u03A1',
+ Sigma: '\u03A3',
+ Tau: '\u03A4',
+ Upsilon: '\u03A5',
+ Phi: '\u03A6',
+ Chi: '\u03A7',
+ Psi: '\u03A8',
+ Omega: '\u03A9',
+ alpha: '\u03B1',
+ beta: '\u03B2',
+ gamma: '\u03B3',
+ delta: '\u03B4',
+ epsilon: '\u03B5',
+ zeta: '\u03B6',
+ eta: '\u03B7',
+ theta: '\u03B8',
+ iota: '\u03B9',
+ kappa: '\u03BA',
+ lambda: '\u03BB',
+ mu: '\u03BC',
+ nu: '\u03BD',
+ xi: '\u03BE',
+ omicron: '\u03BF',
+ pi: '\u03C0',
+ rho: '\u03C1',
+ sigmaf: '\u03C2',
+ sigma: '\u03C3',
+ tau: '\u03C4',
+ upsilon: '\u03C5',
+ phi: '\u03C6',
+ chi: '\u03C7',
+ psi: '\u03C8',
+ omega: '\u03C9',
+ thetasym: '\u03D1',
+ upsih: '\u03D2',
+ piv: '\u03D6',
+ ensp: '\u2002',
+ emsp: '\u2003',
+ thinsp: '\u2009',
+ zwnj: '\u200C',
+ zwj: '\u200D',
+ lrm: '\u200E',
+ rlm: '\u200F',
+ ndash: '\u2013',
+ mdash: '\u2014',
+ lsquo: '\u2018',
+ rsquo: '\u2019',
+ sbquo: '\u201A',
+ ldquo: '\u201C',
+ rdquo: '\u201D',
+ bdquo: '\u201E',
+ dagger: '\u2020',
+ Dagger: '\u2021',
+ bull: '\u2022',
+ hellip: '\u2026',
+ permil: '\u2030',
+ prime: '\u2032',
+ Prime: '\u2033',
+ lsaquo: '\u2039',
+ rsaquo: '\u203A',
+ oline: '\u203E',
+ frasl: '\u2044',
+ euro: '\u20AC',
+ image: '\u2111',
+ weierp: '\u2118',
+ real: '\u211C',
+ trade: '\u2122',
+ alefsym: '\u2135',
+ larr: '\u2190',
+ uarr: '\u2191',
+ rarr: '\u2192',
+ darr: '\u2193',
+ harr: '\u2194',
+ crarr: '\u21B5',
+ lArr: '\u21D0',
+ uArr: '\u21D1',
+ rArr: '\u21D2',
+ dArr: '\u21D3',
+ hArr: '\u21D4',
+ forall: '\u2200',
+ part: '\u2202',
+ exist: '\u2203',
+ empty: '\u2205',
+ nabla: '\u2207',
+ isin: '\u2208',
+ notin: '\u2209',
+ ni: '\u220B',
+ prod: '\u220F',
+ sum: '\u2211',
+ minus: '\u2212',
+ lowast: '\u2217',
+ radic: '\u221A',
+ prop: '\u221D',
+ infin: '\u221E',
+ ang: '\u2220',
+ and: '\u2227',
+ or: '\u2228',
+ cap: '\u2229',
+ cup: '\u222A',
+ int: '\u222B',
+ there4: '\u2234',
+ sim: '\u223C',
+ cong: '\u2245',
+ asymp: '\u2248',
+ ne: '\u2260',
+ equiv: '\u2261',
+ le: '\u2264',
+ ge: '\u2265',
+ sub: '\u2282',
+ sup: '\u2283',
+ nsub: '\u2284',
+ sube: '\u2286',
+ supe: '\u2287',
+ oplus: '\u2295',
+ otimes: '\u2297',
+ perp: '\u22A5',
+ sdot: '\u22C5',
+ lceil: '\u2308',
+ rceil: '\u2309',
+ lfloor: '\u230A',
+ rfloor: '\u230B',
+ loz: '\u25CA',
+ spades: '\u2660',
+ clubs: '\u2663',
+ hearts: '\u2665',
+ diams: '\u2666',
+ lang: '\u27E8',
+ rang: '\u27E9'
+ };
+
+
+/***/ },
+/* 15 */
+/***/ function(module, exports, __webpack_require__) {
+
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var error_handler_1 = __webpack_require__(10);
+ var scanner_1 = __webpack_require__(12);
+ var token_1 = __webpack_require__(13);
+ var Reader = (function () {
+ function Reader() {
+ this.values = [];
+ this.curly = this.paren = -1;
+ }
+ // A function following one of those tokens is an expression.
+ Reader.prototype.beforeFunctionExpression = function (t) {
+ return ['(', '{', '[', 'in', 'typeof', 'instanceof', 'new',
+ 'return', 'case', 'delete', 'throw', 'void',
+ // assignment operators
+ '=', '+=', '-=', '*=', '**=', '/=', '%=', '<<=', '>>=', '>>>=',
+ '&=', '|=', '^=', ',',
+ // binary/unary operators
+ '+', '-', '*', '**', '/', '%', '++', '--', '<<', '>>', '>>>', '&',
+ '|', '^', '!', '~', '&&', '||', '?', ':', '===', '==', '>=',
+ '<=', '<', '>', '!=', '!=='].indexOf(t) >= 0;
+ };
+ // Determine if forward slash (/) is an operator or part of a regular expression
+ // https://github.com/mozilla/sweet.js/wiki/design
+ Reader.prototype.isRegexStart = function () {
+ var previous = this.values[this.values.length - 1];
+ var regex = (previous !== null);
+ switch (previous) {
+ case 'this':
+ case ']':
+ regex = false;
+ break;
+ case ')':
+ var keyword = this.values[this.paren - 1];
+ regex = (keyword === 'if' || keyword === 'while' || keyword === 'for' || keyword === 'with');
+ break;
+ case '}':
+ // Dividing a function by anything makes little sense,
+ // but we have to check for that.
+ regex = false;
+ if (this.values[this.curly - 3] === 'function') {
+ // Anonymous function, e.g. function(){} /42
+ var check = this.values[this.curly - 4];
+ regex = check ? !this.beforeFunctionExpression(check) : false;
+ }
+ else if (this.values[this.curly - 4] === 'function') {
+ // Named function, e.g. function f(){} /42/
+ var check = this.values[this.curly - 5];
+ regex = check ? !this.beforeFunctionExpression(check) : true;
+ }
+ break;
+ default:
+ break;
+ }
+ return regex;
+ };
+ Reader.prototype.push = function (token) {
+ if (token.type === 7 /* Punctuator */ || token.type === 4 /* Keyword */) {
+ if (token.value === '{') {
+ this.curly = this.values.length;
+ }
+ else if (token.value === '(') {
+ this.paren = this.values.length;
+ }
+ this.values.push(token.value);
+ }
+ else {
+ this.values.push(null);
+ }
+ };
+ return Reader;
+ }());
+ var Tokenizer = (function () {
+ function Tokenizer(code, config) {
+ this.errorHandler = new error_handler_1.ErrorHandler();
+ this.errorHandler.tolerant = config ? (typeof config.tolerant === 'boolean' && config.tolerant) : false;
+ this.scanner = new scanner_1.Scanner(code, this.errorHandler);
+ this.scanner.trackComment = config ? (typeof config.comment === 'boolean' && config.comment) : false;
+ this.trackRange = config ? (typeof config.range === 'boolean' && config.range) : false;
+ this.trackLoc = config ? (typeof config.loc === 'boolean' && config.loc) : false;
+ this.buffer = [];
+ this.reader = new Reader();
+ }
+ Tokenizer.prototype.errors = function () {
+ return this.errorHandler.errors;
+ };
+ Tokenizer.prototype.getNextToken = function () {
+ if (this.buffer.length === 0) {
+ var comments = this.scanner.scanComments();
+ if (this.scanner.trackComment) {
+ for (var i = 0; i < comments.length; ++i) {
+ var e = comments[i];
+ var value = this.scanner.source.slice(e.slice[0], e.slice[1]);
+ var comment = {
+ type: e.multiLine ? 'BlockComment' : 'LineComment',
+ value: value
+ };
+ if (this.trackRange) {
+ comment.range = e.range;
+ }
+ if (this.trackLoc) {
+ comment.loc = e.loc;
+ }
+ this.buffer.push(comment);
+ }
+ }
+ if (!this.scanner.eof()) {
+ var loc = void 0;
+ if (this.trackLoc) {
+ loc = {
+ start: {
+ line: this.scanner.lineNumber,
+ column: this.scanner.index - this.scanner.lineStart
+ },
+ end: {}
+ };
+ }
+ var startRegex = (this.scanner.source[this.scanner.index] === '/') && this.reader.isRegexStart();
+ var token = startRegex ? this.scanner.scanRegExp() : this.scanner.lex();
+ this.reader.push(token);
+ var entry = {
+ type: token_1.TokenName[token.type],
+ value: this.scanner.source.slice(token.start, token.end)
+ };
+ if (this.trackRange) {
+ entry.range = [token.start, token.end];
+ }
+ if (this.trackLoc) {
+ loc.end = {
+ line: this.scanner.lineNumber,
+ column: this.scanner.index - this.scanner.lineStart
+ };
+ entry.loc = loc;
+ }
+ if (token.type === 9 /* RegularExpression */) {
+ var pattern = token.pattern;
+ var flags = token.flags;
+ entry.regex = { pattern: pattern, flags: flags };
+ }
+ this.buffer.push(entry);
+ }
+ }
+ return this.buffer.shift();
+ };
+ return Tokenizer;
+ }());
+ exports.Tokenizer = Tokenizer;
+
+
+/***/ }
+/******/ ])
+});
+;
+
+/***/ }),
+/* 122 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+/*eslint-disable no-use-before-define*/
+
+var common = __webpack_require__(15);
+var YAMLException = __webpack_require__(20);
+var DEFAULT_FULL_SCHEMA = __webpack_require__(25);
+var DEFAULT_SAFE_SCHEMA = __webpack_require__(21);
+
+var _toString = Object.prototype.toString;
+var _hasOwnProperty = Object.prototype.hasOwnProperty;
var CHAR_TAB = 0x09; /* Tab */
var CHAR_LINE_FEED = 0x0A; /* LF */
@@ -3163,7 +18904,7 @@ function compileStyleMap(schema, map) {
}
type = schema.compiledTypeMap['fallback'][tag];
- if (type && _hasOwnProperty$3.call(type.styleAliases, style)) {
+ if (type && _hasOwnProperty.call(type.styleAliases, style)) {
style = type.styleAliases[style];
}
@@ -3188,14 +18929,14 @@ function encodeHex(character) {
handle = 'U';
length = 8;
} else {
- throw new exception('code point within a string may not be greater than 0xFFFFFFFF');
+ throw new YAMLException('code point within a string may not be greater than 0xFFFFFFFF');
}
return '\\' + handle + common.repeat('0', length - string.length) + string;
}
-function State$1(options) {
- this.schema = options['schema'] || default_full;
+function State(options) {
+ this.schema = options['schema'] || DEFAULT_FULL_SCHEMA;
this.indent = Math.max(1, (options['indent'] || 2));
this.skipInvalid = options['skipInvalid'] || false;
this.flowLevel = (common.isNothing(options['flowLevel']) ? -1 : options['flowLevel']);
@@ -3330,11 +19071,11 @@ function needIndentIndicator(string) {
return leadingSpaceRe.test(string);
}
-var STYLE_PLAIN = 1;
-var STYLE_SINGLE = 2;
-var STYLE_LITERAL = 3;
-var STYLE_FOLDED = 4;
-var STYLE_DOUBLE = 5;
+var STYLE_PLAIN = 1,
+ STYLE_SINGLE = 2,
+ STYLE_LITERAL = 3,
+ STYLE_FOLDED = 4,
+ STYLE_DOUBLE = 5;
// Determines which scalar styles are possible and returns the preferred style.
// lineWidth = -1 => no limit.
@@ -3454,7 +19195,7 @@ function writeScalar(state, string, level, iskey) {
case STYLE_DOUBLE:
return '"' + escapeString(string, lineWidth) + '"';
default:
- throw new exception('impossible error: invalid scalar style');
+ throw new YAMLException('impossible error: invalid scalar style');
}
}());
}
@@ -3686,7 +19427,7 @@ function writeBlockMapping(state, level, object, compact) {
objectKeyList.sort(state.sortKeys);
} else if (state.sortKeys) {
// Something is wrong
- throw new exception('sortKeys must be a boolean or a function');
+ throw new YAMLException('sortKeys must be a boolean or a function');
}
for (index = 0, length = objectKeyList.length; index < length; index += 1) {
@@ -3757,12 +19498,12 @@ function detectType(state, object, explicit) {
if (type.represent) {
style = state.styleMap[type.tag] || type.defaultStyle;
- if (_toString$2.call(type.represent) === '[object Function]') {
+ if (_toString.call(type.represent) === '[object Function]') {
_result = type.represent(object, style);
- } else if (_hasOwnProperty$3.call(type.represent, style)) {
+ } else if (_hasOwnProperty.call(type.represent, style)) {
_result = type.represent[style](object, style);
} else {
- throw new exception('!<' + type.tag + '> tag resolver accepts not "' + style + '" style');
+ throw new YAMLException('!<' + type.tag + '> tag resolver accepts not "' + style + '" style');
}
state.dump = _result;
@@ -3786,7 +19527,7 @@ function writeNode(state, level, object, block, compact, iskey) {
detectType(state, object, true);
}
- var type = _toString$2.call(state.dump);
+ var type = _toString.call(state.dump);
if (block) {
block = (state.flowLevel < 0 || state.flowLevel > level);
@@ -3841,7 +19582,7 @@ function writeNode(state, level, object, block, compact, iskey) {
}
} else {
if (state.skipInvalid) return false;
- throw new exception('unacceptable kind of an object to dump ' + type);
+ throw new YAMLException('unacceptable kind of an object to dump ' + type);
}
if (state.tag !== null && state.tag !== '?') {
@@ -3898,7 +19639,7 @@ function inspectNode(object, objects, duplicatesIndexes) {
function dump(input, options) {
options = options || {};
- var state = new State$1(options);
+ var state = new State(options);
if (!state.noRefs) getDuplicateReferences(input, state);
@@ -3908,84 +19649,22 @@ function dump(input, options) {
}
function safeDump(input, options) {
- return dump(input, common.extend({ schema: default_safe }, options));
-}
-
-var dump_1 = dump;
-var safeDump_1 = safeDump;
-
-var dumper = {
- dump: dump_1,
- safeDump: safeDump_1
-};
-
-function deprecated(name) {
- return function () {
- throw new Error('Function ' + name + ' is deprecated and cannot be used.');
- };
+ return dump(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options));
}
+module.exports.dump = dump;
+module.exports.safeDump = safeDump;
-var Type$2 = type;
-var Schema$2 = schema;
-var FAILSAFE_SCHEMA = failsafe;
-var JSON_SCHEMA = json;
-var CORE_SCHEMA = core;
-var DEFAULT_SAFE_SCHEMA$1 = default_safe;
-var DEFAULT_FULL_SCHEMA$1 = default_full;
-var load$1 = loader.load;
-var loadAll$1 = loader.loadAll;
-var safeLoad$1 = loader.safeLoad;
-var safeLoadAll$1 = loader.safeLoadAll;
-var dump$1 = dumper.dump;
-var safeDump$1 = dumper.safeDump;
-var YAMLException$2 = exception;
-// Deprecated schema names from JS-YAML 2.0.x
-var MINIMAL_SCHEMA = failsafe;
-var SAFE_SCHEMA = default_safe;
-var DEFAULT_SCHEMA = default_full;
-
-// Deprecated functions from JS-YAML 1.x.x
-var scan = deprecated('scan');
-var parse = deprecated('parse');
-var compose = deprecated('compose');
-var addConstructor = deprecated('addConstructor');
-
-var jsYaml = {
- Type: Type$2,
- Schema: Schema$2,
- FAILSAFE_SCHEMA: FAILSAFE_SCHEMA,
- JSON_SCHEMA: JSON_SCHEMA,
- CORE_SCHEMA: CORE_SCHEMA,
- DEFAULT_SAFE_SCHEMA: DEFAULT_SAFE_SCHEMA$1,
- DEFAULT_FULL_SCHEMA: DEFAULT_FULL_SCHEMA$1,
- load: load$1,
- loadAll: loadAll$1,
- safeLoad: safeLoad$1,
- safeLoadAll: safeLoadAll$1,
- dump: dump$1,
- safeDump: safeDump$1,
- YAMLException: YAMLException$2,
- MINIMAL_SCHEMA: MINIMAL_SCHEMA,
- SAFE_SCHEMA: SAFE_SCHEMA,
- DEFAULT_SCHEMA: DEFAULT_SCHEMA,
- scan: scan,
- parse: parse,
- compose: compose,
- addConstructor: addConstructor
-};
+/***/ }),
+/* 123 */
+/***/ (function(module, exports, __webpack_require__) {
-var jsYaml$2 = jsYaml;
+"use strict";
-var isArrayish = function isArrayish(obj) {
- if (!obj) {
- return false;
- }
- return obj instanceof Array || Array.isArray(obj) ||
- (obj.length >= 0 && obj.splice instanceof Function);
-};
+var util = __webpack_require__(11);
+var isArrayish = __webpack_require__(124);
var errorEx = function errorEx(name, properties) {
if (!name || name.constructor !== String) {
@@ -4122,488 +19801,78 @@ errorEx.line = function (str, def) {
};
};
-var errorEx_1 = errorEx;
+module.exports = errorEx;
+
+
+/***/ }),
+/* 124 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+module.exports = function isArrayish(obj) {
+ if (!obj) {
+ return false;
+ }
+
+ return obj instanceof Array || Array.isArray(obj) ||
+ (obj.length >= 0 && obj.splice instanceof Function);
+};
+
+
+/***/ }),
+/* 125 */
+/***/ (function(module, exports, __webpack_require__) {
-var jsonParseBetterErrors = parseJson;
+"use strict";
+
+
+module.exports = parseJson
function parseJson (txt, reviver, context) {
- context = context || 20;
+ context = context || 20
try {
return JSON.parse(txt, reviver)
} catch (e) {
if (typeof txt !== 'string') {
- const isEmptyArray = Array.isArray(txt) && txt.length === 0;
+ const isEmptyArray = Array.isArray(txt) && txt.length === 0
const errorMessage = 'Cannot parse ' +
- (isEmptyArray ? 'an empty array' : String(txt));
+ (isEmptyArray ? 'an empty array' : String(txt))
throw new TypeError(errorMessage)
}
- const syntaxErr = e.message.match(/^Unexpected token.*position\s+(\d+)/i);
+ const syntaxErr = e.message.match(/^Unexpected token.*position\s+(\d+)/i)
const errIdx = syntaxErr
? +syntaxErr[1]
: e.message.match(/^Unexpected end of JSON.*/i)
? txt.length - 1
- : null;
+ : null
if (errIdx != null) {
const start = errIdx <= context
? 0
- : errIdx - context;
+ : errIdx - context
const end = errIdx + context >= txt.length
? txt.length
- : errIdx + context;
+ : errIdx + context
e.message += ` while parsing near '${
start === 0 ? '' : '...'
}${txt.slice(start, end)}${
end === txt.length ? '' : '...'
- }'`;
+ }'`
} else {
- e.message += ` while parsing '${txt.slice(0, context * 2)}'`;
+ e.message += ` while parsing '${txt.slice(0, context * 2)}'`
}
throw e
}
}
-var parseJson$1 = createCommonjsModule(function (module) {
-const JSONError = errorEx_1('JSONError', {
- fileName: errorEx_1.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) {
- jsonParseBetterErrors(input, reviver);
- throw err;
- }
- } catch (err) {
- err.message = err.message.replace(/\n/g, '');
+/***/ }),
+/* 126 */
+/***/ (function(module, exports, __webpack_require__) {
- const jsonErr = new JSONError(err);
- if (filename) {
- jsonErr.fileName = filename;
- }
+"use strict";
- throw jsonErr;
- }
-};
-});
-/**
- * Helpers.
- */
-
-var s = 1000;
-var m = s * 60;
-var h = m * 60;
-var d = h * 24;
-var w = d * 7;
-var y = d * 365.25;
-
-/**
- * Parse or format the given `val`.
- *
- * Options:
- *
- * - `long` verbose formatting [false]
- *
- * @param {String|Number} val
- * @param {Object} [options]
- * @throws {Error} throw an error if val is not a non-empty string or a number
- * @return {String|Number}
- * @api public
- */
-
-var ms = function(val, options) {
- options = options || {};
- var type = typeof val;
- if (type === 'string' && val.length > 0) {
- return parse$1(val);
- } else if (type === 'number' && isNaN(val) === false) {
- return options.long ? fmtLong(val) : fmtShort(val);
- }
- throw new Error(
- 'val is not a non-empty string or a valid number. val=' +
- JSON.stringify(val)
- );
-};
-
-/**
- * Parse the given `str` and return milliseconds.
- *
- * @param {String} str
- * @return {Number}
- * @api private
- */
-
-function parse$1(str) {
- str = String(str);
- if (str.length > 100) {
- return;
- }
- var match = /^((?:\d+)?\-?\d?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
- str
- );
- if (!match) {
- return;
- }
- var n = parseFloat(match[1]);
- var type = (match[2] || 'ms').toLowerCase();
- switch (type) {
- case 'years':
- case 'year':
- case 'yrs':
- case 'yr':
- case 'y':
- return n * y;
- case 'weeks':
- case 'week':
- case 'w':
- return n * w;
- case 'days':
- case 'day':
- case 'd':
- return n * d;
- case 'hours':
- case 'hour':
- case 'hrs':
- case 'hr':
- case 'h':
- return n * h;
- case 'minutes':
- case 'minute':
- case 'mins':
- case 'min':
- case 'm':
- return n * m;
- case 'seconds':
- case 'second':
- case 'secs':
- case 'sec':
- case 's':
- return n * s;
- case 'milliseconds':
- case 'millisecond':
- case 'msecs':
- case 'msec':
- case 'ms':
- return n;
- default:
- return undefined;
- }
-}
-
-/**
- * Short format for `ms`.
- *
- * @param {Number} ms
- * @return {String}
- * @api private
- */
-
-function fmtShort(ms) {
- var msAbs = Math.abs(ms);
- if (msAbs >= d) {
- return Math.round(ms / d) + 'd';
- }
- if (msAbs >= h) {
- return Math.round(ms / h) + 'h';
- }
- if (msAbs >= m) {
- return Math.round(ms / m) + 'm';
- }
- if (msAbs >= s) {
- return Math.round(ms / s) + 's';
- }
- return ms + 'ms';
-}
-
-/**
- * Long format for `ms`.
- *
- * @param {Number} ms
- * @return {String}
- * @api private
- */
-
-function fmtLong(ms) {
- var msAbs = Math.abs(ms);
- if (msAbs >= d) {
- return plural(ms, msAbs, d, 'day');
- }
- if (msAbs >= h) {
- return plural(ms, msAbs, h, 'hour');
- }
- if (msAbs >= m) {
- return plural(ms, msAbs, m, 'minute');
- }
- if (msAbs >= s) {
- return plural(ms, msAbs, s, 'second');
- }
- return ms + ' ms';
-}
-
-/**
- * Pluralization helper.
- */
-
-function plural(ms, msAbs, n, name) {
- var isPlural = msAbs >= n * 1.5;
- return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
-}
-
-/**
- * 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 = ms;
- 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$$1 = curr - (prevTime || curr);
- self.diff = ms$$1;
- 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;
-}
-
-var common$3 = setup;
-
-var browser = createCommonjsModule(function (module, exports) {
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
/* eslint-env browser */
@@ -4768,7 +20037,7 @@ function localstorage() {
}
}
-module.exports = common$3(exports);
+module.exports = __webpack_require__(52)(exports);
var formatters = module.exports.formatters;
/**
* Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
@@ -4781,141 +20050,195 @@ formatters.j = function (v) {
return '[UnexpectedJSONParseError]: ' + error.message;
}
};
-});
-var browser_1 = browser.log;
-var browser_2 = browser.formatArgs;
-var browser_3 = browser.save;
-var browser_4 = browser.load;
-var browser_5 = browser.useColors;
-var browser_6 = browser.storage;
-var browser_7 = browser.colors;
-var hasFlag = function (flag, argv) {
- argv = argv || process.argv;
- var terminatorPos = argv.indexOf('--');
- var prefix = /^-{1,2}/.test(flag) ? '' : '--';
- var pos = argv.indexOf(prefix + flag);
+/***/ }),
+/* 127 */
+/***/ (function(module, exports) {
- return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
-};
+/**
+ * Helpers.
+ */
-var supportsColor = createCommonjsModule(function (module) {
-const env = process.env;
+var s = 1000;
+var m = s * 60;
+var h = m * 60;
+var d = h * 24;
+var w = d * 7;
+var y = d * 365.25;
-const support = level => {
- if (level === 0) {
- return false;
- }
+/**
+ * Parse or format the given `val`.
+ *
+ * Options:
+ *
+ * - `long` verbose formatting [false]
+ *
+ * @param {String|Number} val
+ * @param {Object} [options]
+ * @throws {Error} throw an error if val is not a non-empty string or a number
+ * @return {String|Number}
+ * @api public
+ */
- return {
- level,
- hasBasic: true,
- has256: level >= 2,
- has16m: level >= 3
- };
+module.exports = function(val, options) {
+ options = options || {};
+ var type = typeof val;
+ if (type === 'string' && val.length > 0) {
+ return parse(val);
+ } else if (type === 'number' && isNaN(val) === false) {
+ return options.long ? fmtLong(val) : fmtShort(val);
+ }
+ throw new Error(
+ 'val is not a non-empty string or a valid number. val=' +
+ JSON.stringify(val)
+ );
};
-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;
- }
+/**
+ * Parse the given `str` and return milliseconds.
+ *
+ * @param {String} str
+ * @return {Number}
+ * @api private
+ */
- 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;
- }
+function parse(str) {
+ str = String(str);
+ if (str.length > 100) {
+ return;
+ }
+ var match = /^((?:\d+)?\-?\d?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+ str
+ );
+ if (!match) {
+ return;
+ }
+ var n = parseFloat(match[1]);
+ var type = (match[2] || 'ms').toLowerCase();
+ switch (type) {
+ case 'years':
+ case 'year':
+ case 'yrs':
+ case 'yr':
+ case 'y':
+ return n * y;
+ case 'weeks':
+ case 'week':
+ case 'w':
+ return n * w;
+ case 'days':
+ case 'day':
+ case 'd':
+ return n * d;
+ case 'hours':
+ case 'hour':
+ case 'hrs':
+ case 'hr':
+ case 'h':
+ return n * h;
+ case 'minutes':
+ case 'minute':
+ case 'mins':
+ case 'min':
+ case 'm':
+ return n * m;
+ case 'seconds':
+ case 'second':
+ case 'secs':
+ case 'sec':
+ case 's':
+ return n * s;
+ case 'milliseconds':
+ case 'millisecond':
+ case 'msecs':
+ case 'msec':
+ case 'ms':
+ return n;
+ default:
+ return undefined;
+ }
+}
- return 1;
- }
+/**
+ * Short format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
- if ('CI' in env) {
- if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
- return 1;
- }
+function fmtShort(ms) {
+ var msAbs = Math.abs(ms);
+ if (msAbs >= d) {
+ return Math.round(ms / d) + 'd';
+ }
+ if (msAbs >= h) {
+ return Math.round(ms / h) + 'h';
+ }
+ if (msAbs >= m) {
+ return Math.round(ms / m) + 'm';
+ }
+ if (msAbs >= s) {
+ return Math.round(ms / s) + 's';
+ }
+ return ms + 'ms';
+}
- return 0;
- }
+/**
+ * Long format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
- if ('TEAMCITY_VERSION' in env) {
- return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
- }
+function fmtLong(ms) {
+ var msAbs = Math.abs(ms);
+ if (msAbs >= d) {
+ return plural(ms, msAbs, d, 'day');
+ }
+ if (msAbs >= h) {
+ return plural(ms, msAbs, h, 'hour');
+ }
+ if (msAbs >= m) {
+ return plural(ms, msAbs, m, 'minute');
+ }
+ if (msAbs >= s) {
+ return plural(ms, msAbs, s, 'second');
+ }
+ return ms + ' ms';
+}
- if ('TERM_PROGRAM' in env) {
- const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+/**
+ * Pluralization helper.
+ */
- switch (env.TERM_PROGRAM) {
- case 'iTerm.app':
- return version >= 3 ? 3 : 2;
- case 'Hyper':
- return 3;
- case 'Apple_Terminal':
- return 2;
- // No default
- }
- }
+function plural(ms, msAbs, n, name) {
+ var isPlural = msAbs >= n * 1.5;
+ return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
+}
- if (/-256(color)?$/i.test(env.TERM)) {
- return 2;
- }
- if (/^screen|^xterm|^vt100|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
- return 1;
- }
+/***/ }),
+/* 128 */
+/***/ (function(module, exports, __webpack_require__) {
- if ('COLORTERM' in env) {
- return 1;
- }
+"use strict";
- if (env.TERM === 'dumb') {
- return 0;
- }
- return 0;
-})();
+/**
+ * Module dependencies.
+ */
+var tty = __webpack_require__(129);
-if ('FORCE_COLOR' in env) {
- supportLevel = parseInt(env.FORCE_COLOR, 10) === 0 ? 0 : (supportLevel || 1);
-}
+var util = __webpack_require__(11);
+/**
+ * This is the Node.js implementation of `debug()`.
+ */
-module.exports = process && support(supportLevel);
-});
-var node = createCommonjsModule(function (module, exports) {
exports.init = init;
exports.log = log;
exports.formatArgs = formatArgs;
@@ -4931,9 +20254,9 @@ exports.colors = [6, 2, 3, 4, 5, 1];
try {
// Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json)
// eslint-disable-next-line import/no-extraneous-dependencies
- var supportsColor$$1 = supportsColor;
+ var supportsColor = __webpack_require__(53);
- if (supportsColor$$1 && (supportsColor$$1.stderr || supportsColor$$1).level >= 2) {
+ if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
exports.colors = [20, 21, 26, 27, 32, 33, 38, 39, 40, 41, 42, 43, 44, 45, 56, 57, 62, 63, 68, 69, 74, 75, 76, 77, 78, 79, 80, 81, 92, 93, 98, 99, 112, 113, 128, 129, 134, 135, 148, 149, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 178, 179, 184, 185, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 214, 215, 220, 221];
}
} catch (error) {} // Swallow - we only care if `supports-color` is available; it doesn't have to be.
@@ -5057,7 +20380,7 @@ function init(debug) {
}
}
-module.exports = common$3(exports);
+module.exports = __webpack_require__(52)(exports);
var formatters = module.exports.formatters;
/**
* Map %o to `util.inspect()`, all on a single line.
@@ -5076,26 +20399,42 @@ formatters.O = function (v) {
this.inspectOpts.colors = this.useColors;
return util.inspect(v, this.inspectOpts);
};
-});
-var node_1 = node.init;
-var node_2 = node.log;
-var node_3 = node.formatArgs;
-var node_4 = node.save;
-var node_5 = node.load;
-var node_6 = node.useColors;
-var node_7 = node.colors;
-var node_8 = node.inspectOpts;
-var src = createCommonjsModule(function (module) {
-if (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) {
- module.exports = browser;
-} else {
- module.exports = node;
-}
-});
-var resolveFrom_1 = createCommonjsModule(function (module) {
+/***/ }),
+/* 129 */
+/***/ (function(module, exports) {
+
+module.exports = require("tty");
+
+/***/ }),
+/* 130 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+module.exports = function (flag, argv) {
+ argv = argv || process.argv;
+
+ var terminatorPos = argv.indexOf('--');
+ var prefix = /^-{1,2}/.test(flag) ? '' : '--';
+ var pos = argv.indexOf(prefix + flag);
+
+ return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
+};
+
+
+/***/ }),
+/* 131 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+const path = __webpack_require__(4);
+const Module = __webpack_require__(47);
+const fs = __webpack_require__(6);
+
const resolveFrom = (fromDir, moduleId, silent) => {
if (typeof fromDir !== 'string') {
throw new TypeError(`Expected \`fromDir\` to be of type \`string\`, got \`${typeof fromDir}\``);
@@ -5119,10 +20458,10 @@ const resolveFrom = (fromDir, moduleId, silent) => {
const fromFile = path.join(fromDir, 'noop.js');
- const resolveFileName = () => module$1._resolveFilename(moduleId, {
+ const resolveFileName = () => Module._resolveFilename(moduleId, {
id: fromFile,
filename: fromFile,
- paths: module$1._nodeModulePaths(fromDir)
+ paths: Module._nodeModulePaths(fromDir)
});
if (silent) {
@@ -5138,66 +20477,266 @@ const resolveFrom = (fromDir, moduleId, silent) => {
module.exports = (fromDir, moduleId) => resolveFrom(fromDir, moduleId);
module.exports.silent = (fromDir, moduleId) => resolveFrom(fromDir, moduleId, true);
-});
-var resolveFrom_2 = resolveFrom_1.silent;
-var ini = createCommonjsModule(function (module, exports) {
-exports.parse = exports.decode = decode;
+/***/ }),
+/* 132 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var rc = __webpack_require__(133),
+ untildify = __webpack_require__(138),
+ substitute = __webpack_require__(140);
+
+var path = __webpack_require__(4);
+
+
+module.exports = function () {
+ var rcPrefix = rc('npm', null, []).prefix;
+
+ if (rcPrefix) {
+ return untildify(substitute(rcPrefix, process.env));
+ }
+ else if (process.platform == 'win32') {
+ return path.dirname(process.execPath);
+ }
+ else {
+ return path.resolve(process.execPath, '../..');
+ }
+};
+
+
+/***/ }),
+/* 133 */
+/***/ (function(module, exports, __webpack_require__) {
+
+var cc = __webpack_require__(134)
+var join = __webpack_require__(4).join
+var deepExtend = __webpack_require__(137)
+var etc = '/etc'
+var win = process.platform === "win32"
+var home = win
+ ? process.env.USERPROFILE
+ : process.env.HOME
+
+module.exports = function (name, defaults, argv, parse) {
+ if('string' !== typeof name)
+ throw new Error('rc(name): name *must* be string')
+ if(!argv)
+ argv = __webpack_require__(56)(process.argv.slice(2))
+ defaults = (
+ 'string' === typeof defaults
+ ? cc.json(defaults) : defaults
+ ) || {}
+
+ parse = parse || cc.parse
+
+ var env = cc.env(name + '_')
+
+ var configs = [defaults]
+ var configFiles = []
+ function addConfigFile (file) {
+ if (configFiles.indexOf(file) >= 0) return
+ var fileConfig = cc.file(file)
+ if (fileConfig) {
+ configs.push(parse(fileConfig))
+ configFiles.push(file)
+ }
+ }
+
+ // which files do we look at?
+ if (!win)
+ [join(etc, name, 'config'),
+ join(etc, name + 'rc')].forEach(addConfigFile)
+ if (home)
+ [join(home, '.config', name, 'config'),
+ join(home, '.config', name),
+ join(home, '.' + name, 'config'),
+ join(home, '.' + name + 'rc')].forEach(addConfigFile)
+ addConfigFile(cc.find('.'+name+'rc'))
+ if (env.config) addConfigFile(env.config)
+ if (argv.config) addConfigFile(argv.config)
+
+ return deepExtend.apply(null, configs.concat([
+ env,
+ argv,
+ configFiles.length ? {configs: configFiles, config: configFiles[configFiles.length - 1]} : undefined,
+ ]))
+}
+
+
+/***/ }),
+/* 134 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var fs = __webpack_require__(6)
+var ini = __webpack_require__(135)
+var path = __webpack_require__(4)
+var stripJsonComments = __webpack_require__(136)
+
+var parse = exports.parse = function (content) {
+
+ //if it ends in .json or starts with { then it must be json.
+ //must be done this way, because ini accepts everything.
+ //can't just try and parse it and let it throw if it's not ini.
+ //everything is ini. even json with a syntax error.
+
+ if(/^\s*{/.test(content))
+ return JSON.parse(stripJsonComments(content))
+ return ini.parse(content)
+
+}
+
+var file = exports.file = function () {
+ var args = [].slice.call(arguments).filter(function (arg) { return arg != null })
+
+ //path.join breaks if it's a not a string, so just skip this.
+ for(var i in args)
+ if('string' !== typeof args[i])
+ return
+
+ var file = path.join.apply(null, args)
+ var content
+ try {
+ return fs.readFileSync(file,'utf-8')
+ } catch (err) {
+ return
+ }
+}
-exports.stringify = exports.encode = encode;
+var json = exports.json = function () {
+ var content = file.apply(null, arguments)
+ return content ? parse(content) : null
+}
-exports.safe = safe;
-exports.unsafe = unsafe;
+var env = exports.env = function (prefix, env) {
+ env = env || process.env
+ var obj = {}
+ var l = prefix.length
+ for(var k in env) {
+ if(k.toLowerCase().indexOf(prefix.toLowerCase()) === 0) {
+
+ var keypath = k.substring(l).split('__')
+
+ // Trim empty strings from keypath array
+ var _emptyStringIndex
+ while ((_emptyStringIndex=keypath.indexOf('')) > -1) {
+ keypath.splice(_emptyStringIndex, 1)
+ }
+
+ var cursor = obj
+ keypath.forEach(function _buildSubObj(_subkey,i){
+
+ // (check for _subkey first so we ignore empty strings)
+ // (check for cursor to avoid assignment to primitive objects)
+ if (!_subkey || typeof cursor !== 'object')
+ return
+
+ // If this is the last key, just stuff the value in there
+ // Assigns actual value from env variable to final key
+ // (unless it's just an empty string- in that case use the last valid key)
+ if (i === keypath.length-1)
+ cursor[_subkey] = env[k]
+
+
+ // Build sub-object if nothing already exists at the keypath
+ if (cursor[_subkey] === undefined)
+ cursor[_subkey] = {}
+
+ // Increment cursor used to track the object at the current depth
+ cursor = cursor[_subkey]
+
+ })
+
+ }
+
+ }
+
+ return obj
+}
+
+var find = exports.find = function () {
+ var rel = path.join.apply(null, [].slice.call(arguments))
+
+ function find(start, rel) {
+ var file = path.join(start, rel)
+ try {
+ fs.statSync(file)
+ return file
+ } catch (err) {
+ if(path.dirname(start) !== start) // root
+ return find(path.dirname(start), rel)
+ }
+ }
+ return find(process.cwd(), rel)
+}
+
+
+
+
+/***/ }),
+/* 135 */
+/***/ (function(module, exports) {
+
+exports.parse = exports.decode = decode
+
+exports.stringify = exports.encode = encode
+
+exports.safe = safe
+exports.unsafe = unsafe
var eol = typeof process !== 'undefined' &&
- process.platform === 'win32' ? '\r\n' : '\n';
+ process.platform === 'win32' ? '\r\n' : '\n'
function encode (obj, opt) {
- var children = [];
- var out = '';
+ var children = []
+ var out = ''
if (typeof opt === 'string') {
opt = {
section: opt,
whitespace: false
- };
+ }
} else {
- opt = opt || {};
- opt.whitespace = opt.whitespace === true;
+ opt = opt || {}
+ opt.whitespace = opt.whitespace === true
}
- var separator = opt.whitespace ? ' = ' : '=';
+ var separator = opt.whitespace ? ' = ' : '='
Object.keys(obj).forEach(function (k, _, __) {
- var val = obj[k];
+ var val = obj[k]
if (val && Array.isArray(val)) {
val.forEach(function (item) {
- out += safe(k + '[]') + separator + safe(item) + '\n';
- });
+ out += safe(k + '[]') + separator + safe(item) + '\n'
+ })
} else if (val && typeof val === 'object') {
- children.push(k);
+ children.push(k)
} else {
- out += safe(k) + separator + safe(val) + eol;
+ out += safe(k) + separator + safe(val) + eol
}
- });
+ })
if (opt.section && out.length) {
- out = '[' + safe(opt.section) + ']' + eol + out;
+ out = '[' + safe(opt.section) + ']' + eol + out
}
children.forEach(function (k, _, __) {
- var nk = dotSplit(k).join('\\.');
- var section = (opt.section ? opt.section + '.' : '') + nk;
+ var nk = dotSplit(k).join('\\.')
+ var section = (opt.section ? opt.section + '.' : '') + nk
var child = encode(obj[k], {
section: section,
whitespace: opt.whitespace
- });
+ })
if (out.length && child.length) {
- out += eol;
+ out += eol
}
- out += child;
- });
+ out += child
+ })
return out
}
@@ -5212,48 +20751,48 @@ function dotSplit (str) {
}
function decode (str) {
- var out = {};
- var p = out;
- var section = null;
+ var out = {}
+ var p = out
+ var section = null
// section |key = value
- var re = /^\[([^\]]*)\]$|^([^=]+)(=(.*))?$/i;
- var lines = str.split(/[\r\n]+/g);
+ var re = /^\[([^\]]*)\]$|^([^=]+)(=(.*))?$/i
+ var lines = str.split(/[\r\n]+/g)
lines.forEach(function (line, _, __) {
if (!line || line.match(/^\s*[;#]/)) return
- var match = line.match(re);
+ var match = line.match(re)
if (!match) return
if (match[1] !== undefined) {
- section = unsafe(match[1]);
- p = out[section] = out[section] || {};
+ section = unsafe(match[1])
+ p = out[section] = out[section] || {}
return
}
- var key = unsafe(match[2]);
- var value = match[3] ? unsafe(match[4]) : true;
+ var key = unsafe(match[2])
+ var value = match[3] ? unsafe(match[4]) : true
switch (value) {
case 'true':
case 'false':
- case 'null': value = JSON.parse(value);
+ case 'null': value = JSON.parse(value)
}
// Convert keys with '[]' suffix to an array
if (key.length > 2 && key.slice(-2) === '[]') {
- key = key.substring(0, key.length - 2);
+ key = key.substring(0, key.length - 2)
if (!p[key]) {
- p[key] = [];
+ p[key] = []
} else if (!Array.isArray(p[key])) {
- p[key] = [p[key]];
+ p[key] = [p[key]]
}
}
// safeguard against resetting a previously defined
// array by accidentally forgetting the brackets
if (Array.isArray(p[key])) {
- p[key].push(value);
+ p[key].push(value)
} else {
- p[key] = value;
+ p[key] = value
}
- });
+ })
// {a:{y:1},"a.b":{x:2}} --> {a:{y:1,b:{x:2}}}
// use a filter to return the keys that have to be deleted.
@@ -5265,22 +20804,22 @@ function decode (str) {
}
// 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, '.');
+ 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[part] || typeof p[part] !== 'object') p[part] = {}
+ p = p[part]
+ })
if (p === out && nl === l) {
return false
}
- p[nl] = out[k];
+ p[nl] = out[k]
return true
}).forEach(function (del, _, __) {
- delete out[del];
- });
+ delete out[del]
+ })
return out
}
@@ -5302,49 +20841,48 @@ function safe (val) {
}
function unsafe (val, doUnesc) {
- val = (val || '').trim();
+ 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);
+ val = val.substr(1, val.length - 2)
}
- try { val = JSON.parse(val); } catch (_) {}
+ try { val = JSON.parse(val) } catch (_) {}
} else {
// walk the val to find the first not-escaped ; character
- var esc = false;
- var unesc = '';
+ var esc = false
+ var unesc = ''
for (var i = 0, l = val.length; i < l; i++) {
- var c = val.charAt(i);
+ var c = val.charAt(i)
if (esc) {
if ('\\;#'.indexOf(c) !== -1) {
- unesc += c;
+ unesc += c
} else {
- unesc += '\\' + c;
+ unesc += '\\' + c
}
- esc = false;
+ esc = false
} else if (';#'.indexOf(c) !== -1) {
break
} else if (c === '\\') {
- esc = true;
+ esc = true
} else {
- unesc += c;
+ unesc += c
}
}
if (esc) {
- unesc += '\\';
+ unesc += '\\'
}
return unesc.trim()
}
return val
}
-});
-var ini_1 = ini.parse;
-var ini_2 = ini.decode;
-var ini_3 = ini.stringify;
-var ini_4 = ini.encode;
-var ini_5 = ini.safe;
-var ini_6 = ini.unsafe;
+
+/***/ }),
+/* 136 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
var singleComment = 1;
var multiComment = 2;
@@ -5357,7 +20895,7 @@ function stripWithWhitespace(str, start, end) {
return str.slice(start, end).replace(/\S/g, ' ');
}
-var stripJsonComments = function (str, opts) {
+module.exports = function (str, opts) {
opts = opts || {};
var currentChar;
@@ -5416,111 +20954,12 @@ var stripJsonComments = function (str, opts) {
return ret + (insideComment ? strip(str.substr(offset)) : str.substr(offset));
};
-var utils = createCommonjsModule(function (module, exports) {
-var parse = exports.parse = function (content) {
-
- //if it ends in .json or starts with { then it must be json.
- //must be done this way, because ini accepts everything.
- //can't just try and parse it and let it throw if it's not ini.
- //everything is ini. even json with a syntax error.
-
- if(/^\s*{/.test(content))
- return JSON.parse(stripJsonComments(content))
- return ini.parse(content)
-
-};
-
-var file = exports.file = function () {
- var args = [].slice.call(arguments).filter(function (arg) { return arg != null });
-
- //path.join breaks if it's a not a string, so just skip this.
- for(var i in args)
- if('string' !== typeof args[i])
- return
-
- var file = path.join.apply(null, args);
- try {
- return fs.readFileSync(file,'utf-8')
- } catch (err) {
- return
- }
-};
-
-var json = exports.json = function () {
- var content = file.apply(null, arguments);
- return content ? parse(content) : null
-};
-
-var env = exports.env = function (prefix, env) {
- env = env || process.env;
- var obj = {};
- var l = prefix.length;
- for(var k in env) {
- if(k.toLowerCase().indexOf(prefix.toLowerCase()) === 0) {
-
- var keypath = k.substring(l).split('__');
-
- // Trim empty strings from keypath array
- var _emptyStringIndex;
- while ((_emptyStringIndex=keypath.indexOf('')) > -1) {
- keypath.splice(_emptyStringIndex, 1);
- }
-
- var cursor = obj;
- keypath.forEach(function _buildSubObj(_subkey,i){
-
- // (check for _subkey first so we ignore empty strings)
- // (check for cursor to avoid assignment to primitive objects)
- if (!_subkey || typeof cursor !== 'object')
- return
-
- // If this is the last key, just stuff the value in there
- // Assigns actual value from env variable to final key
- // (unless it's just an empty string- in that case use the last valid key)
- if (i === keypath.length-1)
- cursor[_subkey] = env[k];
-
- // Build sub-object if nothing already exists at the keypath
- if (cursor[_subkey] === undefined)
- cursor[_subkey] = {};
-
- // Increment cursor used to track the object at the current depth
- cursor = cursor[_subkey];
+/***/ }),
+/* 137 */
+/***/ (function(module, exports, __webpack_require__) {
- });
-
- }
-
- }
-
- return obj
-};
-
-var find = exports.find = function () {
- var rel = path.join.apply(null, [].slice.call(arguments));
-
- function find(start, rel) {
- var file = path.join(start, rel);
- try {
- fs.statSync(file);
- return file
- } catch (err) {
- if(path.dirname(start) !== start) // root
- return find(path.dirname(start), rel)
- }
- }
- return find(process.cwd(), rel)
-};
-});
-
-var utils_1 = utils.parse;
-var utils_2 = utils.file;
-var utils_3 = utils.json;
-var utils_4 = utils.env;
-var utils_5 = utils.find;
-
-var deepExtend_1 = createCommonjsModule(function (module) {
+"use strict";
/*!
* @description Recursive object extending
* @author Viacheslav Lotsmanov <lotsmanov89@gmail.com>
@@ -5548,6 +20987,8 @@ var deepExtend_1 = createCommonjsModule(function (module) {
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
+
+
function isSpecificValue(val) {
return (
val instanceof Buffer
@@ -5620,7 +21061,7 @@ var deepExtend = module.exports = function (/*obj_1, [obj_2], [obj_N]*/) {
// convert arguments to array and cut off target object
var args = Array.prototype.slice.call(arguments, 1);
- var val, src;
+ var val, src, clone;
args.forEach(function (obj) {
// skip argument if isn't an object, is null, or is an array
@@ -5669,295 +21110,33 @@ var deepExtend = module.exports = function (/*obj_1, [obj_2], [obj_N]*/) {
return target;
};
-});
-
-var minimist = 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;
- }
- }
- }
+/***/ }),
+/* 138 */
+/***/ (function(module, exports, __webpack_require__) {
- Object.keys(defaults).forEach(function (key) {
- if (!hasKey(argv, key.split('.'))) {
- setKey(argv, key.split('.'), defaults[key]);
+"use strict";
- (aliases[key] || []).forEach(function (x) {
- setKey(argv, x.split('.'), defaults[key]);
- });
- }
- });
+var osHomedir = __webpack_require__(139);
+var home = osHomedir();
- if (opts['--']) {
- argv['--'] = new Array();
- notFlags.forEach(function(key) {
- argv['--'].push(key);
- });
- }
- else {
- notFlags.forEach(function(key) {
- argv._.push(key);
- });
- }
+module.exports = function (str) {
+ if (typeof str !== 'string') {
+ throw new TypeError('Expected a string');
+ }
- return argv;
+ return home ? str.replace(/^~($|\/|\\)/, home + '$1') : str;
};
-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);
-}
-
-var join = path.join;
-
-var etc = '/etc';
-var win = process.platform === "win32";
-var home = win
- ? process.env.USERPROFILE
- : process.env.HOME;
-
-var rc = function (name, defaults, argv, parse) {
- if('string' !== typeof name)
- throw new Error('rc(name): name *must* be string')
- if(!argv)
- argv = minimist(process.argv.slice(2));
- defaults = (
- 'string' === typeof defaults
- ? utils.json(defaults) : defaults
- ) || {};
-
- parse = parse || utils.parse;
-
- var env = utils.env(name + '_');
- var configs = [defaults];
- var configFiles = [];
- function addConfigFile (file) {
- if (configFiles.indexOf(file) >= 0) return
- var fileConfig = utils.file(file);
- if (fileConfig) {
- configs.push(parse(fileConfig));
- configFiles.push(file);
- }
- }
+/***/ }),
+/* 139 */
+/***/ (function(module, exports, __webpack_require__) {
- // which files do we look at?
- if (!win)
- [join(etc, name, 'config'),
- join(etc, name + 'rc')].forEach(addConfigFile);
- if (home)
- [join(home, '.config', name, 'config'),
- join(home, '.config', name),
- join(home, '.' + name, 'config'),
- join(home, '.' + name + 'rc')].forEach(addConfigFile);
- addConfigFile(utils.find('.'+name+'rc'));
- if (env.config) addConfigFile(env.config);
- if (argv.config) addConfigFile(argv.config);
+"use strict";
- return deepExtend_1.apply(null, configs.concat([
- env,
- argv,
- configFiles.length ? {configs: configFiles, config: configFiles[configFiles.length - 1]} : undefined,
- ]))
-};
+var os = __webpack_require__(54);
function homedir() {
var env = process.env;
@@ -5979,19 +21158,14 @@ function homedir() {
return home || null;
}
-var osHomedir = typeof os.homedir === 'function' ? os.homedir : homedir;
-
-var home$1 = osHomedir();
+module.exports = typeof os.homedir === 'function' ? os.homedir : homedir;
-var untildify = function (str) {
- if (typeof str !== 'string') {
- throw new TypeError('Expected a string');
- }
- return home$1 ? str.replace(/^~($|\/|\\)/, home$1 + '$1') : str;
-};
+/***/ }),
+/* 140 */
+/***/ (function(module, exports) {
-var shellsubstitute = function (s, vars) {
+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] || '');
@@ -6001,110 +21175,27 @@ var shellsubstitute = function (s, vars) {
});
};
-var npmPrefix = function () {
- var rcPrefix = rc('npm', null, []).prefix;
-
- if (rcPrefix) {
- return untildify(shellsubstitute(rcPrefix, process.env));
- }
- else if (process.platform == 'win32') {
- return path.dirname(process.execPath);
- }
- else {
- return path.resolve(process.execPath, '../..');
- }
-};
-
-var resolve = resolveFrom_1.silent;
-var npmPrefix$2 = npmPrefix();
-var loadPlugin_1 = loadPlugin;
-loadPlugin.resolve = resolvePlugin;
+/***/ }),
+/* 141 */
+/***/ (function(module, exports) {
-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$2) === 0;
-var windows = process.platform === 'win32';
-var prefix = windows ? /* istanbul ignore next */ '' : 'lib';
-var globals = path.resolve(npmPrefix$2, 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');
+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;
-/* Load the plug-in found using `resolvePlugin`. */
-function loadPlugin(name, options) {
- return commonjsRequire(resolvePlugin(name, options) || name)
-}
+/***/ }),
+/* 142 */
+/***/ (function(module, exports, __webpack_require__) {
-/* Find a plugin.
- *
- * See also:
- * <https://docs.npmjs.com/files/folders#node-modules>
- * <https://github.com/sindresorhus/resolve-from>
- *
- * 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
-}
-
-var format = createCommonjsModule(function (module) {
//
// format - printf-like string formatting for JavaScript
// github.com/samsonjs/format
@@ -6116,16 +21207,19 @@ var format = createCommonjsModule(function (module) {
// http://sjs.mit-license.org
//
-(function() {
+;(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;
@@ -6161,7 +21255,8 @@ var format = createCommonjsModule(function (module) {
c = fmt[i];
}
return digits.length > 0 ? parseInt(digits) : null;
- };
+ }
+ ;
for (; i < n; ++i) {
c = fmt[i];
if (escaped) {
@@ -6226,532 +21321,155 @@ var format = createCommonjsModule(function (module) {
}
}());
-});
-var fault = create(Error);
-var fault_1 = fault;
+/***/ }),
+/* 143 */
+/***/ (function(module, exports) {
-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$$1) {
- if (format$$1) {
- format$$1 = format.apply(null, arguments);
- }
-
- return new EConstructor(format$$1)
- }
+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;
-var immutable = extend$1;
+/***/ }),
+/* 144 */
+/***/ (function(module, exports, __webpack_require__) {
-var hasOwnProperty = Object.prototype.hasOwnProperty;
+"use strict";
-function extend$1() {
- var target = {};
- for (var i = 0; i < arguments.length; i++) {
- var source = arguments[i];
+var Ignore = __webpack_require__(145);
+var find = __webpack_require__(147);
- for (var key in source) {
- if (hasOwnProperty.call(source, key)) {
- target[key] = source[key];
- }
- }
- }
-
- return target
-}
-
-var isObject$1 = function isObject(x) {
- return typeof x === "object" && x !== null;
-};
-
-var toString = Object.prototype.toString;
-
-var xIsString = isString;
-
-function isString(obj) {
- return toString.call(obj) === "[object String]"
-}
-
-var xIsFunction = function isFunction (fn) {
- return Object.prototype.toString.call(fn) === '[object Function]'
-};
-
-var debug = src('unified-engine:find-up');
-
-
-
-var findUp = FindUp;
-
-var read = fs.readFile;
-var resolve$1 = path.resolve;
-var relative = path.relative;
-var join$1 = path.join;
-var dirname = path.dirname;
-
-FindUp.prototype.load = load$2;
-
-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$1(options.cwd, fp);
- }
-}
-
-function load$2(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;
- }
+module.exports = fileSystem;
- if (!self.detect) {
- return callback();
- }
-
- filePath = resolve$1(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_1('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_1('Cannot parse given file `%s`\n%s', relative(cwd, givenFilePath), err.stack);
- debug(err.message);
- }
- }
+/* 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
+ });
- givenFile = result;
- self.givenFile = result;
- applyAll(cbs, result);
+ if (input.length === 0) {
+ return next();
}
- 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$1(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$1(directory, name);
- var contents;
-
- /* istanbul ignore if - Hard to test. */
- if (err) {
- if (err.code === 'ENOENT') {
- return next();
- }
-
- err = fault_1('Cannot read file `%s`\n%s', relative(cwd, fp), err.message);
- debug(err.message);
- return found(err);
- }
+ find(input, {
+ cwd: settings.cwd,
+ extensions: settings.extensions,
+ silentlyIgnore: skip,
+ ignore: ignore
+ }, found);
- try {
- contents = create(buf, fp);
- } catch (err) {
- return found(fault_1('Cannot parse file `%s`\n%s', relative(cwd, fp), err.message));
- }
+ function found(err, result) {
+ var output = result.files;
- /* istanbul ignore else - maybe used in the future. */
- if (contents) {
- debug('Read file `%s`', fp);
- found(null, contents);
- } else {
- next();
- }
- }
+ /* 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;
+ });
- function found(err, result) {
- var cbs = cache[directory];
- cache[directory] = err || result;
- applyAll(cbs, err || result);
- }
- }
+ /* Mark as given. This allows outputting files,
+ * which can be pretty dangerous, so it’s “hidden”. */
+ output.forEach(function (file) {
+ file.data.unifiedEngineGiven = true;
+ });
- function applyAll(cbs, result) {
- var index = cbs.length;
+ context.files = output;
- while (index--) {
- apply(cbs[index], result);
+ /* 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;
}
- }
- function apply(cb, result) {
- if (isObject$1(result) && xIsFunction(result[0])) {
- result.push(cb);
- } else if (result instanceof Error) {
- cb(result);
- } else {
- cb(null, result);
- }
+ next(err);
}
}
-var configuration = createCommonjsModule(function (module) {
-var debug = src('unified-engine:configuration');
-var resolve = loadPlugin_1.resolve;
-
+/***/ }),
+/* 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;
-module.exports = Config;
+Ignore.prototype.check = check;
-var own = {}.hasOwnProperty;
-var extname = path.extname;
-var basename = path.basename;
var dirname = path.dirname;
var relative = path.relative;
+var resolve = path.resolve;
-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 = [];
-
+function Ignore(options) {
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,
+ this.findUp = new FindUp({
+ filePath: options.ignorePath,
cwd: options.cwd,
- detect: options.detectConfig,
- names: names,
- create: this.create
+ detect: options.detectIgnore,
+ names: options.ignoreName ? [options.ignoreName] : [],
+ create: 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) {
+function check(filePath, callback) {
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, immutable(options, {root: self.cwd}));
- }
- } else {
- merge(result, contents, null, immutable(options, {root: dirname(filePath)}));
- }
-
- merge(result, self.given, null, immutable(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$1._cache[filePath];
-
- if (!submodule) {
- submodule = new module$1(filePath, module);
- submodule.filename = filePath;
- submodule.paths = module$1._nodeModulePaths(dirname(filePath));
- submodule._compile(String(buf), filePath);
- submodule.loaded = true;
- module$1._cache[filePath] = submodule;
- }
-
- return submodule.exports;
-}
-
-function loadYAML(buf, filePath) {
- return jsYaml$2.safeLoad(buf, {filename: basename(filePath)});
-}
-
-function loadJSON(buf, filePath) {
- var result = parseJson$1(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 (isObject$1(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 (isObject$1(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 = immutable(target.settings, result.settings);
- }
-
- function addEach(result) {
- var length = result.length;
- var index = -1;
- var value;
-
- while (++index < length) {
- value = result[index];
-
- if (isObject$1(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 (xIsString(usable)) {
- addModule(usable, value);
- } else if (xIsFunction(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 = commonjsRequire(fp); // eslint-disable-line import/no-dynamic-require
- } catch (err) {
- throw fault_1('Cannot parse script `%s`\n%s', relative(root, fp), err.stack);
- }
- try {
- if (xIsFunction(res)) {
- addPlugin(res, value);
- } else {
- merge(target, res, value, immutable(options, {root: dirname(fp)}));
- }
- } catch (err) {
- throw fault_1('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);
- }
- }
+ self.findUp.load(filePath, done);
- function addPlugin(result, value) {
- var entry = find(target.plugins, result);
+ function done(err, ignore) {
+ var normal;
- if (entry) {
- reconfigure(entry, value);
+ if (err) {
+ callback(err);
+ } else if (ignore) {
+ normal = relative(ignore.filePath, resolve(self.cwd, filePath));
+ callback(null, normal ? ignore.ignores(normal) : false);
} else {
- target.plugins.push([result, value]);
+ callback(null, false);
}
}
}
-function reconfigure(entry, value) {
- if (value !== false && entry[1] !== false && isObject$1(value)) {
- value = immutable(entry[1], value);
- }
-
- entry[1] = value;
+function create(buf, filePath) {
+ var ignore = gitignore().add(String(buf));
+ ignore.filePath = dirname(filePath);
+ return ignore;
}
-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;
- }
-}
-});
+/***/ }),
+/* 146 */
+/***/ (function(module, exports, __webpack_require__) {
-var configure_1 = configure;
+"use strict";
-function configure(context, settings) {
- context.configuration = new configuration(settings);
-}
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"); } }
-var ignore = function () {
+module.exports = function () {
return new IgnoreBase();
};
@@ -6842,8 +21560,8 @@ var IgnoreBase = function () {
value: function filter(paths) {
var _this = this;
- return make_array(paths).filter(function (path$$1) {
- return _this._filter(path$$1);
+ return make_array(paths).filter(function (path) {
+ return _this._filter(path);
});
}
}, {
@@ -6851,14 +21569,14 @@ var IgnoreBase = function () {
value: function createFilter() {
var _this2 = this;
- return function (path$$1) {
- return _this2._filter(path$$1);
+ return function (path) {
+ return _this2._filter(path);
};
}
}, {
key: 'ignores',
- value: function ignores(path$$1) {
- return !this._filter(path$$1);
+ value: function ignores(path) {
+ return !this._filter(path);
}
}, {
key: '_createRule',
@@ -6892,37 +21610,37 @@ var IgnoreBase = function () {
}, {
key: '_filter',
- value: function _filter(path$$1, slices) {
- if (!path$$1) {
+ value: function _filter(path, slices) {
+ if (!path) {
return false;
}
- if (path$$1 in this._cache) {
- return this._cache[path$$1];
+ if (path in this._cache) {
+ return this._cache[path];
}
if (!slices) {
// path/to/a.js
// ['path', 'to', 'a.js']
- slices = path$$1.split(SLASH);
+ slices = path.split(SLASH);
}
slices.pop();
- return this._cache[path$$1] = slices.length
+ 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$$1)
+ ? this._filter(slices.join(SLASH) + SLASH, slices) && this._test(path)
// Or only test the path
- : this._test(path$$1);
+ : this._test(path);
}
// @returns {Boolean} true if a file is NOT ignored
}, {
key: '_test',
- value: function _test(path$$1) {
+ value: function _test(path) {
// Explicitly define variable type by setting matched to `0`
var matched = 0;
@@ -6930,7 +21648,7 @@ var IgnoreBase = function () {
// 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$$1);
+ matched = rule.negative ^ rule.regex.test(path);
}
});
@@ -7165,57 +21883,275 @@ typeof process !== 'undefined' && (process.env && process.env.IGNORE_TEST_WIN32
);
};
- IgnoreBase.prototype._filter = function (path$$1, slices) {
- path$$1 = make_posix(path$$1);
- return filter.call(this, path$$1, slices);
+ IgnoreBase.prototype._filter = function (path, slices) {
+ path = make_posix(path);
+ return filter.call(this, path, slices);
};
}
-var ignore$2 = Ignore;
-Ignore.prototype.check = check;
+/***/ }),
+/* 147 */
+/***/ (function(module, exports, __webpack_require__) {
-var dirname$1 = path.dirname;
-var relative$1 = path.relative;
-var resolve$2 = path.resolve;
+"use strict";
-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$1
- });
-}
+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);
-function check(filePath, callback) {
- var self = this;
+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;
- self.findUp.load(filePath, done);
+module.exports = find;
- function done(err, ignore$$1) {
- var normal;
+/* 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 if (ignore$$1) {
- normal = relative$1(ignore$$1.filePath, resolve$2(self.cwd, filePath));
- callback(null, normal ? ignore$$1.ignores(normal) : false);
} else {
- callback(null, false);
+ callback(null, {oneFileMode: oneFileMode(result), files: result.output});
}
}
}
-function create$1(buf, filePath) {
- var ignore$$1 = ignore().add(String(buf));
- ignore$$1.filePath = dirname$1(filePath);
- return ignore$$1;
+/* 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
@@ -7237,9 +22173,9 @@ function create$1(buf, filePath) {
// 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
@@ -7284,7 +22220,7 @@ function maybeCallback(cb) {
return typeof cb === 'function' ? cb : rethrow();
}
-var normalize = path.normalize;
+var normalize = pathModule.normalize;
// Regexp that finds the next partion of a (partial) path
// result is [base_with_slash, base], e.g. ['somedir/', 'somedir']
@@ -7301,9 +22237,9 @@ if (isWindows) {
var splitRootRe = /^[\/]*/;
}
-var realpathSync = function realpathSync(p, cache) {
+exports.realpathSync = function realpathSync(p, cache) {
// make p is absolute
- p = path.resolve(p);
+ p = pathModule.resolve(p);
if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
return cache[p];
@@ -7381,14 +22317,14 @@ var realpathSync = function realpathSync(p, cache) {
fs.statSync(base);
linkTarget = fs.readlinkSync(base);
}
- resolvedLink = path.resolve(previous, linkTarget);
+ 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 = path.resolve(resolvedLink, p.slice(pos));
+ p = pathModule.resolve(resolvedLink, p.slice(pos));
start();
}
@@ -7398,14 +22334,14 @@ var realpathSync = function realpathSync(p, cache) {
};
-var realpath = function realpath(p, cache, cb) {
+exports.realpath = function realpath(p, cache, cb) {
if (typeof cb !== 'function') {
cb = maybeCallback(cache);
cache = null;
}
// make p is absolute
- p = path.resolve(p);
+ p = pathModule.resolve(p);
if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
return process.nextTick(cb.bind(null, null, cache[p]));
@@ -7508,164 +22444,27 @@ var realpath = function realpath(p, cache, cb) {
function gotTarget(err, target, base) {
if (err) return cb(err);
- var resolvedLink = path.resolve(previous, target);
+ var resolvedLink = pathModule.resolve(previous, target);
if (cache) cache[base] = resolvedLink;
gotResolvedLink(resolvedLink);
}
function gotResolvedLink(resolvedLink) {
// resolve the link, then start over
- p = path.resolve(resolvedLink, p.slice(pos));
+ p = pathModule.resolve(resolvedLink, p.slice(pos));
start();
}
};
-var old = {
- realpathSync: realpathSync,
- realpath: realpath
-};
-
-var fs_realpath = realpath$1;
-realpath$1.realpath = realpath$1;
-realpath$1.sync = realpathSync$1;
-realpath$1.realpathSync = realpathSync$1;
-realpath$1.monkeypatch = monkeypatch;
-realpath$1.unmonkeypatch = unmonkeypatch;
-
-
-var origRealpath = fs.realpath;
-var origRealpathSync = fs.realpathSync;
-
-var version = process.version;
-var ok = /^v[0-5]\./.test(version);
-
-
-function newError (er) {
- return er && er.syscall === 'realpath' && (
- er.code === 'ELOOP' ||
- er.code === 'ENOMEM' ||
- er.code === 'ENAMETOOLONG'
- )
-}
-
-function realpath$1 (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$1 (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$1;
- fs.realpathSync = realpathSync$1;
-}
-
-function unmonkeypatch () {
- fs.realpath = origRealpath;
- fs.realpathSync = origRealpathSync;
-}
-
-var concatMap = 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]';
-};
-
-var balancedMatch = 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;
-}
+/***/ }),
+/* 149 */
+/***/ (function(module, exports, __webpack_require__) {
-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;
+var concatMap = __webpack_require__(150);
+var balanced = __webpack_require__(151);
- 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;
-}
-
-var braceExpansion = expandTop;
+module.exports = expandTop;
var escSlash = '\0SLASH'+Math.random()+'\0';
var escOpen = '\0OPEN'+Math.random()+'\0';
@@ -7704,7 +22503,7 @@ function parseCommaParts(str) {
return [''];
var parts = [];
- var m = balancedMatch('{', '}', str);
+ var m = balanced('{', '}', str);
if (!m)
return str.split(',');
@@ -7743,6 +22542,10 @@ function expandTop(str) {
return expand(escapeBraces(str), true).map(unescapeBraces);
}
+function identity(e) {
+ return e;
+}
+
function embrace(str) {
return '{' + str + '}';
}
@@ -7760,7 +22563,7 @@ function gte(i, y) {
function expand(str, isTop) {
var expansions = [];
- var m = balancedMatch('{', '}', str);
+ var m = balanced('{', '}', str);
if (!m || /\$$/.test(m.pre)) return [str];
var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
@@ -7809,7 +22612,7 @@ function expand(str, isTop) {
if (isSequence) {
var x = numeric(n[0]);
var y = numeric(n[1]);
- var width = Math.max(n[0].length, n[1].length);
+ var width = Math.max(n[0].length, n[1].length)
var incr = n.length == 3
? Math.abs(numeric(n[2]))
: 1;
@@ -7859,935 +22662,101 @@ function expand(str, isTop) {
return expansions;
}
-var minimatch_1 = minimatch;
-minimatch.Minimatch = Minimatch;
-
-var path$2 = { sep: '/' };
-try {
- path$2 = path;
-} catch (er) {}
-
-var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {};
-
-
-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$1;
-function filter$1 (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))
- };
+/***/ }),
+/* 150 */
+/***/ (function(module, exports) {
- return m
+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;
};
-Minimatch.defaults = function (def) {
- if (!def || !Object.keys(def).length) return Minimatch
- return minimatch.defaults(def).Minimatch
+var isArray = Array.isArray || function (xs) {
+ return Object.prototype.toString.call(xs) === '[object Array]';
};
-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$2.sep !== '/') {
- pattern = pattern.split(path$2.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
- });
+/***/ }),
+/* 151 */
+/***/ (function(module, exports, __webpack_require__) {
- 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;
+"use strict";
- if (options.nonegate) return
+module.exports = balanced;
+function balanced(a, b, str) {
+ if (a instanceof RegExp) a = maybeMatch(a, str);
+ if (b instanceof RegExp) b = maybeMatch(b, str);
- for (var i = 0, l = pattern.length
- ; i < l && pattern.charAt(i) === '!'
- ; i++) {
- negate = !negate;
- negateOffset++;
- }
+ var r = range(a, b, str);
- if (negateOffset) this.pattern = pattern.substr(negateOffset);
- this.negate = negate;
+ 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)
+ };
}
-// 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 braceExpansion(pattern)
+function maybeMatch(reg, str) {
+ var m = str.match(reg);
+ return m ? m[0] : null;
}
-// 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$2;
-var SUBPARSE = {};
-function parse$2 (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 (?:<pattern>)<type>
- 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 {
-
- } 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
+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;
- default:
- // swallow any state char that wasn't consumed
- clearStateChar();
+ if (ai >= 0 && bi > 0) {
+ begs = [];
+ left = str.length;
- if (escaping) {
- // no need
- escaping = false;
- } else if (reSpecials[c]
- && !(c === '^' && inClass)) {
- re += '\\';
+ 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;
}
- 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 = '\\';
+ bi = str.indexOf(b, i + 1);
}
- // 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 = '$';
+ i = ai < bi && ai >= 0 ? ai : bi;
}
- 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$2.sep !== '/') {
- f = f.split(path$2.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
+ if (begs.length) {
+ result = [ left, right ];
}
}
- // didn't get any hits. this is success if it's a negative
- // pattern, failure otherwise.
- if (options.flipNegate) return false
- return this.negate
+ return result;
}
-// 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
- }
+/***/ }),
+/* 152 */
+/***/ (function(module, exports) {
- // 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, '\\$&')
-}
-
-var inherits_browser = createCommonjsModule(function (module) {
if (typeof Object.create === 'function') {
// implementation from standard node.js 'util' module
module.exports = function inherits(ctor, superCtor) {
- ctor.super_ = superCtor;
+ ctor.super_ = superCtor
ctor.prototype = Object.create(superCtor.prototype, {
constructor: {
value: ctor,
@@ -8800,310 +22769,38 @@ if (typeof Object.create === 'function') {
} 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;
- };
-}
-});
-
-var inherits = createCommonjsModule(function (module) {
-try {
- var util$$1 = util;
- if (typeof util$$1.inherits !== 'function') throw '';
- module.exports = util$$1.inherits;
-} catch (e) {
- module.exports = inherits_browser;
-}
-});
-
-function posix(path$$1) {
- return path$$1.charAt(0) === '/';
-}
-
-function win32(path$$1) {
- // https://github.com/nodejs/node/blob/b3fcc245fb25539909ef1d5eaa01dbf92e168633/lib/path.js#L56
- var splitDeviceRe = /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
- var result = splitDeviceRe.exec(path$$1);
- var device = result[1] || '';
- var isUnc = Boolean(device && device.charAt(1) !== ':');
-
- // UNC paths are always absolute
- return Boolean(result[2] || isUnc);
-}
-
-var pathIsAbsolute = process.platform === 'win32' ? win32 : posix;
-var posix_1 = posix;
-var win32_1 = win32;
-
-pathIsAbsolute.posix = posix_1;
-pathIsAbsolute.win32 = win32_1;
-
-var alphasort_1 = alphasort;
-var alphasorti_1 = alphasorti;
-var setopts_1 = setopts;
-var ownProp_1 = ownProp;
-var makeAbs_1 = makeAbs;
-var finish_1 = finish;
-var mark_1 = mark$2;
-var isIgnored_1 = isIgnored;
-var childrenIgnored_1 = childrenIgnored;
-
-function ownProp (obj, field) {
- return Object.prototype.hasOwnProperty.call(obj, field)
-}
-
-
-
-
-var Minimatch$1 = minimatch_1.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$1(gpattern, { dot: true });
- }
-
- return {
- matcher: new Minimatch$1(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 = pathIsAbsolute(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$1(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$2 (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 (pathIsAbsolute(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$$1) {
- if (!self.ignore.length)
- return false
-
- return self.ignore.some(function(item) {
- return item.matcher.match(path$$1) || !!(item.gmatcher && item.gmatcher.match(path$$1))
- })
-}
-
-function childrenIgnored (self, path$$1) {
- if (!self.ignore.length)
- return false
-
- return self.ignore.some(function(item) {
- return !!(item.gmatcher && item.gmatcher.match(path$$1))
- })
-}
-
-var common$5 = {
- alphasort: alphasort_1,
- alphasorti: alphasorti_1,
- setopts: setopts_1,
- ownProp: ownProp_1,
- makeAbs: makeAbs_1,
- finish: finish_1,
- mark: mark_1,
- isIgnored: isIgnored_1,
- childrenIgnored: childrenIgnored_1
-};
-
-var sync = globSync;
-globSync.GlobSync = GlobSync;
-
-
-
-
-var setopts$1 = common$5.setopts;
-var ownProp$1 = common$5.ownProp;
-var childrenIgnored$1 = common$5.childrenIgnored;
-var isIgnored$1 = common$5.isIgnored;
+ 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)
@@ -9124,104 +22821,104 @@ function GlobSync (pattern, options) {
if (!(this instanceof GlobSync))
return new GlobSync(pattern, options)
- setopts$1(this, pattern, options);
+ setopts(this, pattern, options)
if (this.noprocess)
return this
- var n = this.minimatch.set.length;
- this.matches = new Array(n);
+ 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._process(this.minimatch.set[i], i, false)
}
- this._finish();
+ this._finish()
}
GlobSync.prototype._finish = function () {
- assert(this instanceof GlobSync);
+ assert(this instanceof GlobSync)
if (this.realpath) {
- var self = this;
+ var self = this
this.matches.forEach(function (matchset, index) {
- var set = self.matches[index] = Object.create(null);
+ var set = self.matches[index] = Object.create(null)
for (var p in matchset) {
try {
- p = self._makeAbs(p);
- var real = fs_realpath.realpathSync(p, self.realpathCache);
- set[real] = true;
+ 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;
+ set[self._makeAbs(p)] = true
else
throw er
}
}
- });
+ })
}
- common$5.finish(this);
-};
+ common.finish(this)
+}
GlobSync.prototype._process = function (pattern, index, inGlobStar) {
- assert(this instanceof GlobSync);
+ assert(this instanceof GlobSync)
// Get the first [n] parts of pattern that are all strings.
- var n = 0;
+ var n = 0
while (typeof pattern[n] === 'string') {
- n ++;
+ n ++
}
// now n is the index of the first one that is *not* a string.
// See if there's anything else
- var prefix;
+ var prefix
switch (n) {
// if not, then this is rather simple
case pattern.length:
- this._processSimple(pattern.join('/'), index);
+ 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;
+ 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('/');
+ prefix = pattern.slice(0, n).join('/')
break
}
- var remain = pattern.slice(n);
+ var remain = pattern.slice(n)
// get the list of entries.
- var read;
+ var read
if (prefix === null)
- read = '.';
- else if (pathIsAbsolute(prefix) || pathIsAbsolute(pattern.join('/'))) {
- if (!prefix || !pathIsAbsolute(prefix))
- prefix = '/' + prefix;
- read = prefix;
+ read = '.'
+ else if (isAbsolute(prefix) || isAbsolute(pattern.join('/'))) {
+ if (!prefix || !isAbsolute(prefix))
+ prefix = '/' + prefix
+ read = prefix
} else
- read = prefix;
+ read = prefix
- var abs = this._makeAbs(read);
+ var abs = this._makeAbs(read)
//if ignored, skip processing
- if (childrenIgnored$1(this, read))
+ if (childrenIgnored(this, read))
return
- var isGlobStar = remain[0] === minimatch_1.GLOBSTAR;
+ var isGlobStar = remain[0] === minimatch.GLOBSTAR
if (isGlobStar)
- this._processGlobStar(prefix, read, abs, remain, index, inGlobStar);
+ this._processGlobStar(prefix, read, abs, remain, index, inGlobStar)
else
- this._processReaddir(prefix, read, abs, remain, index, inGlobStar);
-};
+ this._processReaddir(prefix, read, abs, remain, index, inGlobStar)
+}
GlobSync.prototype._processReaddir = function (prefix, read, abs, remain, index, inGlobStar) {
- var entries = this._readdir(abs, inGlobStar);
+ var entries = this._readdir(abs, inGlobStar)
// if the abs isn't a dir, then nothing can match!
if (!entries)
@@ -9229,27 +22926,27 @@ GlobSync.prototype._processReaddir = function (prefix, read, abs, remain, index,
// 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 pn = remain[0]
+ var negate = !!this.minimatch.negate
+ var rawGlob = pn._glob
+ var dotOk = this.dot || rawGlob.charAt(0) === '.'
- var matchedEntries = [];
+ var matchedEntries = []
for (var i = 0; i < entries.length; i++) {
- var e = entries[i];
+ var e = entries[i]
if (e.charAt(0) !== '.' || dotOk) {
- var m;
+ var m
if (negate && !prefix) {
- m = !e.match(pn);
+ m = !e.match(pn)
} else {
- m = e.match(pn);
+ m = e.match(pn)
}
if (m)
- matchedEntries.push(e);
+ matchedEntries.push(e)
}
}
- var len = matchedEntries.length;
+ var len = matchedEntries.length
// If there are no matched entries, then nothing matches.
if (len === 0)
return
@@ -9261,21 +22958,21 @@ GlobSync.prototype._processReaddir = function (prefix, read, abs, remain, index,
if (remain.length === 1 && !this.mark && !this.stat) {
if (!this.matches[index])
- this.matches[index] = Object.create(null);
+ this.matches[index] = Object.create(null)
for (var i = 0; i < len; i ++) {
- var e = matchedEntries[i];
+ var e = matchedEntries[i]
if (prefix) {
if (prefix.slice(-1) !== '/')
- e = prefix + '/' + e;
+ e = prefix + '/' + e
else
- e = prefix + e;
+ e = prefix + e
}
if (e.charAt(0) === '/' && !this.nomount) {
- e = path.join(this.root, e);
+ e = path.join(this.root, e)
}
- this._emitMatch(index, e);
+ this._emitMatch(index, e)
}
// This was the last one, and no stats were needed
return
@@ -9283,46 +22980,46 @@ GlobSync.prototype._processReaddir = function (prefix, read, abs, remain, index,
// now test all matched entries as stand-ins for that part
// of the pattern.
- remain.shift();
+ remain.shift()
for (var i = 0; i < len; i ++) {
- var e = matchedEntries[i];
- var newPattern;
+ var e = matchedEntries[i]
+ var newPattern
if (prefix)
- newPattern = [prefix, e];
+ newPattern = [prefix, e]
else
- newPattern = [e];
- this._process(newPattern.concat(remain), index, inGlobStar);
+ newPattern = [e]
+ this._process(newPattern.concat(remain), index, inGlobStar)
}
-};
+}
GlobSync.prototype._emitMatch = function (index, e) {
- if (isIgnored$1(this, e))
+ if (isIgnored(this, e))
return
- var abs = this._makeAbs(e);
+ var abs = this._makeAbs(e)
if (this.mark)
- e = this._mark(e);
+ e = this._mark(e)
if (this.absolute) {
- e = abs;
+ e = abs
}
if (this.matches[index][e])
return
if (this.nodir) {
- var c = this.cache[abs];
+ var c = this.cache[abs]
if (c === 'DIR' || Array.isArray(c))
return
}
- this.matches[index][e] = true;
+ this.matches[index][e] = true
if (this.stat)
- this._stat(e);
-};
+ this._stat(e)
+}
GlobSync.prototype._readdirInGlobStar = function (abs) {
@@ -9331,10 +23028,11 @@ GlobSync.prototype._readdirInGlobStar = function (abs) {
if (this.follow)
return this._readdir(abs, false)
- var entries;
- var lstat;
+ var entries
+ var lstat
+ var stat
try {
- lstat = fs.lstatSync(abs);
+ lstat = fs.lstatSync(abs)
} catch (er) {
if (er.code === 'ENOENT') {
// lstat failed, doesn't exist
@@ -9342,25 +23040,27 @@ GlobSync.prototype._readdirInGlobStar = function (abs) {
}
}
- var isSym = lstat && lstat.isSymbolicLink();
- this.symlinks[abs] = isSym;
+ 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';
+ this.cache[abs] = 'FILE'
else
- entries = this._readdir(abs, false);
+ entries = this._readdir(abs, false)
return entries
-};
+}
GlobSync.prototype._readdir = function (abs, inGlobStar) {
- if (inGlobStar && !ownProp$1(this.symlinks, abs))
+ var entries
+
+ if (inGlobStar && !ownProp(this.symlinks, abs))
return this._readdirInGlobStar(abs)
- if (ownProp$1(this.cache, abs)) {
- var c = this.cache[abs];
+ if (ownProp(this.cache, abs)) {
+ var c = this.cache[abs]
if (!c || c === 'FILE')
return null
@@ -9371,10 +23071,10 @@ GlobSync.prototype._readdir = function (abs, inGlobStar) {
try {
return this._readdirEntries(abs, fs.readdirSync(abs))
} catch (er) {
- this._readdirError(abs, er);
+ this._readdirError(abs, er)
return null
}
-};
+}
GlobSync.prototype._readdirEntries = function (abs, entries) {
// if we haven't asked to stat everything, then just
@@ -9382,32 +23082,32 @@ GlobSync.prototype._readdirEntries = function (abs, entries) {
// having to stat it a second time.
if (!this.mark && !this.stat) {
for (var i = 0; i < entries.length; i ++) {
- var e = entries[i];
+ var e = entries[i]
if (abs === '/')
- e = abs + e;
+ e = abs + e
else
- e = abs + '/' + e;
- this.cache[e] = true;
+ e = abs + '/' + e
+ this.cache[e] = true
}
}
- this.cache[abs] = entries;
+ 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';
+ 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;
+ var error = new Error(er.code + ' invalid cwd ' + this.cwd)
+ error.path = this.cwd
+ error.code = er.code
throw error
}
break
@@ -9416,22 +23116,22 @@ GlobSync.prototype._readdirError = function (f, er) {
case 'ELOOP':
case 'ENAMETOOLONG':
case 'UNKNOWN':
- this.cache[this._makeAbs(f)] = false;
+ this.cache[this._makeAbs(f)] = false
break
default: // some unusual error. Treat as failure.
- this.cache[this._makeAbs(f)] = false;
+ this.cache[this._makeAbs(f)] = false
if (this.strict)
throw er
if (!this.silent)
- console.error('glob error', er);
+ console.error('glob error', er)
break
}
-};
+}
GlobSync.prototype._processGlobStar = function (prefix, read, abs, remain, index, inGlobStar) {
- var entries = this._readdir(abs, 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
@@ -9440,77 +23140,77 @@ GlobSync.prototype._processGlobStar = function (prefix, read, abs, remain, index
// 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);
+ 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);
+ this._process(noGlobStar, index, false)
- var len = entries.length;
- var isSym = this.symlinks[abs];
+ 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];
+ 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 instead = gspref.concat(entries[i], remainWithoutGlobStar)
+ this._process(instead, index, true)
- var below = gspref.concat(entries[i], remain);
- this._process(below, 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);
+ var exists = this._stat(prefix)
if (!this.matches[index])
- this.matches[index] = Object.create(null);
+ this.matches[index] = Object.create(null)
// If it doesn't exist, then just mark the lack of results
if (!exists)
return
- if (prefix && pathIsAbsolute(prefix) && !this.nomount) {
- var trail = /[\/\\]$/.test(prefix);
+ if (prefix && isAbsolute(prefix) && !this.nomount) {
+ var trail = /[\/\\]$/.test(prefix)
if (prefix.charAt(0) === '/') {
- prefix = path.join(this.root, prefix);
+ prefix = path.join(this.root, prefix)
} else {
- prefix = path.resolve(this.root, prefix);
+ prefix = path.resolve(this.root, prefix)
if (trail)
- prefix += '/';
+ prefix += '/'
}
}
if (process.platform === 'win32')
- prefix = prefix.replace(/\\/g, '/');
+ prefix = prefix.replace(/\\/g, '/')
// Mark this as a match
- this._emitMatch(index, prefix);
-};
+ 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) === '/';
+ var abs = this._makeAbs(f)
+ var needDir = f.slice(-1) === '/'
if (f.length > this.maxLength)
return false
- if (!this.stat && ownProp$1(this.cache, abs)) {
- var c = this.cache[abs];
+ if (!this.stat && ownProp(this.cache, abs)) {
+ var c = this.cache[abs]
if (Array.isArray(c))
- c = 'DIR';
+ c = 'DIR'
// It exists, but maybe not how we need it
if (!needDir || c === 'DIR')
@@ -9523,149 +23223,78 @@ GlobSync.prototype._stat = function (f) {
// if we know it exists, but not what it is.
}
- var stat = this.statCache[abs];
+ var exists
+ var stat = this.statCache[abs]
if (!stat) {
- var lstat;
+ var lstat
try {
- lstat = fs.lstatSync(abs);
+ lstat = fs.lstatSync(abs)
} catch (er) {
if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) {
- this.statCache[abs] = false;
+ this.statCache[abs] = false
return false
}
}
if (lstat && lstat.isSymbolicLink()) {
try {
- stat = fs.statSync(abs);
+ stat = fs.statSync(abs)
} catch (er) {
- stat = lstat;
+ stat = lstat
}
} else {
- stat = lstat;
+ stat = lstat
}
}
- this.statCache[abs] = stat;
+ this.statCache[abs] = stat
- var c = true;
+ var c = true
if (stat)
- c = stat.isDirectory() ? 'DIR' : 'FILE';
+ c = stat.isDirectory() ? 'DIR' : 'FILE'
- this.cache[abs] = this.cache[abs] || c;
+ this.cache[abs] = this.cache[abs] || c
if (needDir && c === 'FILE')
return false
return c
-};
-
-GlobSync.prototype._mark = function (p) {
- return common$5.mark(this, p)
-};
-
-GlobSync.prototype._makeAbs = function (f) {
- return common$5.makeAbs(this, f)
-};
-
-// 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.
-var wrappy_1 = 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
- }
}
-var once_1 = wrappy_1(once);
-var strict = wrappy_1(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
+GlobSync.prototype._mark = function (p) {
+ return common.mark(this, p)
}
-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
+GlobSync.prototype._makeAbs = function (f) {
+ return common.makeAbs(this, f)
}
-once_1.strict = strict;
-var reqs = Object.create(null);
+/***/ }),
+/* 154 */
+/***/ (function(module, exports, __webpack_require__) {
+var wrappy = __webpack_require__(62)
+var reqs = Object.create(null)
+var once = __webpack_require__(63)
-var inflight_1 = wrappy_1(inflight);
+module.exports = wrappy(inflight)
function inflight (key, cb) {
if (reqs[key]) {
- reqs[key].push(cb);
+ reqs[key].push(cb)
return null
} else {
- reqs[key] = [cb];
+ reqs[key] = [cb]
return makeres(key)
}
}
function makeres (key) {
- return once_1(function RES () {
- var cbs = reqs[key];
- var len = cbs.length;
- var args = slice$2(arguments);
+ 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
@@ -9675,998 +23304,231 @@ function makeres (key) {
// 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);
+ 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);
+ cbs.splice(0, len)
process.nextTick(function () {
- RES.apply(null, args);
- });
+ RES.apply(null, args)
+ })
} else {
- delete reqs[key];
+ delete reqs[key]
}
}
})
}
-function slice$2 (args) {
- var length = args.length;
- var array = [];
+function slice (args) {
+ var length = args.length
+ var array = []
- for (var i = 0; i < length; i++) array[i] = args[i];
+ for (var i = 0; i < length; i++) array[i] = args[i]
return array
}
-// 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.
-
-var glob_1 = glob;
-
+/***/ }),
+/* 155 */
+/***/ (function(module, exports, __webpack_require__) {
+"use strict";
-var EE = events.EventEmitter;
+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);
-var setopts$2 = common$5.setopts;
-var ownProp$2 = common$5.ownProp;
-
-
-var childrenIgnored$2 = common$5.childrenIgnored;
-var isIgnored$2 = common$5.isIgnored;
-
-
-
-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 sync(pattern, options)
- }
-
- return new Glob$1(pattern, options, cb)
-}
-
-glob.sync = sync;
-var GlobSync$1 = glob.GlobSync = sync.GlobSync;
-
-// old api surface
-glob.glob = glob;
-
-function extend$2 (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$2({}, options_);
- options.noprocess = true;
-
- var g = new Glob$1(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$1;
-inherits(Glob$1, EE);
-function Glob$1 (pattern, options, cb) {
- if (typeof options === 'function') {
- cb = options;
+ if (!callback && func(options)) {
+ callback = options;
options = null;
}
- if (options && options.sync) {
- if (cb)
- throw new TypeError('callback provided to sync glob')
- return new GlobSync$1(pattern, options)
- }
-
- if (!(this instanceof Glob$1))
- return new Glob$1(pattern, options, cb)
-
- setopts$2(this, pattern, options);
- this._didRealPath = false;
-
- // process each pattern in the minimatch set
- var n = this.minimatch.set.length;
-
- // The matches are stored as {<filename>: 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_1(cb);
- this.on('error', cb);
- this.on('end', function (matches) {
- cb(null, matches);
- });
+ if (!callback) {
+ return new Promise(executor);
}
- var self = this;
- this._processing = 0;
-
- this._emitQueue = [];
- this._processQueue = [];
- this.paused = false;
-
- if (this.noprocess)
- return this
-
- if (n === 0)
- return done()
+ executor(null, callback);
- var sync$$1 = true;
- for (var i = 0; i < n; i ++) {
- this._process(this.minimatch.set[i], i, false, done);
- }
- sync$$1 = false;
+ function executor(resolve, reject) {
+ fs.readFile(file.path, options, done);
- function done () {
- --self._processing;
- if (self._processing <= 0) {
- if (sync$$1) {
- process.nextTick(function () {
- self._finish();
- });
+ function done(err, res) {
+ if (err) {
+ reject(err);
} else {
- self._finish();
- }
- }
- }
-}
-
-Glob$1.prototype._finish = function () {
- assert(this instanceof Glob$1);
- if (this.aborted)
- return
-
- if (this.realpath && !this._didRealpath)
- return this._realpath()
-
- common$5.finish(this);
- this.emit('end', this.found);
-};
-
-Glob$1.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$1.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);
- fs_realpath.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$1.prototype._mark = function (p) {
- return common$5.mark(this, p)
-};
-
-Glob$1.prototype._makeAbs = function (f) {
- return common$5.makeAbs(this, f)
-};
-
-Glob$1.prototype.abort = function () {
- this.aborted = true;
- this.emit('abort');
-};
-
-Glob$1.prototype.pause = function () {
- if (!this.paused) {
- this.paused = true;
- this.emit('pause');
- }
-};
+ file.contents = res;
-Glob$1.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]);
+ if (resolve) {
+ resolve(file);
+ } else {
+ callback(null, file);
+ }
}
}
}
-};
-
-Glob$1.prototype._process = function (pattern, index, inGlobStar, cb) {
- assert(this instanceof Glob$1);
- assert(typeof cb === 'function');
-
- if (this.aborted)
- return
+}
- this._processing++;
- if (this.paused) {
- this._processQueue.push([pattern, index, inGlobStar, cb]);
- return
- }
+/* 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;
+}
- //console.error('PROCESS %d', this._processing, pattern)
+/* Create a virtual file and write it out, asynchronously. */
+function write(description, options, callback) {
+ var file = vfile(description);
- // Get the first [n] parts of pattern that are all strings.
- var n = 0;
- while (typeof pattern[n] === 'string') {
- n ++;
+ /* Weird, right? Otherwise `fs` doesn’t accept it. */
+ if (!callback && func(options)) {
+ callback = options;
+ options = undefined;
}
- // 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
+ if (!callback) {
+ return new Promise(executor);
}
- var remain = pattern.slice(n);
-
- // get the list of entries.
- var read;
- if (prefix === null)
- read = '.';
- else if (pathIsAbsolute(prefix) || pathIsAbsolute(pattern.join('/'))) {
- if (!prefix || !pathIsAbsolute(prefix))
- prefix = '/' + prefix;
- read = prefix;
- } else
- read = prefix;
-
- var abs = this._makeAbs(read);
-
- //if ignored, skip _processing
- if (childrenIgnored$2(this, read))
- return cb()
-
- var isGlobStar = remain[0] === minimatch_1.GLOBSTAR;
- if (isGlobStar)
- this._processGlobStar(prefix, read, abs, remain, index, inGlobStar, cb);
- else
- this._processReaddir(prefix, read, abs, remain, index, inGlobStar, cb);
-};
-
-Glob$1.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$1.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()
+ executor(null, callback);
- // 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) === '.';
+ function executor(resolve, reject) {
+ fs.writeFile(file.path, file.contents || '', options, done);
- 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);
+ function done(err) {
+ if (err) {
+ reject(err);
+ } else if (resolve) {
+ resolve();
} else {
- m = e.match(pn);
+ callback();
}
- 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];
- if (prefix) {
- if (prefix !== '/')
- e = prefix + '/' + e;
- else
- e = prefix + e;
- }
- this._process([e].concat(remain), index, inGlobStar, cb);
- }
- cb();
-};
-
-Glob$1.prototype._emitMatch = function (index, e) {
- if (this.aborted)
- return
-
- if (isIgnored$2(this, e))
- return
-
- if (this.paused) {
- this._emitQueue.push([index, e]);
- return
- }
-
- var abs = pathIsAbsolute(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$1.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_1(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$1.prototype._readdir = function (abs, inGlobStar, cb) {
- if (this.aborted)
- return
-
- cb = inflight_1('readdir\0'+abs+'\0'+inGlobStar, cb);
- if (!cb)
- return
-
- //console.error('RD %j %j', +inGlobStar, abs)
- if (inGlobStar && !ownProp$2(this.symlinks, abs))
- return this._readdirInGlobStar(abs, cb)
-
- if (ownProp$2(this.cache, abs)) {
- var c = this.cache[abs];
- if (!c || c === 'FILE')
- return cb()
-
- if (Array.isArray(c))
- return cb(null, c)
- }
-
- 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$1.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$1.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$1.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$1.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$1.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$1.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 && pathIsAbsolute(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$1.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$2(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 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_1('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$1.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)
-};
-
-/*!
- * Determine if an object is a Buffer
- *
- * @author Feross Aboukhadijeh <https://feross.org>
- * @license MIT
- */
-
-// The _isBuffer check is for Safari 5-7 support, because it's missing
-// Object.prototype.constructor. Remove this eventually
-var isBuffer_1 = 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)
+/* Create a virtual file and write it out, synchronously. */
+function writeSync(description, options) {
+ var file = vfile(description);
+ fs.writeFileSync(file.path, file.contents || '', options);
}
-// 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))
-}
-var own = {}.hasOwnProperty;
+/***/ }),
+/* 156 */
+/***/ (function(module, exports, __webpack_require__) {
-var unistUtilStringifyPosition = stringify;
+"use strict";
-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)
- }
+var buffer = __webpack_require__(64);
+var vfile = __webpack_require__(157);
- /* Position. */
- if (own.call(value, 'start') || own.call(value, 'end')) {
- return position(value)
- }
+module.exports = toVFile;
- /* Point. */
- if (own.call(value, 'line') || own.call(value, 'column')) {
- return point(value)
+/* 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 null
+ return vfile(options);
}
-function point(point) {
- if (!point || typeof point !== 'object') {
- point = {};
- }
- return index(point.line) + ':' + index(point.column)
-}
+/***/ }),
+/* 157 */
+/***/ (function(module, exports, __webpack_require__) {
-function position(pos) {
- if (!pos || typeof pos !== 'object') {
- pos = {};
- }
+"use strict";
- return point(pos.start) + '-' + point(pos.end)
-}
-function index(value) {
- return value && typeof value === 'number' ? value : 1
-}
+var VMessage = __webpack_require__(65);
+var VFile = __webpack_require__(158);
-var vfileMessage = VMessage;
+module.exports = VFile;
-/* Inherit from `Error#`. */
-function VMessagePrototype() {}
-VMessagePrototype.prototype = Error.prototype;
-VMessage.prototype = new VMessagePrototype();
+var proto = VFile.prototype;
-/* Message properties. */
-var proto = VMessage.prototype;
+proto.message = message;
+proto.info = info;
+proto.fail = fail;
-proto.file = '';
-proto.name = '';
-proto.reason = '';
-proto.message = '';
-proto.stack = '';
-proto.fatal = null;
-proto.column = null;
-proto.line = null;
+/* Slight backwards compatibility. Remove in the future. */
+proto.warn = message;
-/* 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;
+/* 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 (typeof position === 'string') {
- origin = position;
- position = null;
+ if (filePath) {
+ message.name = filePath + ':' + message.name;
+ message.file = filePath;
}
- parts = parseOrigin(origin);
- range = unistUtilStringifyPosition(position) || '1:1';
+ message.fatal = false;
- location = {
- start: {line: null, column: null},
- end: {line: null, column: null}
- };
+ this.messages.push(message);
- /* Node. */
- if (position && position.position) {
- position = position.position;
- }
+ return message;
+}
- if (position) {
- /* Position. */
- if (position.start) {
- location = position;
- position = position.start;
- } else {
- /* Point. */
- location.start = position;
- }
- }
+/* Fail. Creates a vmessage, associates it with the file,
+ * and throws it. */
+function fail() {
+ var message = this.message.apply(this, arguments);
- if (reason.stack) {
- this.stack = reason.stack;
- reason = reason.message;
- }
+ message.fatal = true;
- 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];
+ throw message;
}
-function parseOrigin(origin) {
- var result = [null, null];
- var index;
-
- if (typeof origin === 'string') {
- index = origin.indexOf(':');
+/* Info. Creates a vmessage, associates it with the file,
+ * and marks the fatality as null. */
+function info() {
+ var message = this.message.apply(this, arguments);
- if (index === -1) {
- result[1] = origin;
- } else {
- result[0] = origin.slice(0, index);
- result[1] = origin.slice(index + 1);
- }
- }
+ message.fatal = null;
- return result
+ return message;
}
-function replaceExt(npath, ext) {
- if (typeof npath !== 'string') {
- return npath;
- }
- if (npath.length === 0) {
- return npath;
- }
+/***/ }),
+/* 158 */
+/***/ (function(module, exports, __webpack_require__) {
- var nFileName = path.basename(npath, path.extname(npath)) + ext;
- return path.join(path.dirname(npath), nFileName);
-}
+"use strict";
-var replaceExt_1 = replaceExt;
-var core$2 = VFile;
+var path = __webpack_require__(4);
+var replace = __webpack_require__(66);
+var buffer = __webpack_require__(64);
-var own$1 = {}.hasOwnProperty;
-var proto$1 = VFile.prototype;
+module.exports = VFile;
-proto$1.toString = toString$1;
+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
@@ -10688,7 +23550,7 @@ function VFile(options) {
if (!options) {
options = {};
- } else if (typeof options === 'string' || isBuffer_1(options)) {
+ } else if (typeof options === 'string' || buffer(options)) {
options = {contents: options};
} else if ('message' in options && 'messages' in options) {
return options;
@@ -10710,7 +23572,7 @@ function VFile(options) {
while (++index < length) {
prop = order[index];
- if (own$1.call(options, prop)) {
+ if (own.call(options, prop)) {
this[prop] = options[prop];
}
}
@@ -10724,21 +23586,21 @@ function VFile(options) {
}
/* Access full path (`~/index.min.js`). */
-Object.defineProperty(proto$1, 'path', {
+Object.defineProperty(proto, 'path', {
get: function () {
return this.history[this.history.length - 1];
},
- set: function (path$$1) {
- assertNonEmpty(path$$1, 'path');
+ set: function (path) {
+ assertNonEmpty(path, 'path');
- if (path$$1 !== this.path) {
- this.history.push(path$$1);
+ if (path !== this.path) {
+ this.history.push(path);
}
}
});
/* Access parent path (`~`). */
-Object.defineProperty(proto$1, 'dirname', {
+Object.defineProperty(proto, 'dirname', {
get: function () {
return typeof this.path === 'string' ? path.dirname(this.path) : undefined;
},
@@ -10749,7 +23611,7 @@ Object.defineProperty(proto$1, 'dirname', {
});
/* Access basename (`index.min.js`). */
-Object.defineProperty(proto$1, 'basename', {
+Object.defineProperty(proto, 'basename', {
get: function () {
return typeof this.path === 'string' ? path.basename(this.path) : undefined;
},
@@ -10761,7 +23623,7 @@ Object.defineProperty(proto$1, 'basename', {
});
/* Access extname (`.js`). */
-Object.defineProperty(proto$1, 'extname', {
+Object.defineProperty(proto, 'extname', {
get: function () {
return typeof this.path === 'string' ? path.extname(this.path) : undefined;
},
@@ -10781,12 +23643,12 @@ Object.defineProperty(proto$1, 'extname', {
}
}
- this.path = replaceExt_1(this.path, ext);
+ this.path = replace(this.path, ext);
}
});
/* Access stem (`index.min`). */
-Object.defineProperty(proto$1, 'stem', {
+Object.defineProperty(proto, 'stem', {
get: function () {
return typeof this.path === 'string' ? path.basename(this.path, this.extname) : undefined;
},
@@ -10798,9 +23660,9 @@ Object.defineProperty(proto$1, 'stem', {
});
/* Get the value of the file. */
-function toString$1(encoding) {
+function toString(encoding) {
var value = this.contents || '';
- return isBuffer_1(value) ? value.toString(encoding) : String(value);
+ return buffer(value) ? value.toString(encoding) : String(value);
}
/* Assert that `part` is not a path (i.e., does
@@ -10819,492 +23681,461 @@ function assertNonEmpty(part, name) {
}
/* Assert `path` exists. */
-function assertPath(path$$1, name) {
- if (!path$$1) {
+function assertPath(path, name) {
+ if (!path) {
throw new Error('Setting `' + name + '` requires `path` to be set too');
}
}
-var vfile = core$2;
-var proto$2 = core$2.prototype;
+/***/ }),
+/* 159 */
+/***/ (function(module, exports, __webpack_require__) {
-proto$2.message = message;
-proto$2.info = info;
-proto$2.fail = fail;
+"use strict";
-/* Slight backwards compatibility. Remove in the future. */
-proto$2.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 vfileMessage(reason, position, origin);
+/* Expose. */
+module.exports = hidden;
- if (filePath) {
- message.name = filePath + ':' + message.name;
- message.file = filePath;
+/* Check if `filename` is hidden (starts with a dot). */
+function hidden(filename) {
+ if (typeof filename !== 'string') {
+ throw new Error('Expected string');
}
- message.fatal = false;
+ return filename.charAt(0) === '.';
+}
- this.messages.push(message);
- return message;
-}
+/***/ }),
+/* 160 */
+/***/ (function(module, exports, __webpack_require__) {
-/* Fail. Creates a vmessage, associates it with the file,
- * and throws it. */
-function fail() {
- var message = this.message.apply(this, arguments);
+"use strict";
- message.fatal = true;
- throw message;
-}
+var debug = __webpack_require__(9)('unified-engine:file-set-pipeline:stdin');
+var vfile = __webpack_require__(39);
+var concat = __webpack_require__(161);
-/* Info. Creates a vmessage, associates it with the file,
- * and marks the fatality as null. */
-function info() {
- var message = this.message.apply(this, arguments);
+module.exports = stdin;
- message.fatal = null;
+function stdin(context, settings, next) {
+ var streamIn = settings.streamIn;
+ var err;
- return message;
-}
+ 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?'
+ );
+ }
-var core$4 = toVFile;
+ next(err);
-/* 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' || isBuffer_1(options)) {
- options = {path: String(options)};
+ return;
}
- return vfile(options);
-}
+ if (streamIn.isTTY) {
+ debug('Cannot read from `tty` stream');
+ next(new Error('No input'));
-var fs_1 = core$4;
+ return;
+ }
-core$4.read = read$1;
-core$4.readSync = readSync;
-core$4.write = write;
-core$4.writeSync = writeSync;
+ debug('Reading from `streamIn`');
-/* Create a virtual file and read it in, asynchronously. */
-function read$1(description, options, callback) {
- var file = core$4(description);
+ streamIn.pipe(concat({encoding: 'string'}, read));
- if (!callback && xIsFunction(options)) {
- callback = options;
- options = null;
- }
+ function read(value) {
+ var file = vfile(settings.filePath || undefined);
- if (!callback) {
- return new Promise(executor);
- }
+ debug('Read from `streamIn`');
- executor(null, callback);
+ file.cwd = settings.cwd;
+ file.contents = value;
+ file.data.unifiedEngineGiven = true;
+ file.data.unifiedEngineStreamIn = true;
- function executor(resolve, reject) {
- fs.readFile(file.path, options, done);
+ context.files = [file];
- function done(err, res) {
- if (err) {
- reject(err);
- } else {
- file.contents = res;
+ /* If `out` wasn’t set, set `out`. */
+ settings.out = settings.out === null || settings.out === undefined ? true : settings.out;
- if (resolve) {
- resolve(file);
- } else {
- callback(null, file);
- }
- }
- }
+ next();
}
}
-/* Create a virtual file and read it in, synchronously. */
-function readSync(description, options) {
- var file = core$4(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 = core$4(description);
+/***/ }),
+/* 161 */
+/***/ (function(module, exports, __webpack_require__) {
- /* Weird, right? Otherwise `fs` doesn’t accept it. */
- if (!callback && xIsFunction(options)) {
- callback = options;
- options = undefined;
- }
+var Writable = __webpack_require__(162).Writable
+var inherits = __webpack_require__(13)
+var bufferFrom = __webpack_require__(167)
- if (!callback) {
- return new Promise(executor);
- }
+if (typeof Uint8Array === 'undefined') {
+ var U8 = __webpack_require__(168).Uint8Array
+} else {
+ var U8 = Uint8Array
+}
- executor(null, callback);
+function ConcatStream(opts, cb) {
+ if (!(this instanceof ConcatStream)) return new ConcatStream(opts, cb)
- function executor(resolve, reject) {
- fs.writeFile(file.path, file.contents || '', options, done);
+ if (typeof opts === 'function') {
+ cb = opts
+ opts = {}
+ }
+ if (!opts) opts = {}
- function done(err) {
- if (err) {
- reject(err);
- } else if (resolve) {
- resolve();
- } else {
- callback();
- }
+ var encoding = opts.encoding
+ var shouldInferEncoding = false
+
+ if (!encoding) {
+ shouldInferEncoding = true
+ } else {
+ encoding = String(encoding).toLowerCase()
+ if (encoding === 'u8' || encoding === 'uint8') {
+ encoding = 'uint8array'
}
}
-}
-/* Create a virtual file and write it out, synchronously. */
-function writeSync(description, options) {
- var file = core$4(description);
- fs.writeFileSync(file.path, file.contents || '', options);
+ Writable.call(this, { objectMode: true })
+
+ this.encoding = encoding
+ this.shouldInferEncoding = shouldInferEncoding
+
+ if (cb) this.on('finish', function () { cb(this.getBody()) })
+ this.body = []
}
-var toVfile = fs_1;
+module.exports = ConcatStream
+inherits(ConcatStream, Writable)
-/* Expose. */
-var isHidden = hidden;
+ConcatStream.prototype._write = function(chunk, enc, next) {
+ this.body.push(chunk)
+ next()
+}
-/* Check if `filename` is hidden (starts with a dot). */
-function hidden(filename) {
- if (typeof filename !== 'string') {
- throw new Error('Expected string');
- }
+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'
+}
- return filename.charAt(0) === '.';
+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 readdir = fs.readdir;
-var stat = fs.stat;
-var join$2 = path.join;
-var relative$2 = path.relative;
-var resolve$3 = path.resolve;
-var basename = path.basename;
-var extname = path.extname;
-var magic = glob_1.hasMagic;
+var isArray = Array.isArray || function (arr) {
+ return Object.prototype.toString.call(arr) == '[object Array]'
+}
-var finder = find;
+function isArrayish (arr) {
+ return /Array\]$/.test(Object.prototype.toString.call(arr))
+}
-/* Search `patterns`, a mix of globs, paths, and files. */
-function find(input, options, callback) {
- expand$2(input, options, done);
+function isBufferish (p) {
+ return typeof p === 'string' || isArrayish(p) || (p && typeof p.subarray === 'function')
+}
- function done(err, result) {
- /* istanbul ignore if - glob errors are unusual.
- * other errors are on the vfile results. */
- if (err) {
- callback(err);
+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 {
- callback(null, {oneFileMode: oneFileMode(result), files: result.output});
+ strings.push(bufferFrom(String(p)))
}
}
-}
-
-/* Expand the given glob patterns, search given and found
- * directories, and map to vfiles. */
-function expand$2(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);
+ if (Buffer.isBuffer(parts[0])) {
+ strings = Buffer.concat(strings)
+ strings = strings.toString('utf8')
+ } else {
+ strings = strings.join('')
}
+ return strings
+}
- function each(file) {
- if (xIsString(file)) {
- if (magic(file)) {
- expected++;
- glob_1(file, {cwd: cwd}, one);
- } else {
- /* `relative` to make the paths canonical. */
- file = relative$2(cwd, resolve$3(cwd, file)) || '.';
- paths.push(file);
- }
+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 {
- file.cwd = cwd;
- file.path = relative$2(cwd, file.path);
- file.history = [file.path];
- paths.push(file);
+ bufs.push(bufferFrom(String(p)))
}
}
+ return Buffer.concat(bufs)
+}
- 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);
+function arrayConcat (parts) {
+ var res = []
+ for (var i = 0; i < parts.length; i++) {
+ res.push.apply(res, parts[i])
+ }
+ return res
+}
- if (actual === expected) {
- search(paths, options, done);
- }
+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
}
-
- function done(err, files) {
- /* istanbul ignore if - `search` currently does not give errors. */
- if (err) {
- next(err);
- } else {
- next(null, {input: paths, output: files});
+ 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
}
-/* 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;
+/***/ }),
+/* 162 */
+/***/ (function(module, exports, __webpack_require__) {
- function each(file) {
- var part = base(file);
+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);
+}
- if (nested && (isHidden(part) || part === 'node_modules')) {
- return;
- }
- expected++;
+/***/ }),
+/* 163 */
+/***/ (function(module, exports) {
- statAndIgnore(file, options, handle);
+var toString = {}.toString;
- function handle(err, result) {
- var ignored = result && result.ignored;
- var dir = result && result.stats && result.stats.isDirectory();
+module.exports = Array.isArray || function (arr) {
+ return toString.call(arr) == '[object Array]';
+};
- if (ignored && (nested || silent)) {
- return one(null, []);
- }
- if (!ignored && dir) {
- return readdir(resolve$3(cwd, filePath(file)), directory);
- }
+/***/ }),
+/* 164 */
+/***/ (function(module, exports, __webpack_require__) {
- if (nested && !dir && extensions.length !== 0 && extensions.indexOf(extname(file)) === -1) {
- return one(null, []);
- }
+"use strict";
- file = toVfile(file);
- file.cwd = cwd;
- if (ignored) {
- try {
- file.fail('Cannot process specified file: it’s ignored');
- } catch (err) {}
- }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
- if (err && err.code === 'ENOENT') {
- try {
- file.fail(err.syscall === 'stat' ? 'No such file or directory' : err);
- } catch (err) {}
- }
+var Buffer = __webpack_require__(29).Buffer;
+var util = __webpack_require__(11);
- one(null, [file]);
- }
+function copyBuffer(src, target, offset) {
+ src.copy(target, offset);
+}
- function directory(err, basenames) {
- var file;
+module.exports = function () {
+ function BufferList() {
+ _classCallCheck(this, BufferList);
- /* istanbul ignore if - Should not happen often: the directory
- * is `stat`ed first, which was ok, but reading it is not. */
- if (err) {
- file = toVfile(filePath(file));
- file.cwd = cwd;
+ this.head = null;
+ this.tail = null;
+ this.length = 0;
+ }
- try {
- file.fail('Cannot read directory');
- } catch (err) {}
+ 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;
+ };
- one(null, [file]);
- } else {
- search(basenames.map(concat), immutable(options, {nested: true}), one);
- }
- }
+ 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;
+ };
- /* Error is never given. Always given `results`. */
- function one(_, results) {
- /* istanbul ignore else - always given. */
- if (results) {
- files = files.concat(results);
- }
+ 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;
+ };
- actual++;
+ BufferList.prototype.clear = function clear() {
+ this.head = this.tail = null;
+ this.length = 0;
+ };
- if (actual === expected) {
- next(null, files);
- }
- }
+ 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;
+ };
- function concat(value) {
- return join$2(filePath(file), value);
+ 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;
+ };
-function statAndIgnore(file, options, callback) {
- var ignore = options.ignore;
- var fp = resolve$3(options.cwd, filePath(file));
- var expected = 1;
- var actual = 0;
- var stats;
- var ignored;
+ return BufferList;
+}();
- if (!file.contents) {
- expected++;
- stat(fp, handleStat);
- }
+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;
+ };
+}
- ignore.check(fp, handleIgnore);
+/***/ }),
+/* 165 */
+/***/ (function(module, exports, __webpack_require__) {
- function handleStat(err, value) {
- stats = value;
- one(err);
- }
- function handleIgnore(err, value) {
- ignored = value;
- one(err);
- }
+/**
+ * For Node.js, simply re-export the core `util.deprecate` function.
+ */
- function one(err) {
- actual++;
+module.exports = __webpack_require__(11).deprecate;
- if (err) {
- callback(err);
- actual = -1;
- } else if (actual === expected) {
- callback(null, {stats: stats, ignored: ignored});
- }
- }
-}
-function base(file) {
- return xIsString(file) ? basename(file) : file.basename;
-}
+/***/ }),
+/* 166 */
+/***/ (function(module, exports, __webpack_require__) {
-function filePath(file) {
- return xIsString(file) ? file : file.path;
-}
+"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.
-function oneFileMode(result) {
- return result.output.length === 1 &&
- result.input.length === 1 &&
- result.output[0].path === result.input[0];
-}
+// a passthrough stream.
+// basically just the most minimal sort of Transform stream.
+// Every written chunk gets output as-is.
-var fileSystem_1 = fileSystem;
-/* Find files from the file-system. */
-function fileSystem(context, settings, next) {
- var input = context.files;
- var skip = settings.silentlyIgnore;
- var ignore = new ignore$2({
- cwd: settings.cwd,
- detectIgnore: settings.detectIgnore,
- ignoreName: settings.ignoreName,
- ignorePath: settings.ignorePath
- });
- if (input.length === 0) {
- return next();
- }
+module.exports = PassThrough;
- finder(input, {
- cwd: settings.cwd,
- extensions: settings.extensions,
- silentlyIgnore: skip,
- ignore: ignore
- }, found);
+var Transform = __webpack_require__(72);
- function found(err, result) {
- var output = result.files;
+/*<replacement>*/
+var util = __webpack_require__(22);
+util.inherits = __webpack_require__(13);
+/*</replacement>*/
- /* 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;
- });
+util.inherits(PassThrough, Transform);
- /* Mark as given. This allows outputting files,
- * which can be pretty dangerous, so it’s “hidden”. */
- output.forEach(function (file) {
- file.data.unifiedEngineGiven = true;
- });
+function PassThrough(options) {
+ if (!(this instanceof PassThrough)) return new PassThrough(options);
- context.files = output;
+ Transform.call(this, options);
+}
- /* 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;
- }
+PassThrough.prototype._transform = function (chunk, encoding, cb) {
+ cb(null, chunk);
+};
- next(err);
- }
-}
+/***/ }),
+/* 167 */
+/***/ (function(module, exports) {
-var toString$2 = Object.prototype.toString;
+var toString = Object.prototype.toString
var isModern = (
typeof Buffer.alloc === 'function' &&
typeof Buffer.allocUnsafe === 'function' &&
typeof Buffer.from === 'function'
-);
+)
function isArrayBuffer (input) {
- return toString$2.call(input).slice(8, -1) === 'ArrayBuffer'
+ return toString.call(input).slice(8, -1) === 'ArrayBuffer'
}
function fromArrayBuffer (obj, byteOffset, length) {
- byteOffset >>>= 0;
+ byteOffset >>>= 0
- var maxLength = obj.byteLength - byteOffset;
+ var maxLength = obj.byteLength - byteOffset
if (maxLength < 0) {
throw new RangeError("'offset' is out of bounds")
}
if (length === undefined) {
- length = maxLength;
+ length = maxLength
} else {
- length >>>= 0;
+ length >>>= 0
if (length > maxLength) {
throw new RangeError("'length' is out of bounds")
@@ -11318,7 +24149,7 @@ function fromArrayBuffer (obj, byteOffset, length) {
function fromString (string, encoding) {
if (typeof encoding !== 'string' || encoding === '') {
- encoding = 'utf8';
+ encoding = 'utf8'
}
if (!Buffer.isEncoding(encoding)) {
@@ -11348,9 +24179,13 @@ function bufferFrom (value, encodingOrOffset, length) {
: new Buffer(value)
}
-var bufferFrom_1 = bufferFrom;
+module.exports = bufferFrom
+
+
+/***/ }),
+/* 168 */
+/***/ (function(module, exports) {
-var typedarray = createCommonjsModule(function (module, exports) {
var undefined = (void 0); // Paranoia
// Beyond this value, index getters/setters (i.e. array[0], array[1]) are so slow to
@@ -11402,7 +24237,7 @@ function configureProperties(obj) {
// 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;
+var defineProp
if (Object.defineProperty && (function() {
try {
Object.defineProperty({}, 'x', {});
@@ -11981,221 +24816,81 @@ function packF32(v) { return packIEEE754(v, 8, 23); }
exports.DataView = exports.DataView || DataView;
}());
-});
-
-var typedarray_1 = typedarray.ArrayBuffer;
-var typedarray_2 = typedarray.Int8Array;
-var typedarray_3 = typedarray.Uint8Array;
-var typedarray_4 = typedarray.Uint8ClampedArray;
-var typedarray_5 = typedarray.Int16Array;
-var typedarray_6 = typedarray.Uint16Array;
-var typedarray_7 = typedarray.Int32Array;
-var typedarray_8 = typedarray.Uint32Array;
-var typedarray_9 = typedarray.Float32Array;
-var typedarray_10 = typedarray.Float64Array;
-var typedarray_11 = typedarray.DataView;
-var Writable = stream.Writable;
+/***/ }),
+/* 169 */
+/***/ (function(module, exports, __webpack_require__) {
+"use strict";
-if (typeof Uint8Array === 'undefined') {
- var U8 = typedarray.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 });
+var FileSet = __webpack_require__(170);
+var filePipeline = __webpack_require__(171);
- this.encoding = encoding;
- this.shouldInferEncoding = shouldInferEncoding;
-
- if (cb) this.on('finish', function () { cb(this.getBody()); });
- this.body = [];
-}
-
-var concatStream = 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'
-};
+module.exports = transform;
-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
-};
+/* Transform all files. */
+function transform(context, settings, next) {
+ var fileSet = new FileSet();
-function isArrayish$3 (arr) {
- return /Array\]$/.test(Object.prototype.toString.call(arr))
-}
+ context.fileSet = fileSet;
-function isBufferish (p) {
- return typeof p === 'string' || isArrayish$3(p) || (p && typeof p.subarray === 'function')
-}
+ fileSet.on('add', add).on('done', next);
-function stringConcat (parts) {
- var strings = [];
- 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_1(p));
- } else {
- strings.push(bufferFrom_1(String(p)));
- }
- }
- if (Buffer.isBuffer(parts[0])) {
- strings = Buffer.concat(strings);
- strings = strings.toString('utf8');
+ if (context.files.length === 0) {
+ next();
} else {
- strings = strings.join('');
+ context.files.forEach(fileSet.add, fileSet);
}
- 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_1(p));
- } else {
- bufs.push(bufferFrom_1(String(p)));
- }
- }
- return Buffer.concat(bufs)
-}
+ 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 arrayConcat (parts) {
- var res = [];
- for (var i = 0; i < parts.length; i++) {
- res.push.apply(res, parts[i]);
- }
- return res
-}
+ 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;
+ }
-function u8Concat (parts) {
- var len = 0;
- for (var i = 0; i < parts.length; i++) {
- if (typeof parts[i] === 'string') {
- parts[i] = bufferFrom_1(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];
+ fileSet.emit('one', file);
}
}
- return u8
}
-var debug$1 = src('unified-engine:file-set-pipeline:stdin');
-
-
-
-var stdin_1 = stdin;
-
-function stdin(context, settings, next) {
- var streamIn = settings.streamIn;
- var err;
-
- if (settings.files && settings.files.length !== 0) {
- debug$1('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$1('Cannot read from `tty` stream');
- next(new Error('No input'));
-
- return;
- }
-
- debug$1('Reading from `streamIn`');
-
- streamIn.pipe(concatStream({encoding: 'string'}, read));
-
- function read(value) {
- var file = toVfile(settings.filePath || undefined);
-
- debug$1('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();
- }
-}
-var inherits$3 = util.inherits;
+/***/ }),
+/* 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);
-var fileSet = FileSet;
+module.exports = FileSet;
/* FileSet constructor. */
function FileSet() {
@@ -12207,7 +24902,7 @@ function FileSet() {
self.expected = 0;
self.actual = 0;
- self.pipeline = trough_1();
+ self.pipeline = trough();
self.plugins = [];
events.init.call(self);
@@ -12216,7 +24911,7 @@ function FileSet() {
}
/* Events. */
-inherits$3(FileSet, events.EventEmitter);
+inherits(FileSet, events.EventEmitter);
/* Expose methods. */
FileSet.prototype.valueOf = valueOf;
@@ -12263,8 +24958,8 @@ function add(file) {
var self = this;
var origin;
- if (xIsString(file)) {
- file = toVfile(file);
+ if (string(file)) {
+ file = vfile(file);
}
/* Prevent files from being added multiple times. */
@@ -12304,140 +24999,128 @@ function one() {
}
}
-var debug$2 = src('unified-engine:file-pipeline:read');
-
-var read_1 = read$2;
+/***/ }),
+/* 171 */
+/***/ (function(module, exports, __webpack_require__) {
-var resolve$4 = path.resolve;
-var readFile = fs.readFile;
-
-/* Fill a file with its contents when not already filled. */
-function read$2(context, file, fileSet, next) {
- var filePath = file.path;
+"use strict";
- if (file.contents || file.data.unifiedEngineStreamIn) {
- debug$2('Not reading file `%s` with contents', filePath);
- next();
- } else if (vfileStatistics(file).fatal) {
- debug$2('Not reading failed file `%s`', filePath);
- next();
- } else {
- filePath = resolve$4(context.cwd, filePath);
- debug$2('Reading `%s` in `%s`', filePath, 'utf8');
+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);
- readFile(filePath, 'utf8', function (err, contents) {
- debug$2('Read `%s` (err: %s)', filePath, err);
+/* 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)));
- file.contents = contents || '';
+/* 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;
- next(err);
- });
- }
-}
+ /* Run the bound bound pipe and handles any errors. */
+ function run(context, file, fileSet, next) {
+ pipe.run(context, file, fileSet, one);
-var fnName = function (fn) {
- if (typeof fn !== 'function') {
- throw new TypeError('Expected a function');
- }
+ function one(err) {
+ var messages = file.messages;
+ var index;
- return fn.displayName || fn.name || (/function ([^\(]+)?\(/.exec(fn.toString()) || [])[1] || null;
-};
+ if (err) {
+ index = messages.indexOf(err);
-/**
- * Has own property.
- *
- * @type {Function}
- */
+ if (index === -1) {
+ err = file.message(err);
+ index = messages.length - 1;
+ }
-var has = Object.prototype.hasOwnProperty;
+ messages[index].fatal = true;
+ }
-/**
- * To string.
- *
- * @type {Function}
- */
+ next();
+ }
+ }
+}
-var toString$3 = Object.prototype.toString;
-/**
- * Test whether a value is "empty".
- *
- * @param {Mixed} val
- * @return {Boolean}
- */
+/***/ }),
+/* 172 */
+/***/ (function(module, exports, __webpack_require__) {
-function isEmpty(val) {
- // Null and Undefined...
- if (val == null) return true
+"use strict";
- // Booleans...
- if ('boolean' == typeof val) return false
- // Numbers...
- if ('number' == typeof val) return val === 0
+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);
- // Strings...
- if ('string' == typeof val) return val.length === 0
+module.exports = read;
- // Functions...
- if ('function' == typeof val) return val.length === 0
+var resolve = path.resolve;
+var readFile = fs.readFile;
- // Arrays...
- if (Array.isArray(val)) return val.length === 0
+/* Fill a file with its contents when not already filled. */
+function read(context, file, fileSet, next) {
+ var filePath = file.path;
- // Errors...
- if (val instanceof Error) return val.message === ''
+ 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);
- // Objects...
- if (val.toString == toString$3) {
- switch (val.toString()) {
+ debug('Reading `%s` in `%s`', filePath, 'utf8');
- // Maps, Sets, Files and Errors...
- case '[object File]':
- case '[object Map]':
- case '[object Set]': {
- return val.size === 0
- }
+ readFile(filePath, 'utf8', function (err, contents) {
+ debug('Read `%s` (err: %s)', filePath, err);
- // Plain objects...
- case '[object Object]': {
- for (var key in val) {
- if (has.call(val, key)) return false
- }
+ file.contents = contents || '';
- return true
- }
- }
+ next(err);
+ });
}
-
- // Anything else...
- return false
}
-/**
- * Export `isEmpty`.
- *
- * @type {Function}
- */
-
-var lib = isEmpty;
-
-var debug$3 = src('unified-engine:file-pipeline:configure');
+/***/ }),
+/* 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);
-var configure_1$2 = configure$1;
+module.exports = configure;
/* Collect configuration for a file based on the context. */
-function configure$1(context, file, fileSet, next) {
+function configure(context, file, fileSet, next) {
var config = context.configuration;
var processor = context.processor;
- if (vfileStatistics(file).fatal) {
+ if (stats(file).fatal) {
return next();
}
@@ -12456,14 +25139,14 @@ function configure$1(context, file, fileSet, next) {
}
/* Store configuration on the context object. */
- debug$3('Using settings `%j`', configuration.settings);
+ debug('Using settings `%j`', configuration.settings);
processor.data('settings', configuration.settings);
plugins = configuration.plugins;
length = plugins.length;
index = -1;
- debug$3('Using `%d` plugins', length);
+ debug('Using `%d` plugins', length);
while (++index < length) {
plugin = plugins[index][0];
@@ -12474,12 +25157,12 @@ function configure$1(context, file, fileSet, next) {
}
/* Allow for default arguments in es2020. */
- if (options === null || (isObject$1(options) && lib(options))) {
+ if (options === null || (object(options) && empty(options))) {
options = undefined;
}
name = fnName(plugin) || 'function';
- debug$3('Using plug-in `%s`, with options `%j`', name, options);
+ debug('Using plug-in `%s`, with options `%j`', name, options);
try {
processor.use(plugin, options, fileSet);
@@ -12493,25 +25176,48 @@ function configure$1(context, file, fileSet, next) {
}
}
-var debug$4 = src('unified-engine:file-pipeline:parse');
+/***/ }),
+/* 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 parse_1 = parse$3;
+
+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$3(context, file) {
+function parse(context, file) {
var message;
- if (vfileStatistics(file).fatal) {
+ if (stats(file).fatal) {
return;
}
if (context.treeIn) {
- debug$4('Not parsing already parsed document');
+ debug('Not parsing already parsed document');
try {
- context.tree = parseJson$1(file.toString());
+ context.tree = json(file.toString());
} catch (err) {
message = file.message(new Error('Cannot read file as JSON\n' + err.message));
message.fatal = true;
@@ -12529,40 +25235,56 @@ function parse$3(context, file) {
return;
}
- debug$4('Parsing `%s`', file.path);
+ debug('Parsing `%s`', file.path);
context.tree = context.processor.parse(file);
- debug$4('Parsed document');
+ debug('Parsed document');
}
-var debug$5 = src('unified-engine:file-pipeline:transform');
+
+/***/ }),
+/* 176 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
-var transform_1 = transform;
+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 (vfileStatistics(file).fatal) {
+ if (stats(file).fatal) {
next();
return;
}
- debug$5('Transforming document `%s`', file.path);
+ debug('Transforming document `%s`', file.path);
context.processor.run(context.tree, file, function (err, node) {
- debug$5('Transformed document (error: %s)', err);
+ debug('Transformed document (error: %s)', err);
context.tree = node;
next(err);
});
}
-var debug$6 = src('unified-engine:file-pipeline:queue');
+/***/ }),
+/* 177 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
-var queue_1 = queue;
+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
@@ -12577,14 +25299,14 @@ function queue(context, file, fileSet, next) {
fileSet.complete = map;
}
- debug$6('Queueing `%s`', origin);
+ debug('Queueing `%s`', origin);
map[origin] = next;
fileSet.valueOf().forEach(each);
if (!complete) {
- debug$6('Not flushing: some files cannot be flushed');
+ debug('Not flushing: some files cannot be flushed');
return;
}
@@ -12595,20 +25317,20 @@ function queue(context, file, fileSet, next) {
function each(file) {
var key = file.history[0];
- if (vfileStatistics(file).fatal) {
+ if (stats(file).fatal) {
return;
}
- if (xIsFunction(map[key])) {
- debug$6('`%s` can be flushed', key);
+ if (func(map[key])) {
+ debug('`%s` can be flushed', key);
} else {
- debug$6('Interupting flush: `%s` is not finished', key);
+ debug('Interupting flush: `%s` is not finished', key);
complete = false;
}
}
function done(err) {
- debug$6('Flushing: all files can be flushed');
+ debug('Flushing: all files can be flushed');
/* Flush. */
for (origin in map) {
@@ -12617,27 +25339,94 @@ function queue(context, file, fileSet, next) {
}
}
+
+/***/ }),
+/* 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;
+var color = true
try {
- color = 'inspect' in util;
+ color = 'inspect' in __webpack_require__(11)
} catch (err) {
/* istanbul ignore next - browser */
- color = false;
+ color = false
}
-var unistUtilInspect = color ? inspect : /* istanbul ignore next */ noColor;
+module.exports = color ? inspect : /* istanbul ignore next */ noColor
-inspect.color = inspect;
-noColor.color = inspect;
-inspect.noColor = noColor;
-noColor.noColor = 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);
+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(
@@ -12650,12 +25439,12 @@ var COLOR_EXPRESSION = new RegExp(
')|' +
'\\u001b[A-M]',
'g'
-);
+)
/* Standard keys defined by unist:
* https://github.com/syntax-tree/unist.
* We don’t ignore `data` though. */
-var ignore$4 = ['type', 'value', 'children', 'position'];
+var ignore = ['type', 'value', 'children', 'position']
/* Inspects a node, without using color. */
function noColor(node, pad) {
@@ -12664,18 +25453,18 @@ function noColor(node, pad) {
/* Inspects a node. */
function inspect(node, pad) {
- var result;
- var children;
- var index;
- var length;
+ var result
+ var children
+ var index
+ var length
if (node && Boolean(node.length) && typeof node !== 'string') {
- length = node.length;
- index = -1;
- result = [];
+ length = node.length
+ index = -1
+ result = []
while (++index < length) {
- result[index] = inspect(node[index]);
+ result[index] = inspect(node[index])
}
return result.join('\n')
@@ -12685,26 +25474,26 @@ function inspect(node, pad) {
return String(node)
}
- result = [formatNode(node)];
- children = node.children;
- length = children && children.length;
- index = -1;
+ result = [formatNode(node)]
+ children = node.children
+ length = children && children.length
+ index = -1
if (!length) {
return result[0]
}
if (!pad || typeof pad === 'number') {
- pad = '';
+ pad = ''
}
while (++index < length) {
- node = children[index];
+ node = children[index]
if (index === length - 1) {
- result.push(formatNesting(pad + '└─ ') + inspect(node, pad + ' '));
+ result.push(formatNesting(pad + '└─ ') + inspect(node, pad + ' '))
} else {
- result.push(formatNesting(pad + '├─ ') + inspect(node, pad + '│ '));
+ result.push(formatNesting(pad + '├─ ') + inspect(node, pad + '│ '))
}
}
@@ -12718,49 +25507,49 @@ function formatNesting(value) {
/* Compile a single position. */
function compile(pos) {
- var values = [];
+ var values = []
if (!pos) {
return null
}
- values = [[pos.line || 1, pos.column || 1].join(':')];
+ values = [[pos.line || 1, pos.column || 1].join(':')]
if ('offset' in pos) {
- values.push(String(pos.offset || 0));
+ values.push(String(pos.offset || 0))
}
return values
}
/* Compile a location. */
-function stringify$2(start, end) {
- var values = [];
- var positions = [];
- var offsets = [];
+function stringify(start, end) {
+ var values = []
+ var positions = []
+ var offsets = []
- add(start);
- add(end);
+ add(start)
+ add(end)
if (positions.length !== 0) {
- values.push(positions.join('-'));
+ values.push(positions.join('-'))
}
if (offsets.length !== 0) {
- values.push(offsets.join('-'));
+ values.push(offsets.join('-'))
}
return values.join(', ')
/* Add a position. */
function add(position) {
- var tuple = compile(position);
+ var tuple = compile(position)
if (tuple) {
- positions.push(tuple[0]);
+ positions.push(tuple[0])
if (tuple[1]) {
- offsets.push(tuple[1]);
+ offsets.push(tuple[1])
}
}
}
@@ -12768,40 +25557,40 @@ function stringify$2(start, end) {
/* Colored node formatter. */
function formatNode(node) {
- var log = node.type;
- var location = node.position || {};
- var position = stringify$2(location.start, location.end);
- var key;
- var values = [];
- var value;
+ 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(']');
+ log += dim('[') + yellow(node.children.length) + dim(']')
} else if (typeof node.value === 'string') {
- log += dim(': ') + green(JSON.stringify(node.value));
+ log += dim(': ') + green(JSON.stringify(node.value))
}
if (position) {
- log += ' (' + position + ')';
+ log += ' (' + position + ')'
}
for (key in node) {
- value = node[key];
+ value = node[key]
if (
- ignore$4.indexOf(key) !== -1 ||
+ ignore.indexOf(key) !== -1 ||
value === null ||
value === undefined ||
- (typeof value === 'object' && lib(value))
+ (typeof value === 'object' && isEmpty(value))
) {
continue
}
- values.push('[' + key + '=' + JSON.stringify(value) + ']');
+ values.push('[' + key + '=' + JSON.stringify(value) + ']')
}
if (values.length !== 0) {
- log += ' ' + values.join('');
+ log += ' ' + values.join('')
}
return log
@@ -12821,64 +25610,25 @@ function ansiColor(open, close) {
}
}
-var debug$7 = src('unified-engine:file-pipeline:stringify');
-
-
-
-var stringify_1 = stringify$3;
-
-/* Stringify a tree. */
-function stringify$3(context, file) {
- var processor = context.processor;
- var tree = context.tree;
- var value;
-
- if (vfileStatistics(file).fatal) {
- debug$7('Not compiling failed document');
- return;
- }
-
- if (!context.output && !context.out && !context.alwaysStringify) {
- debug$7('Not compiling document without output settings');
- return;
- }
-
- debug$7('Compiling `%s`', file.path);
- if (context.inspect) {
- /* Add a `txt` extension if there’s a path. */
- if (file.path) {
- file.extname = '.txt';
- }
-
- value = unistUtilInspect[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;
+/***/ }),
+/* 180 */
+/***/ (function(module, exports, __webpack_require__) {
- debug$7('Compiled document');
-}
+"use strict";
-var debug$8 = src('unified-engine:file-pipeline:copy');
+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);
-var copy_1 = copy;
+module.exports = copy;
-var stat$1 = fs.stat;
-var dirname$2 = path.dirname;
-var resolve$5 = path.resolve;
-var relative$3 = path.relative;
+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) {
@@ -12887,16 +25637,16 @@ function copy(context, file, fileSet, next) {
var outpath = output;
var currentPath = file.path;
- if (!xIsString(outpath)) {
- debug$8('Not copying');
+ if (!string(outpath)) {
+ debug('Not copying');
return next();
}
- outpath = resolve$5(context.cwd, outpath);
+ outpath = resolve(context.cwd, outpath);
- debug$8('Copying `%s`', currentPath);
+ debug('Copying `%s`', currentPath);
- stat$1(outpath, onstatfile);
+ stat(outpath, onstatfile);
function onstatfile(err, stats) {
if (err) {
@@ -12904,7 +25654,7 @@ function copy(context, file, fileSet, next) {
return next(new Error('Cannot read output directory. Error:\n' + err.message));
}
- stat$1(dirname$2(outpath), onstatparent);
+ stat(dirname(outpath), onstatparent);
} else {
done(stats.isDirectory());
}
@@ -12926,363 +25676,162 @@ function copy(context, file, fileSet, next) {
return next(new Error('Cannot write multiple files to single output: ' + outpath));
}
- file[directory ? 'dirname' : 'path'] = relative$3(file.cwd, outpath);
+ file[directory ? 'dirname' : 'path'] = relative(file.cwd, outpath);
- debug$8('Copying document from %s to %s', currentPath, file.path);
+ debug('Copying document from %s to %s', currentPath, file.path);
next();
}
}
-var debug$9 = src('unified-engine:file-pipeline:stdout');
+/***/ }),
+/* 181 */
+/***/ (function(module, exports, __webpack_require__) {
-var stdout_1 = stdout;
+"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$9('Ignoring programmatically added file');
+ debug('Ignoring programmatically added file');
next();
- } else if (vfileStatistics(file).fatal || context.output || !context.out) {
- debug$9('Ignoring writing to `streamOut`');
+ } else if (stats(file).fatal || context.output || !context.out) {
+ debug('Ignoring writing to `streamOut`');
next();
} else {
- debug$9('Writing document to `streamOut`');
+ debug('Writing document to `streamOut`');
context.streamOut.write(file.toString(), next);
}
}
-var debug$10 = src('unified-engine:file-pipeline:file-system');
-var fileSystem_1$2 = fileSystem$1;
+/***/ }),
+/* 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$6 = path.resolve;
+var resolve = path.resolve;
/* Write a virtual file to the file-system.
* Ignored when `output` is not given. */
-function fileSystem$1(context, file, fileSet, next) {
+function fileSystem(context, file, fileSet, next) {
var destinationPath;
if (!context.output) {
- debug$10('Ignoring writing to file-system');
+ debug('Ignoring writing to file-system');
return next();
}
if (!file.data.unifiedEngineGiven) {
- debug$10('Ignoring programmatically added file');
+ debug('Ignoring programmatically added file');
return next();
}
destinationPath = file.path;
if (!destinationPath) {
- debug$10('Cannot write file without a `destinationPath`');
+ debug('Cannot write file without a `destinationPath`');
return next(new Error('Cannot write file without an output path '));
}
- destinationPath = resolve$6(context.cwd, destinationPath);
- debug$10('Writing document to `%s`', destinationPath);
+ destinationPath = resolve(context.cwd, destinationPath);
+ debug('Writing document to `%s`', destinationPath);
file.stored = true;
writeFile(destinationPath, file.toString(), next);
}
-/* Expose: This pipeline ensures each of the pipes
- * always runs: even if the read pipe fails,
- * queue and write trigger. */
-var filePipeline = trough_1()
- .use(chunk(trough_1().use(read_1).use(configure_1$2).use(parse_1).use(transform_1)))
- .use(chunk(trough_1().use(queue_1)))
- .use(chunk(trough_1().use(stringify_1).use(copy_1).use(stdout_1).use(fileSystem_1$2)));
-
-/* 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;
- }
+/***/ }),
+/* 183 */
+/***/ (function(module, exports, __webpack_require__) {
- next();
- }
- }
-}
+"use strict";
-var transform_1$2 = transform$2;
-/* Transform all files. */
-function transform$2(context, settings, next) {
- var fileSet$$1 = new fileSet();
+var xtend = __webpack_require__(7);
+var load = __webpack_require__(55);
+var report = __webpack_require__(184);
+var string = __webpack_require__(17);
- context.fileSet = fileSet$$1;
+module.exports = log;
- fileSet$$1.on('add', add).on('done', next);
+var prefix = 'vfile-reporter';
- if (context.files.length === 0) {
- next();
- } else {
- context.files.forEach(fileSet$$1.add, fileSet$$1);
- }
-
- 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$$1, 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;
- }
+function log(context, settings, next) {
+ var reporter = settings.reporter || report;
+ var diagnostics;
- fileSet$$1.emit('one', file);
+ if (string(reporter)) {
+ try {
+ reporter = load(reporter, {cwd: settings.cwd, prefix: prefix});
+ } catch (err) {
+ next(new Error('Could not find reporter `' + reporter + '`'));
+ return;
}
}
-}
-
-var ansiRegex = function () {
- return /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-PRZcf-nqry=><]/g;
-};
-
-var ansiRegex$2 = ansiRegex();
-
-var stripAnsi = function (str) {
- return typeof str === 'string' ? str.replace(ansiRegex$2, '') : str;
-};
-
-/* eslint-disable babel/new-cap, xo/throw-new-error */
-var codePointAt = 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;
-};
-
-var numberIsNan = Number.isNaN || function (x) {
- return x !== x;
-};
-
-var isFullwidthCodePoint = 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;
-};
-
-// https://github.com/nodejs/io.js/blob/cff7300a578be1b10001f2d967aaedc88aee6402/lib/readline.js#L1345
-var stringWidth = 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;
-};
-
-/*!
- * repeat-string <https://github.com/jonschlinkert/repeat-string>
- *
- * Copyright (c) 2014-2015, Jon Schlinkert.
- * Licensed under the MIT License.
- */
-
-/**
- * Results cache
- */
-
-var res = '';
-var cache$1;
-
-/**
- * Expose `repeat`
- */
-
-var repeatString = repeat$1;
-
-/**
- * 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$1(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$1 !== str || typeof cache$1 === 'undefined') {
- cache$1 = str;
- res = '';
- } else if (res.length >= max) {
- return res.substr(0, max);
- }
+ diagnostics = reporter(context.files.filter(given), xtend(settings.reporterOptions, {
+ quiet: settings.quiet,
+ silent: settings.silent,
+ color: settings.color
+ }));
- while (max > res.length && num > 1) {
- if (num & 1) {
- res += str;
+ if (diagnostics) {
+ if (diagnostics.charAt(diagnostics.length - 1) !== '\n') {
+ diagnostics += '\n';
}
- num >>= 1;
- str += str;
+ settings.streamError.write(diagnostics, next);
+ } else {
+ next();
}
+}
- res += str;
- res = res.substr(0, max);
- return res;
+function given(file) {
+ return file.data.unifiedEngineGiven;
}
-var supported = supportsColor.hasBasic;
+/***/ }),
+/* 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);
-var vfileReporter = reporter;
+module.exports = reporter;
/* Check which characters should be used. */
-var windows$1 = process.platform === 'win32';
+var windows = process.platform === 'win32';
/* `log-symbols` without chalk: */
/* istanbul ignore next - Windows. */
-var chars = windows$1 ? {error: '×', warning: '‼'} : {error: '✖', warning: '⚠'};
+var chars = windows ? {error: '×', warning: '‼'} : {error: '✖', warning: '⚠'};
/* Match trailing white-space. */
var trailing = /\s*$/;
@@ -13333,10 +25882,10 @@ function reporter(files, options) {
files = [files];
}
- return compile$1(parse$5(filter$2(files, settings), settings), one, settings);
+ return compile(parse(filter(files, settings), settings), one, settings);
}
-function filter$2(files, options) {
+function filter(files, options) {
var result = [];
var length = files.length;
var index = -1;
@@ -13357,7 +25906,7 @@ function filter$2(files, options) {
return result;
}
-function parse$5(files, options) {
+function parse(files, options) {
var length = files.length;
var index = -1;
var rows = [];
@@ -13395,7 +25944,7 @@ function parse$5(files, options) {
name: origin || options.defaultName || DEFAULT,
stored: Boolean(file.stored),
moved: Boolean(file.stored && destination !== origin),
- stats: vfileStatistics(messages)
+ stats: statistics(messages)
});
offset = -1;
@@ -13406,7 +25955,7 @@ function parse$5(files, options) {
id = message.ruleId || '';
reason = message.stack || message.message;
loc = message.location;
- loc = unistUtilStringifyPosition(loc.end.line && loc.end.column ? loc : loc.start);
+ loc = stringify(loc.end.line && loc.end.column ? loc : loc.start);
if (options.verbose && message.note) {
reason += '\n' + message.note;
@@ -13433,7 +25982,7 @@ function parse$5(files, options) {
return {
rows: rows,
- statistics: vfileStatistics(all),
+ statistics: statistics(all),
location: locationSize,
label: labelSize,
reason: reasonSize,
@@ -13441,7 +25990,7 @@ function parse$5(files, options) {
};
}
-function compile$1(map, one, options) {
+function compile(map, one, options) {
var enabled = options.color;
var all = map.statistics;
var rows = map.rows;
@@ -13507,7 +26056,7 @@ function compile$1(map, one, options) {
line.push([
style.red.open + chars.error + style.red.close,
all.fatal,
- plural$1(labels.true, all.fatal)
+ plural(labels.true, all.fatal)
].join(' '));
}
@@ -13515,7 +26064,7 @@ function compile$1(map, one, options) {
line.push([
style.yellow.open + chars.warning + style.yellow.close,
all.warn,
- plural$1(labels.false, all.warn)
+ plural(labels.false, all.warn)
].join(' '));
}
@@ -13553,26 +26102,26 @@ function applicable(file, options) {
/* Get the length of `value`, ignoring ANSI sequences. */
function realLength(value) {
var length = value.indexOf('\n');
- return stringWidth(length === -1 ? value : value.slice(0, length));
+ return width(length === -1 ? value : value.slice(0, length));
}
/* Pad `value` on the left. */
function padLeft(value, minimum) {
- return repeatString(' ', minimum - realLength(value)) + value;
+ return repeat(' ', minimum - realLength(value)) + value;
}
/* Pad `value` on the Right. */
function padRight(value, minimum) {
- return value + repeatString(' ', minimum - realLength(value));
+ return value + repeat(' ', minimum - realLength(value));
}
/* Comparator. */
function comparator(a, b) {
- return check$1(a, b, 'line') || check$1(a, b, 'column') || -1;
+ return check(a, b, 'line') || check(a, b, 'column') || -1;
}
/* Compare a single property. */
-function check$1(a, b, property) {
+function check(a, b, property) {
return (a[property] || 0) - (b[property] || 0);
}
@@ -13585,542 +26134,197 @@ function current(file) {
return file.path;
}
-function plural$1(value, count) {
+function plural(value, count) {
return count === 1 ? value : value + 's';
}
-var log_1 = log;
-
-var prefix$1 = 'vfile-reporter';
-
-function log(context, settings, next) {
- var reporter = settings.reporter || vfileReporter;
- var diagnostics;
-
- if (xIsString(reporter)) {
- try {
- reporter = loadPlugin_1(reporter, {cwd: settings.cwd, prefix: prefix$1});
- } catch (err) {
- next(new Error('Could not find reporter `' + reporter + '`'));
- return;
- }
- }
-
- diagnostics = reporter(context.files.filter(given), immutable(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;
-}
-
-var fileSetPipeline = trough_1()
- .use(configure_1)
- .use(fileSystem_1)
- .use(stdin_1)
- .use(transform_1$2)
- .use(log_1);
-
-var PassThrough = stream.PassThrough;
+/***/ }),
+/* 185 */
+/***/ (function(module, exports, __webpack_require__) {
+"use strict";
-var lib$2 = run;
+var stripAnsi = __webpack_require__(186);
+var codePointAt = __webpack_require__(188);
+var isFullwidthCodePoint = __webpack_require__(189);
-/* 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;
+// 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;
+ }
- settings.treeIn = options.treeIn;
- settings.treeOut = options.treeOut;
- settings.inspect = options.inspect;
+ var width = 0;
- if (settings.treeIn === null || settings.treeIn === undefined) {
- settings.treeIn = tree;
- }
+ str = stripAnsi(str);
- if (settings.treeOut === null || settings.treeOut === undefined) {
- settings.treeOut = tree;
- }
+ for (var i = 0; i < str.length; i++) {
+ var code = codePointAt(str, i);
- /* Configuration. */
- detectConfig = options.detectConfig;
- hasConfig = Boolean(options.rcName || options.packageField);
+ // ignore control characters
+ if (code <= 0x1f || (code >= 0x7f && code <= 0x9f)) {
+ continue;
+ }
- if (detectConfig && !hasConfig) {
- return next(new Error(
- 'Missing `rcName` or `packageField` with `detectConfig`'
- ));
- }
+ // surrogates
+ if (code >= 0x10000) {
+ i++;
+ }
- 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;
+ if (isFullwidthCodePoint(code)) {
+ width += 2;
+ } else {
+ width++;
+ }
+ }
- /* Ignore. */
- detectIgnore = options.detectIgnore;
- hasIgnore = Boolean(options.ignoreName);
+ return width;
+};
- 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`'));
- }
+/***/ }),
+/* 186 */
+/***/ (function(module, exports, __webpack_require__) {
- /* Plug-ins. */
- settings.pluginPrefix = options.pluginPrefix || null;
- settings.plugins = options.plugins || {};
+"use strict";
- /* 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;
+var ansiRegex = __webpack_require__(187)();
- /* Process. */
- fileSetPipeline.run({files: options.files || []}, settings, next);
+module.exports = function (str) {
+ return typeof str === 'string' ? str.replace(ansiRegex, '') : str;
+};
- function next(err, context) {
- var stats = vfileStatistics((context || {}).files);
- var failed = Boolean(settings.frail ? stats.fatal || stats.warn : stats.fatal);
- if (err) {
- callback(err);
- } else {
- callback(null, failed ? 1 : 0, context);
- }
- }
-}
+/***/ }),
+/* 187 */
+/***/ (function(module, exports, __webpack_require__) {
-var textTable = 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; };
+"use strict";
- 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;
- }, []);
+module.exports = function () {
+ return /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-PRZcf-nqry=><]/g;
+};
- var rows = map$2(rows_, function (row) {
- return map$2(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;
- }, []);
+/***/ }),
+/* 188 */
+/***/ (function(module, exports, __webpack_require__) {
- return map$2(rows, function (row) {
- return map$2(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(' ')
- ;
- }
+"use strict";
+/* eslint-disable babel/new-cap, xo/throw-new-error */
- return c + s;
- }).join(hsep).replace(/\s+$/, '');
- }).join('\n');
-};
+module.exports = function (str, pos) {
+ if (str === null || str === undefined) {
+ throw TypeError();
+ }
-function dotindex (c) {
- var m = /\.[^.]*$/.exec(c);
- return m ? m.index + 1 : c.length;
-}
+ str = String(str);
-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;
-}
+ var size = str.length;
+ var i = pos ? Number(pos) : 0;
-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);
- }
-}
+ if (Number.isNaN(i)) {
+ i = 0;
+ }
-function map$2 (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;
-}
+ if (i < 0 || i >= size) {
+ return undefined;
+ }
-var camelcase = createCommonjsModule(function (module) {
-const preserveCamelCase = input => {
- let isLastCharLower = false;
- let isLastCharUpper = false;
- let isLastLastCharUpper = false;
+ var first = str.charCodeAt(i);
- for (let i = 0; i < input.length; i++) {
- const c = input[i];
+ if (first >= 0xD800 && first <= 0xDBFF && size > i + 1) {
+ var second = str.charCodeAt(i + 1);
- 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;
+ if (second >= 0xDC00 && second <= 0xDFFF) {
+ return ((first - 0xD800) * 0x400) + second - 0xDC00 + 0x10000;
}
}
- return input;
+ return first;
};
-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();
- }
+/***/ }),
+/* 189 */
+/***/ (function(module, exports, __webpack_require__) {
- if (input.length === 0) {
- return '';
- }
+"use strict";
- if (input.length === 1) {
- return options.pascalCase ? input.toUpperCase() : input.toLowerCase();
- }
+var numberIsNan = __webpack_require__(190);
- if (/^[a-z\d]+$/.test(input)) {
- return postProcess(input);
+module.exports = function (x) {
+ if (numberIsNan(x)) {
+ return false;
}
- const hasUpperCase = input !== input.toLowerCase();
+ // https://github.com/nodejs/io.js/blob/cff7300a578be1b10001f2d967aaedc88aee6402/lib/readline.js#L1369
- if (hasUpperCase) {
- input = preserveCamelCase(input);
+ // 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;
}
- input = input
- .replace(/^[_.\- ]+/, '')
- .toLowerCase()
- .replace(/[_.\- ]+(\w|$)/g, (m, p1) => p1.toUpperCase());
-
- return postProcess(input);
-};
-});
-
-var unicode = createCommonjsModule(function (module, exports) {
-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]/;
-});
-
-unwrapExports(unicode);
-var unicode_1 = unicode.Space_Separator;
-var unicode_2 = unicode.ID_Start;
-var unicode_3 = unicode.ID_Continue;
-
-var util$1 = createCommonjsModule(function (module, exports) {
-Object.defineProperty(exports,'__esModule',{value:true});exports.isSpaceSeparator=isSpaceSeparator;exports.isIdStartChar=isIdStartChar;exports.isIdContinueChar=isIdContinueChar;exports.isDigit=isDigit;exports.isHexDigit=isHexDigit;var unicode$$1=_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$$1.Space_Separator.test(c)}function isIdStartChar(c){return c>='a'&&c<='z'||c>='A'&&c<='Z'||c==='$'||c==='_'||unicode$$1.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$$1.ID_Continue.test(c)}function isDigit(c){return /[0-9]/.test(c)}function isHexDigit(c){return /[0-9A-Fa-f]/.test(c)}
-});
-
-unwrapExports(util$1);
-var util_1 = util$1.isSpaceSeparator;
-var util_2 = util$1.isIdStartChar;
-var util_3 = util$1.isIdContinueChar;
-var util_4 = util$1.isDigit;
-var util_5 = util$1.isHexDigit;
+ return false;
+}
-var parse_1$2 = createCommonjsModule(function (module, exports) {
-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$$1=_interopRequireWildcard(util$1);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$$1.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$$1.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$$1.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$$1.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$$1.isDigit(c)){buffer+=read();return}return newToken('numeric',_sign*Number(buffer))},decimalPointLeading:function decimalPointLeading(){if(util$$1.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$$1.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$$1.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$$1.isDigit(c)){buffer+=read();lexState='decimalExponentInteger';return}throw invalidChar(read())},decimalExponentSign:function decimalExponentSign(){if(util$$1.isDigit(c)){buffer+=read();lexState='decimalExponentInteger';return}throw invalidChar(read())},decimalExponentInteger:function decimalExponentInteger(){if(util$$1.isDigit(c)){buffer+=read();return}return newToken('numeric',_sign*Number(buffer))},hexadecimal:function hexadecimal(){if(util$$1.isHexDigit(c)){buffer+=read();lexState='hexadecimalInteger';return}throw invalidChar(read())},hexadecimalInteger:function hexadecimalInteger(){if(util$$1.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$$1.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$$1.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$$1.isHexDigit(c)){throw invalidChar(read())}buffer+=read();c=peek();if(!util$$1.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$$1.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'];
-});
-unwrapExports(parse_1$2);
+/***/ }),
+/* 190 */
+/***/ (function(module, exports, __webpack_require__) {
-var stringify_1$2 = createCommonjsModule(function (module, exports) {
-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$$1=_interopRequireWildcard(util$1);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]<quotes[b]?a:b});product=product.replace(new RegExp(quoteChar,'g'),replacements[quoteChar]);return quoteChar+product+quoteChar}function serializeObject(value){if(stack.indexOf(value)>=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$$1.isIdStartChar(firstChar)){return quoteString(key,true)}for(var i=firstChar.length;i<key.length;i++){if(!util$$1.isIdContinueChar(String.fromCodePoint(key.codePointAt(i)))){return quoteString(key,true)}}return key}function serializeArray(value){if(stack.indexOf(value)>=0){throw TypeError('Converting circular structure to JSON5')}stack.push(value);var stepback=indent;indent=indent+gap;var partial=[];for(var i=0;i<value.length;i++){var propertyString=serializeProperty(String(i),value);partial.push(propertyString!==undefined?propertyString:'null');}var final=void 0;if(partial.length===0){final='[]';}else{if(gap===''){var properties=partial.join(',');final='['+properties+']';}else{var separator=',\n'+indent;var _properties=partial.join(separator);final='[\n'+indent+_properties+',\n'+stepback+']';}}stack.pop();indent=stepback;return final}}module.exports=exports['default'];
-});
+"use strict";
-unwrapExports(stringify_1$2);
+module.exports = Number.isNaN || function (x) {
+ return x !== x;
+};
-var lib$4 = createCommonjsModule(function (module, exports) {
-Object.defineProperty(exports,'__esModule',{value:true});var _parse2=_interopRequireDefault(parse_1$2);var _stringify2=_interopRequireDefault(stringify_1$2);function _interopRequireDefault(obj){return obj&&obj.__esModule?obj:{default:obj}}exports.default={parse:_parse2.default,stringify:_stringify2.default};module.exports=exports['default'];
-});
-unwrapExports(lib$4);
+/***/ }),
+/* 191 */
+/***/ (function(module, exports, __webpack_require__) {
-var schema$2 = [
- {
- "long": "help",
- "description": "output usage information",
- "short": "h",
- "type": "boolean",
- "default": false
- },
- {
- "long": "version",
- "description": "output version number",
- "short": "v",
- "type": "boolean",
- "default": false
- },
- {
- "long": "output",
- "description": "specify output location",
- "short": "o",
- "value": "[path]"
- },
- {
- "long": "rc-path",
- "description": "specify configuration file",
- "short": "r",
- "type": "string",
- "value": "<path>"
- },
- {
- "long": "ignore-path",
- "description": "specify ignore file",
- "short": "i",
- "type": "string",
- "value": "<path>"
- },
- {
- "long": "setting",
- "description": "specify settings",
- "short": "s",
- "type": "string",
- "value": "<settings>"
- },
- {
- "long": "ext",
- "description": "specify extensions",
- "short": "e",
- "type": "string",
- "value": "<extensions>"
- },
- {
- "long": "use",
- "description": "use plugins",
- "short": "u",
- "type": "string",
- "value": "<plugins>"
- },
- {
- "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": "<reporter>"
- },
- {
- "long": "file-path",
- "description": "specify path to process as",
- "type": "string",
- "value": "<path>"
- },
- {
- "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
- }
-]
-;
+"use strict";
-var schema$3 = Object.freeze({
- default: schema$2
-});
-var schema$4 = ( schema$3 && schema$2 ) || schema$3;
+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)
-var options_1 = options;
+module.exports = options
/* Schema for `minimist`. */
var minischema = {
@@ -14129,30 +26333,30 @@ var minischema = {
alias: {},
string: [],
boolean: []
-};
+}
-schema$4.forEach(addEach);
+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$4.forEach(function(option) {
+ 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_1('Missing value:%s', inspect$2(option).join(' '))
+ throw fault('Missing value:%s', inspect(option).join(' '))
}
- });
+ })
- ext = extensions(config.ext);
- report = reporter$1(config.report);
+ ext = extensions(config.ext)
+ report = reporter(config.report)
help = [
- inspectAll(schema$4),
+ inspectAll(schema),
'',
'Examples:',
'',
@@ -14164,7 +26368,7 @@ function options(flags, configuration) {
'',
' # Rewrite all applicable files',
' $ ' + name + ' . -o'
- ].join('\n');
+ ].join('\n')
return {
helpMessage: help,
@@ -14202,75 +26406,75 @@ function options(flags, configuration) {
}
function addEach(option) {
- var value = option.default;
+ var value = option.default
- minischema.default[option.long] = value === undefined ? null : value;
+ minischema.default[option.long] = value === undefined ? null : value
if (option.type in minischema) {
- minischema[option.type].push(option.long);
+ minischema[option.type].push(option.long)
}
if (option.short) {
- minischema.alias[option.short] = option.long;
+ minischema.alias[option.short] = option.long
}
}
/* Parse `extensions`. */
function extensions(value) {
- return flatten(normalize$1(value).map(splitList))
+ return flatten(normalize(value).map(splitList))
}
/* Parse `plugins`. */
function plugins(value) {
- var result = {};
+ var result = {}
- normalize$1(value)
+ normalize(value)
.map(splitOptions)
.forEach(function(value) {
- result[value[0]] = value[1] ? parseConfig(value[1], {}) : null;
- });
+ result[value[0]] = value[1] ? parseConfig(value[1], {}) : null
+ })
return result
}
/* Parse `reporter`: only one is accepted. */
-function reporter$1(value) {
- var all = normalize$1(value)
+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 = {};
+ var cache = {}
- normalize$1(value).forEach(function(value) {
- parseConfig(value, cache);
- });
+ normalize(value).forEach(function(value) {
+ parseConfig(value, cache)
+ })
return cache
}
/* Parse configuration. */
function parseConfig(flags, cache) {
- var flag;
- var message;
+ var flag
+ var message
try {
- flags = toCamelCase(parseJSON(flags));
+ flags = toCamelCase(parseJSON(flags))
} catch (err) {
/* Fix position */
- message = err.message.replace(/at(?= position)/, 'around');
+ message = err.message.replace(/at(?= position)/, 'around')
- throw fault_1('Cannot parse `%s` as JSON: %s', flags, message)
+ throw fault('Cannot parse `%s` as JSON: %s', flags, message)
}
for (flag in flags) {
- cache[flag] = flags[flag];
+ cache[flag] = flags[flag]
}
return cache
@@ -14285,32 +26489,32 @@ function handleUnknownArgument(flag) {
/* Long options. Always unknown. */
if (flag.charAt(1) === '-') {
- throw fault_1('Unknown option `%s`, expected:\n%s', flag, inspectAll(schema$4))
+ throw fault('Unknown option `%s`, expected:\n%s', flag, inspectAll(schema))
}
/* Short options. Can be grouped. */
flag
.slice(1)
.split('')
- .forEach(each);
+ .forEach(each)
function each(key) {
- var length = schema$4.length;
- var index = -1;
- var option;
+ var length = schema.length
+ var index = -1
+ var option
while (++index < length) {
- option = schema$4[index];
+ option = schema[index]
if (option.short === key) {
return
}
}
- throw fault_1(
+ throw fault(
'Unknown short option `-%s`, expected:\n%s',
key,
- inspectAll(schema$4.filter(short))
+ inspectAll(schema.filter(short))
)
}
@@ -14321,17 +26525,17 @@ function handleUnknownArgument(flag) {
/* Inspect all `options`. */
function inspectAll(options) {
- return textTable(options.map(inspect$2))
+ return table(options.map(inspect))
}
/* Inspect one `option`. */
-function inspect$2(option) {
- var description = option.description;
- var long = option.long;
+function inspect(option) {
+ var description = option.description
+ var long = option.long
if (option.default === true || option.truelike) {
- description += ' (on by default)';
- long = '[no-]' + long;
+ description += ' (on by default)'
+ long = '[no-]' + long
}
return [
@@ -14343,7 +26547,7 @@ function inspect$2(option) {
}
/* Normalize `value`. */
-function normalize$1(value) {
+function normalize(value) {
if (!value) {
return []
}
@@ -14352,7 +26556,7 @@ function normalize$1(value) {
return [value]
}
- return flatten(value.map(normalize$1))
+ return flatten(value.map(normalize))
}
/* Flatten `values`. */
@@ -14371,18 +26575,18 @@ function splitList(value) {
/* Transform the keys on an object to camel-case,
* recursivly. */
function toCamelCase(object) {
- var result = {};
- var value;
- var key;
+ var result = {}
+ var value
+ var key
for (key in object) {
- value = object[key];
+ value = object[key]
if (value && typeof value === 'object' && !('length' in value)) {
- value = toCamelCase(value);
+ value = toCamelCase(value)
}
- result[camelcase(key)] = value;
+ result[camelcase(key)] = value
}
return result
@@ -14390,454 +26594,334 @@ function toCamelCase(object) {
/* Parse a (lazy?) JSON config. */
function parseJSON(value) {
- return lib$4.parse('{' + value + '}')
-}
-
-var markdownExtensions = [
- "md",
- "markdown",
- "mdown",
- "mkdn",
- "mkd",
- "mdwn",
- "mkdown",
- "ron"
-]
-;
+ return json5.parse('{' + value + '}')
+}
-var markdownExtensions$1 = Object.freeze({
- default: markdownExtensions
-});
-var require$$0$14 = ( markdownExtensions$1 && markdownExtensions ) || markdownExtensions$1;
+/***/ }),
+/* 192 */
+/***/ (function(module, exports) {
-var markdownExtensions$2 = require$$0$14;
+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 hasOwn = Object.prototype.hasOwnProperty;
-var toStr = Object.prototype.toString;
-var defineProperty = Object.defineProperty;
-var gOPD = Object.getOwnPropertyDescriptor;
+ 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 isArray$2 = function isArray(arr) {
- if (typeof Array.isArray === 'function') {
- return Array.isArray(arr);
- }
+ 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;
+ });
+ });
- return toStr.call(arr) === '[object Array]';
-};
+ 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;
+ }, []);
-var isPlainObject = function isPlainObject(obj) {
- if (!obj || toStr.call(obj) !== '[object Object]') {
- return false;
- }
+ 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(' ')
+ ;
+ }
- 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;
- }
+ return c + s;
+ }).join(hsep).replace(/\s+$/, '');
+ }).join('\n');
+};
- // 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) { /**/ }
+function dotindex (c) {
+ var m = /\.[^.]*$/.exec(c);
+ return m ? m.index + 1 : c.length;
+}
- return typeof key === 'undefined' || hasOwn.call(obj, key);
-};
+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;
+}
-// 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;
- }
-};
+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);
+ }
+}
-// 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;
- }
- }
+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;
+}
- return obj[name];
-};
-var extend$3 = function extend() {
- var options, name, src, copy, copyIsArray, clone;
- var target = arguments[0];
- var i = 1;
- var length = arguments.length;
- var deep = false;
+/***/ }),
+/* 193 */
+/***/ (function(module, exports, __webpack_require__) {
- // 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 = {};
- }
+"use strict";
- 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$2(copy)))) {
- if (copyIsArray) {
- copyIsArray = false;
- clone = src && isArray$2(src) ? src : [];
- } else {
- clone = src && isPlainObject(src) ? src : {};
- }
+const preserveCamelCase = input => {
+ let isLastCharLower = false;
+ let isLastCharUpper = false;
+ let isLastLastCharUpper = false;
- // Never move original objects, clone them
- setProperty(target, { name: name, newValue: extend(deep, clone, copy) });
+ for (let i = 0; i < input.length; i++) {
+ const c = input[i];
- // Don't bring in undefined values
- } else if (typeof copy !== 'undefined') {
- setProperty(target, { name: name, newValue: copy });
- }
- }
- }
+ 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 the modified object
- return target;
-};
-
-var bail_1 = bail;
-
-function bail(err) {
- if (err) {
- throw err
- }
-}
-
-/*!
- * Determine if an object is a Buffer
- *
- * @author Feross Aboukhadijeh <https://feross.org>
- * @license MIT
- */
-
-var isBuffer$1 = function isBuffer (obj) {
- return obj != null && obj.constructor != null &&
- typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)
+ return input;
};
-var core$6 = VFile$2;
-
-var own$2 = {}.hasOwnProperty;
-var proto$3 = VFile$2.prototype;
-
-proto$3.toString = toString$4;
-
-// 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$1 = ['history', 'path', 'basename', 'stem', 'extname', 'dirname'];
-
-// Construct a new file.
-function VFile$2(options) {
- var prop;
- var index;
- var length;
-
- if (!options) {
- options = {};
- } else if (typeof options === 'string' || isBuffer$1(options)) {
- options = {contents: options};
- } else if ('message' in options && 'messages' in options) {
- return options
- }
-
- if (!(this instanceof VFile$2)) {
- return new VFile$2(options)
- }
+module.exports = (input, options) => {
+ options = Object.assign({
+ pascalCase: false
+ }, options);
- this.data = {};
- this.messages = [];
- this.history = [];
- this.cwd = process.cwd();
+ const postProcess = x => options.pascalCase ? x.charAt(0).toUpperCase() + x.slice(1) : x;
- // Set path related properties in the correct order.
- index = -1;
- length = order$1.length;
+ if (Array.isArray(input)) {
+ input = input.map(x => x.trim())
+ .filter(x => x.length)
+ .join('-');
+ } else {
+ input = input.trim();
+ }
- while (++index < length) {
- prop = order$1[index];
+ if (input.length === 0) {
+ return '';
+ }
- if (own$2.call(options, prop)) {
- this[prop] = options[prop];
- }
- }
+ if (input.length === 1) {
+ return options.pascalCase ? input.toUpperCase() : input.toLowerCase();
+ }
- // Set non-path related properties.
- for (prop in options) {
- if (order$1.indexOf(prop) === -1) {
- this[prop] = options[prop];
- }
- }
-}
+ if (/^[a-z\d]+$/.test(input)) {
+ return postProcess(input);
+ }
-// Access full path (`~/index.min.js`).
-Object.defineProperty(proto$3, 'path', {
- get: function() {
- return this.history[this.history.length - 1]
- },
- set: function(path$$1) {
- assertNonEmpty$1(path$$1, 'path');
+ const hasUpperCase = input !== input.toLowerCase();
- if (path$$1 !== this.path) {
- this.history.push(path$$1);
- }
- }
-});
+ if (hasUpperCase) {
+ input = preserveCamelCase(input);
+ }
-// Access parent path (`~`).
-Object.defineProperty(proto$3, 'dirname', {
- get: function() {
- return typeof this.path === 'string' ? path.dirname(this.path) : undefined
- },
- set: function(dirname) {
- assertPath$1(this.path, 'dirname');
- this.path = path.join(dirname || '', this.basename);
- }
-});
+ input = input
+ .replace(/^[_.\- ]+/, '')
+ .toLowerCase()
+ .replace(/[_.\- ]+(\w|$)/g, (m, p1) => p1.toUpperCase());
-// Access basename (`index.min.js`).
-Object.defineProperty(proto$3, 'basename', {
- get: function() {
- return typeof this.path === 'string' ? path.basename(this.path) : undefined
- },
- set: function(basename) {
- assertNonEmpty$1(basename, 'basename');
- assertPart$1(basename, 'basename');
- this.path = path.join(this.dirname || '', basename);
- }
-});
+ return postProcess(input);
+};
-// Access extname (`.js`).
-Object.defineProperty(proto$3, 'extname', {
- get: function() {
- return typeof this.path === 'string' ? path.extname(this.path) : undefined
- },
- set: function(extname) {
- var ext = extname || '';
- assertPart$1(ext, 'extname');
- assertPath$1(this.path, 'extname');
+/***/ }),
+/* 194 */
+/***/ (function(module, exports, __webpack_require__) {
- if (ext) {
- if (ext.charAt(0) !== '.') {
- throw new Error('`extname` must start with `.`')
- }
+"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'];
- if (ext.indexOf('.', 1) !== -1) {
- throw new Error('`extname` cannot contain multiple dots')
- }
- }
+/***/ }),
+/* 195 */
+/***/ (function(module, exports, __webpack_require__) {
- this.path = replaceExt_1(this.path, ext);
- }
-});
+"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'];
-// Access stem (`index.min`).
-Object.defineProperty(proto$3, 'stem', {
- get: function() {
- return typeof this.path === 'string'
- ? path.basename(this.path, this.extname)
- : undefined
- },
- set: function(stem) {
- assertNonEmpty$1(stem, 'stem');
- assertPart$1(stem, 'stem');
- this.path = path.join(this.dirname || '', stem + (this.extname || ''));
- }
-});
+/***/ }),
+/* 196 */
+/***/ (function(module, exports, __webpack_require__) {
-// Get the value of the file.
-function toString$4(encoding) {
- var value = this.contents || '';
- return isBuffer$1(value) ? value.toString(encoding) : String(value)
-}
+"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]/;
-// Assert that `part` is not a path (i.e., does not contain `path.sep`).
-function assertPart$1(part, name) {
- if (part.indexOf(path.sep) !== -1) {
- throw new Error(
- '`' + name + '` cannot be a path: did not expect `' + path.sep + '`'
- )
- }
-}
+/***/ }),
+/* 197 */
+/***/ (function(module, exports, __webpack_require__) {
-// Assert that `part` is not empty.
-function assertNonEmpty$1(part, name) {
- if (!part) {
- throw new Error('`' + name + '` cannot be empty')
- }
-}
+"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]<quotes[b]?a:b});product=product.replace(new RegExp(quoteChar,'g'),replacements[quoteChar]);return quoteChar+product+quoteChar}function serializeObject(value){if(stack.indexOf(value)>=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<key.length;i++){if(!util.isIdContinueChar(String.fromCodePoint(key.codePointAt(i)))){return quoteString(key,true)}}return key}function serializeArray(value){if(stack.indexOf(value)>=0){throw TypeError('Converting circular structure to JSON5')}stack.push(value);var stepback=indent;indent=indent+gap;var partial=[];for(var i=0;i<value.length;i++){var propertyString=serializeProperty(String(i),value);partial.push(propertyString!==undefined?propertyString:'null')}var final=void 0;if(partial.length===0){final='[]'}else{if(gap===''){var properties=partial.join(',');final='['+properties+']'}else{var separator=',\n'+indent;var _properties=partial.join(separator);final='[\n'+indent+_properties+',\n'+stepback+']'}}stack.pop();indent=stepback;return final}}module.exports=exports['default'];
-// Assert `path` exists.
-function assertPath$1(path$$1, name) {
- if (!path$$1) {
- throw new Error('Setting `' + name + '` requires `path` to be set too')
- }
-}
+/***/ }),
+/* 198 */
+/***/ (function(module) {
-var vfile$5 = core$6;
+module.exports = [{"long":"help","description":"output usage information","short":"h","type":"boolean","default":false},{"long":"version","description":"output version number","short":"v","type":"boolean","default":false},{"long":"output","description":"specify output location","short":"o","value":"[path]"},{"long":"rc-path","description":"specify configuration file","short":"r","type":"string","value":"<path>"},{"long":"ignore-path","description":"specify ignore file","short":"i","type":"string","value":"<path>"},{"long":"setting","description":"specify settings","short":"s","type":"string","value":"<settings>"},{"long":"ext","description":"specify extensions","short":"e","type":"string","value":"<extensions>"},{"long":"use","description":"use plugins","short":"u","type":"string","value":"<plugins>"},{"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":"<reporter>"},{"long":"file-path","description":"specify path to process as","type":"string","value":"<path>"},{"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}];
-var proto$4 = core$6.prototype;
+/***/ }),
+/* 199 */
+/***/ (function(module, exports, __webpack_require__) {
-proto$4.message = message$1;
-proto$4.info = info$1;
-proto$4.fail = fail$1;
+"use strict";
-// Slight backwards compatibility. Remove in the future.
-proto$4.warn = message$1;
+module.exports = __webpack_require__(200);
-// Create a message with `reason` at `position`. When an error is passed in as
-// `reason`, copies the stack.
-function message$1(reason, position, origin) {
- var filePath = this.path;
- var message = new vfileMessage(reason, position, origin);
- if (filePath) {
- message.name = filePath + ':' + message.name;
- message.file = filePath;
- }
+/***/ }),
+/* 200 */
+/***/ (function(module) {
- message.fatal = false;
+module.exports = ["md","markdown","mdown","mkdn","mkd","mdwn","mkdown","ron"];
- this.messages.push(message);
+/***/ }),
+/* 201 */
+/***/ (function(module, exports, __webpack_require__) {
- return message
-}
+"use strict";
-// Fail. Creates a vmessage, associates it with the file, and throws it.
-function fail$1() {
- var message = this.message.apply(this, arguments);
- message.fatal = true;
+var unified = __webpack_require__(202)
+var parse = __webpack_require__(209)
+var stringify = __webpack_require__(258)
- throw message
-}
+module.exports = unified()
+ .use(parse)
+ .use(stringify)
+ .freeze()
-// Info. Creates a vmessage, associates it with the file, and marks the
-// fatality as null.
-function info$1() {
- var message = this.message.apply(this, arguments);
- message.fatal = null;
+/***/ }),
+/* 202 */
+/***/ (function(module, exports, __webpack_require__) {
- return message
-}
+"use strict";
-var toString$5 = Object.prototype.toString;
-var isPlainObj = function (x) {
- var prototype;
- return toString$5.call(x) === '[object Object]' && (prototype = Object.getPrototypeOf(x), prototype === null || prototype === Object.getPrototypeOf({}));
-};
+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.
-var unified_1 = unified().freeze();
+module.exports = unified().freeze()
-var slice$3 = [].slice;
-var own$3 = {}.hasOwnProperty;
+var slice = [].slice
+var own = {}.hasOwnProperty
// Process pipeline.
-var pipeline = trough_1()
+var pipeline = trough()
.use(pipelineParse)
.use(pipelineRun)
- .use(pipelineStringify);
+ .use(pipelineStringify)
function pipelineParse(p, ctx) {
- ctx.tree = p.parse(ctx.file);
+ ctx.tree = p.parse(ctx.file)
}
function pipelineRun(p, ctx, next) {
- p.run(ctx.tree, ctx.file, done);
+ p.run(ctx.tree, ctx.file, done)
function done(err, tree, file) {
if (err) {
- next(err);
+ next(err)
} else {
- ctx.tree = tree;
- ctx.file = file;
- next();
+ ctx.tree = tree
+ ctx.file = file
+ next()
}
}
}
function pipelineStringify(p, ctx) {
- ctx.file.contents = p.stringify(ctx.tree, ctx.file);
+ ctx.file.contents = p.stringify(ctx.tree, ctx.file)
}
// Function to create the first processor.
function unified() {
- var attachers = [];
- var transformers = trough_1();
- var namespace = {};
- var frozen = false;
- var freezeIndex = -1;
+ var attachers = []
+ var transformers = trough()
+ var namespace = {}
+ var frozen = false
+ var freezeIndex = -1
// Data management.
- processor.data = data;
+ processor.data = data
// Lock.
- processor.freeze = freeze;
+ processor.freeze = freeze
// Plugins.
- processor.attachers = attachers;
- processor.use = use;
+ 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;
+ 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;
+ var destination = unified()
+ var length = attachers.length
+ var index = -1
while (++index < length) {
- destination.use.apply(null, attachers[index]);
+ destination.use.apply(null, attachers[index])
}
- destination.data(extend$3(true, {}, namespace));
+ destination.data(extend(true, {}, namespace))
return destination
}
@@ -14850,62 +26934,62 @@ function unified() {
//
// In essence, always invoke this when exporting a processor.
function freeze() {
- var values;
- var plugin;
- var options;
- var transformer;
+ 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;
+ values = attachers[freezeIndex]
+ plugin = values[0]
+ options = values[1]
+ transformer = null
if (options === false) {
continue
}
if (options === true) {
- values[1] = undefined;
+ values[1] = undefined
}
- transformer = plugin.apply(processor, values.slice(1));
+ transformer = plugin.apply(processor, values.slice(1))
if (typeof transformer === 'function') {
- transformers.use(transformer);
+ transformers.use(transformer)
}
}
- frozen = true;
- freezeIndex = Infinity;
+ frozen = true
+ freezeIndex = Infinity
return processor
}
// Data management. Getter / setter for processor-specific informtion.
function data(key, value) {
- if (xIsString(key)) {
+ if (string(key)) {
// Set `key`.
if (arguments.length === 2) {
- assertUnfrozen('data', frozen);
+ assertUnfrozen('data', frozen)
- namespace[key] = value;
+ namespace[key] = value
return processor
}
// Get `key`.
- return (own$3.call(namespace, key) && namespace[key]) || null
+ return (own.call(namespace, key) && namespace[key]) || null
}
// Set space.
if (key) {
- assertUnfrozen('data', frozen);
- namespace = key;
+ assertUnfrozen('data', frozen)
+ namespace = key
return processor
}
@@ -14921,46 +27005,46 @@ function unified() {
// * a list of presets, attachers, and arguments (list of attachers and
// options).
function use(value) {
- var settings;
+ var settings
- assertUnfrozen('use', frozen);
+ assertUnfrozen('use', frozen)
if (value === null || value === undefined) {
// Empty.
} else if (typeof value === 'function') {
- addPlugin.apply(null, arguments);
+ addPlugin.apply(null, arguments)
} else if (typeof value === 'object') {
if ('length' in value) {
- addList(value);
+ addList(value)
} else {
- addPreset(value);
+ addPreset(value)
}
} else {
throw new Error('Expected usable value, not `' + value + '`')
}
if (settings) {
- namespace.settings = extend$3(namespace.settings || {}, settings);
+ namespace.settings = extend(namespace.settings || {}, settings)
}
return processor
function addPreset(result) {
- addList(result.plugins);
+ addList(result.plugins)
if (result.settings) {
- settings = extend$3(settings || {}, result.settings);
+ settings = extend(settings || {}, result.settings)
}
}
function add(value) {
if (typeof value === 'function') {
- addPlugin(value);
+ addPlugin(value)
} else if (typeof value === 'object') {
if ('length' in value) {
- addPlugin.apply(null, value);
+ addPlugin.apply(null, value)
} else {
- addPreset(value);
+ addPreset(value)
}
} else {
throw new Error('Expected usable value, not `' + value + '`')
@@ -14968,17 +27052,17 @@ function unified() {
}
function addList(plugins) {
- var length;
- var index;
+ var length
+ var index
if (plugins === null || plugins === undefined) {
// Empty.
} else if (typeof plugins === 'object' && 'length' in plugins) {
- length = plugins.length;
- index = -1;
+ length = plugins.length
+ index = -1
while (++index < length) {
- add(plugins[index]);
+ add(plugins[index])
}
} else {
throw new Error('Expected a list of plugins, not `' + plugins + '`')
@@ -14986,27 +27070,27 @@ function unified() {
}
function addPlugin(plugin, value) {
- var entry = find(plugin);
+ var entry = find(plugin)
if (entry) {
- if (isPlainObj(entry[1]) && isPlainObj(value)) {
- value = extend$3(entry[1], value);
+ if (plain(entry[1]) && plain(value)) {
+ value = extend(entry[1], value)
}
- entry[1] = value;
+ entry[1] = value
} else {
- attachers.push(slice$3.call(arguments));
+ attachers.push(slice.call(arguments))
}
}
}
function find(plugin) {
- var length = attachers.length;
- var index = -1;
- var entry;
+ var length = attachers.length
+ var index = -1
+ var entry
while (++index < length) {
- entry = attachers[index];
+ entry = attachers[index]
if (entry[0] === plugin) {
return entry
@@ -15017,12 +27101,12 @@ function unified() {
// Parse a file (in string or vfile representation) into a unist node using
// the `Parser` on the processor.
function parse(doc) {
- var file = vfile$5(doc);
- var Parser;
+ var file = vfile(doc)
+ var Parser
- freeze();
- Parser = processor.Parser;
- assertParser('parse', Parser);
+ freeze()
+ Parser = processor.Parser
+ assertParser('parse', Parser)
if (newable(Parser)) {
return new Parser(String(file), file).parse()
@@ -15034,31 +27118,31 @@ function unified() {
// Run transforms on a unist node representation of a file (in string or
// vfile representation), async.
function run(node, file, cb) {
- assertNode(node);
- freeze();
+ assertNode(node)
+ freeze()
if (!cb && typeof file === 'function') {
- cb = file;
- file = null;
+ cb = file
+ file = null
}
if (!cb) {
return new Promise(executor)
}
- executor(null, cb);
+ executor(null, cb)
function executor(resolve, reject) {
- transformers.run(node, vfile$5(file), done);
+ transformers.run(node, vfile(file), done)
function done(err, tree, file) {
- tree = tree || node;
+ tree = tree || node
if (err) {
- reject(err);
+ reject(err)
} else if (resolve) {
- resolve(tree);
+ resolve(tree)
} else {
- cb(null, tree, file);
+ cb(null, tree, file)
}
}
}
@@ -15067,32 +27151,32 @@ function unified() {
// 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;
+ var complete = false
+ var result
- run(node, file, done);
+ run(node, file, done)
- assertDone('runSync', 'run', complete);
+ assertDone('runSync', 'run', complete)
return result
function done(err, tree) {
- complete = true;
- bail_1(err);
- result = 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$5(doc);
- var Compiler;
+ var file = vfile(doc)
+ var Compiler
- freeze();
- Compiler = processor.Compiler;
- assertCompiler('stringify', Compiler);
- assertNode(node);
+ freeze()
+ Compiler = processor.Compiler
+ assertCompiler('stringify', Compiler)
+ assertNode(node)
if (newable(Compiler)) {
return new Compiler(node, file).compile()
@@ -15106,28 +27190,28 @@ function unified() {
// 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);
+ freeze()
+ assertParser('process', processor.Parser)
+ assertCompiler('process', processor.Compiler)
if (!cb) {
return new Promise(executor)
}
- executor(null, cb);
+ executor(null, cb)
function executor(resolve, reject) {
- var file = vfile$5(doc);
+ var file = vfile(doc)
- pipeline.run(processor, {file: file}, done);
+ pipeline.run(processor, {file: file}, done)
function done(err) {
if (err) {
- reject(err);
+ reject(err)
} else if (resolve) {
- resolve(file);
+ resolve(file)
} else {
- cb(null, file);
+ cb(null, file)
}
}
}
@@ -15135,23 +27219,23 @@ function unified() {
// Process the given document (in string or vfile representation), sync.
function processSync(doc) {
- var complete = false;
- var file;
+ var complete = false
+ var file
- freeze();
- assertParser('processSync', processor.Parser);
- assertCompiler('processSync', processor.Compiler);
- file = vfile$5(doc);
+ freeze()
+ assertParser('processSync', processor.Parser)
+ assertCompiler('processSync', processor.Compiler)
+ file = vfile(doc)
- process(file, done);
+ process(file, done)
- assertDone('processSync', 'process', complete);
+ assertDone('processSync', 'process', complete)
return file
function done(err) {
- complete = true;
- bail_1(err);
+ complete = true
+ bail(err)
}
}
}
@@ -15163,7 +27247,7 @@ function newable(value) {
// Check if `value` is an object with keys.
function keys(value) {
- var key;
+ var key
for (key in value) {
return true
}
@@ -15197,7 +27281,7 @@ function assertUnfrozen(name, frozen) {
// Assert `node` is a unist node.
function assertNode(node) {
- if (!node || !xIsString(node.type)) {
+ if (!node || !string(node.type)) {
throw new Error('Expected node, got `' + node + '`')
}
}
@@ -15211,7729 +27295,662 @@ function assertDone(name, asyncName, complete) {
}
}
-var unherit_1 = 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);
+/***/ }),
+/* 203 */
+/***/ (function(module, exports, __webpack_require__) {
- /* Clone values. */
- result = Of.prototype;
+"use strict";
- for (key in result) {
- value = result[key];
- if (value && typeof value === 'object') {
- result[key] = 'concat' in value ? value.concat() : immutable(value);
- }
- }
+var hasOwn = Object.prototype.hasOwnProperty;
+var toStr = Object.prototype.toString;
+var defineProperty = Object.defineProperty;
+var gOPD = Object.getOwnPropertyDescriptor;
- return Of
+var isArray = function isArray(arr) {
+ if (typeof Array.isArray === 'function') {
+ return Array.isArray(arr);
+ }
- /* Constructor accepting a single argument,
- * which itself is an `arguments` object. */
- function From(parameters) {
- return Super.apply(this, parameters)
- }
+ return toStr.call(arr) === '[object Array]';
+};
- /* Constructor accepting variadic arguments. */
- function Of() {
- if (!(this instanceof Of)) {
- return new From(arguments)
- }
+var isPlainObject = function isPlainObject(obj) {
+ if (!obj || toStr.call(obj) !== '[object Object]') {
+ return false;
+ }
- return Super.apply(this, arguments)
- }
-}
+ 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;
+ }
-var stateToggle = factory;
+ // 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) { /**/ }
-/* 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
+ return typeof key === 'undefined' || hasOwn.call(obj, key);
+};
- function enter() {
- var context = ctx || this;
- var current = context[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;
+ }
+};
- context[key] = !state;
+// 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 exit
+ return obj[name];
+};
- function exit() {
- context[key] = current;
- }
- }
-}
+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;
-/* Expose. */
-var vfileLocation = factory$1;
+ // 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 = {};
+ }
-/* Factory. */
-function factory$1(file) {
- var contents = indices(String(file));
+ 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);
- return {
- toPosition: offsetToPositionFactory(contents),
- toOffset: positionToOffsetFactory(contents)
- }
-}
+ // 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 : {};
+ }
-/* Factory to get the line and column-based `position` for
- * `offset` in the bound indices. */
-function offsetToPositionFactory(indices) {
- return offsetToPosition
+ // Never move original objects, clone them
+ setProperty(target, { name: name, newValue: extend(deep, clone, copy) });
- /* Get the line and column-based `position` for
- * `offset` in the bound indices. */
- function offsetToPosition(offset) {
- var index = -1;
- var length = indices.length;
+ // Don't bring in undefined values
+ } else if (typeof copy !== 'undefined') {
+ setProperty(target, { name: name, newValue: copy });
+ }
+ }
+ }
+ }
+ }
- if (offset < 0) {
- return {}
- }
+ // Return the modified object
+ return target;
+};
- while (++index < length) {
- if (indices[index] > offset) {
- return {
- line: index + 1,
- column: offset - (indices[index - 1] || 0) + 1,
- offset: offset
- }
- }
- }
- return {}
- }
-}
+/***/ }),
+/* 204 */
+/***/ (function(module, exports, __webpack_require__) {
-/* Factory to get the `offset` for a line and column-based
- * `position` in the bound indices. */
-function positionToOffsetFactory(indices) {
- return positionToOffset
+"use strict";
- /* 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
- }
+module.exports = bail
- return -1
+function bail(err) {
+ if (err) {
+ throw err
}
}
-/* 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
-}
+/***/ }),
+/* 205 */
+/***/ (function(module, exports, __webpack_require__) {
-var _unescape = factory$2;
+"use strict";
-var backslash = '\\';
-// Factory to de-escape a value, based on a list at `key` in `ctx`.
-function factory$2(ctx, key) {
- return unescape
+var VMessage = __webpack_require__(65)
+var VFile = __webpack_require__(206)
- // 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;
+module.exports = VFile
- while (index !== -1) {
- queue.push(value.slice(prev, index));
- prev = index + 1;
- character = value.charAt(prev);
+var proto = VFile.prototype
- // If the following character is not a valid escape, add the slash.
- if (!character || escape.indexOf(character) === -1) {
- queue.push(backslash);
- }
+proto.message = message
+proto.info = info
+proto.fail = fail
- index = value.indexOf(backslash, prev + 1);
- }
+// Slight backwards compatibility. Remove in the future.
+proto.warn = message
- queue.push(value.slice(prev));
+// 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)
- return queue.join('')
+ if (filePath) {
+ message.name = filePath + ':' + message.name
+ message.file = filePath
}
-}
-
-const AElig = "Æ";
-const AMP = "&";
-const Aacute = "Á";
-const Acirc = "Â";
-const Agrave = "À";
-const Aring = "Å";
-const Atilde = "Ã";
-const Auml = "Ä";
-const COPY = "©";
-const Ccedil = "Ç";
-const ETH = "Ð";
-const Eacute = "É";
-const Ecirc = "Ê";
-const Egrave = "È";
-const Euml = "Ë";
-const GT = ">";
-const Iacute = "Í";
-const Icirc = "Î";
-const Igrave = "Ì";
-const Iuml = "Ï";
-const LT = "<";
-const Ntilde = "Ñ";
-const Oacute = "Ó";
-const Ocirc = "Ô";
-const Ograve = "Ò";
-const Oslash = "Ø";
-const Otilde = "Õ";
-const Ouml = "Ö";
-const QUOT = "\"";
-const REG = "®";
-const THORN = "Þ";
-const Uacute = "Ú";
-const Ucirc = "Û";
-const Ugrave = "Ù";
-const Uuml = "Ü";
-const Yacute = "Ý";
-const aacute = "á";
-const acirc = "â";
-const acute = "´";
-const aelig = "æ";
-const agrave = "à";
-const amp = "&";
-const aring = "å";
-const atilde = "ã";
-const auml = "ä";
-const brvbar = "¦";
-const ccedil = "ç";
-const cedil = "¸";
-const cent = "¢";
-const copy$2 = "©";
-const curren = "¤";
-const deg = "°";
-const divide = "÷";
-const eacute = "é";
-const ecirc = "ê";
-const egrave = "è";
-const eth = "ð";
-const euml = "ë";
-const frac12 = "½";
-const frac14 = "¼";
-const frac34 = "¾";
-const gt = ">";
-const iacute = "í";
-const icirc = "î";
-const iexcl = "¡";
-const igrave = "ì";
-const iquest = "¿";
-const iuml = "ï";
-const laquo = "«";
-const lt = "<";
-const macr = "¯";
-const micro = "µ";
-const middot = "·";
-const nbsp = " ";
-const not = "¬";
-const ntilde = "ñ";
-const oacute = "ó";
-const ocirc = "ô";
-const ograve = "ò";
-const ordf = "ª";
-const ordm = "º";
-const oslash = "ø";
-const otilde = "õ";
-const ouml = "ö";
-const para = "¶";
-const plusmn = "±";
-const pound = "£";
-const quot = "\"";
-const raquo = "»";
-const reg = "®";
-const sect = "§";
-const shy = "­";
-const sup1 = "¹";
-const sup2 = "²";
-const sup3 = "³";
-const szlig = "ß";
-const thorn = "þ";
-const times = "×";
-const uacute = "ú";
-const ucirc = "û";
-const ugrave = "ù";
-const uml = "¨";
-const uuml = "ü";
-const yacute = "ý";
-const yen = "¥";
-const yuml = "ÿ";
-var index$2 = {
- AElig: AElig,
- AMP: AMP,
- Aacute: Aacute,
- Acirc: Acirc,
- Agrave: Agrave,
- Aring: Aring,
- Atilde: Atilde,
- Auml: Auml,
- COPY: COPY,
- Ccedil: Ccedil,
- ETH: ETH,
- Eacute: Eacute,
- Ecirc: Ecirc,
- Egrave: Egrave,
- Euml: Euml,
- GT: GT,
- Iacute: Iacute,
- Icirc: Icirc,
- Igrave: Igrave,
- Iuml: Iuml,
- LT: LT,
- Ntilde: Ntilde,
- Oacute: Oacute,
- Ocirc: Ocirc,
- Ograve: Ograve,
- Oslash: Oslash,
- Otilde: Otilde,
- Ouml: Ouml,
- QUOT: QUOT,
- REG: REG,
- THORN: THORN,
- Uacute: Uacute,
- Ucirc: Ucirc,
- Ugrave: Ugrave,
- Uuml: Uuml,
- Yacute: Yacute,
- aacute: aacute,
- acirc: acirc,
- acute: acute,
- aelig: aelig,
- agrave: agrave,
- amp: amp,
- aring: aring,
- atilde: atilde,
- auml: auml,
- brvbar: brvbar,
- ccedil: ccedil,
- cedil: cedil,
- cent: cent,
- copy: copy$2,
- curren: curren,
- deg: deg,
- divide: divide,
- eacute: eacute,
- ecirc: ecirc,
- egrave: egrave,
- eth: eth,
- euml: euml,
- frac12: frac12,
- frac14: frac14,
- frac34: frac34,
- gt: gt,
- iacute: iacute,
- icirc: icirc,
- iexcl: iexcl,
- igrave: igrave,
- iquest: iquest,
- iuml: iuml,
- laquo: laquo,
- lt: lt,
- macr: macr,
- micro: micro,
- middot: middot,
- nbsp: nbsp,
- not: not,
- ntilde: ntilde,
- oacute: oacute,
- ocirc: ocirc,
- ograve: ograve,
- ordf: ordf,
- ordm: ordm,
- oslash: oslash,
- otilde: otilde,
- ouml: ouml,
- para: para,
- plusmn: plusmn,
- pound: pound,
- quot: quot,
- raquo: raquo,
- reg: reg,
- sect: sect,
- shy: shy,
- sup1: sup1,
- sup2: sup2,
- sup3: sup3,
- szlig: szlig,
- thorn: thorn,
- times: times,
- uacute: uacute,
- ucirc: ucirc,
- ugrave: ugrave,
- uml: uml,
- uuml: uuml,
- yacute: yacute,
- yen: yen,
- yuml: yuml
-};
-var characterEntitiesLegacy = Object.freeze({
- AElig: AElig,
- AMP: AMP,
- Aacute: Aacute,
- Acirc: Acirc,
- Agrave: Agrave,
- Aring: Aring,
- Atilde: Atilde,
- Auml: Auml,
- COPY: COPY,
- Ccedil: Ccedil,
- ETH: ETH,
- Eacute: Eacute,
- Ecirc: Ecirc,
- Egrave: Egrave,
- Euml: Euml,
- GT: GT,
- Iacute: Iacute,
- Icirc: Icirc,
- Igrave: Igrave,
- Iuml: Iuml,
- LT: LT,
- Ntilde: Ntilde,
- Oacute: Oacute,
- Ocirc: Ocirc,
- Ograve: Ograve,
- Oslash: Oslash,
- Otilde: Otilde,
- Ouml: Ouml,
- QUOT: QUOT,
- REG: REG,
- THORN: THORN,
- Uacute: Uacute,
- Ucirc: Ucirc,
- Ugrave: Ugrave,
- Uuml: Uuml,
- Yacute: Yacute,
- aacute: aacute,
- acirc: acirc,
- acute: acute,
- aelig: aelig,
- agrave: agrave,
- amp: amp,
- aring: aring,
- atilde: atilde,
- auml: auml,
- brvbar: brvbar,
- ccedil: ccedil,
- cedil: cedil,
- cent: cent,
- copy: copy$2,
- curren: curren,
- deg: deg,
- divide: divide,
- eacute: eacute,
- ecirc: ecirc,
- egrave: egrave,
- eth: eth,
- euml: euml,
- frac12: frac12,
- frac14: frac14,
- frac34: frac34,
- gt: gt,
- iacute: iacute,
- icirc: icirc,
- iexcl: iexcl,
- igrave: igrave,
- iquest: iquest,
- iuml: iuml,
- laquo: laquo,
- lt: lt,
- macr: macr,
- micro: micro,
- middot: middot,
- nbsp: nbsp,
- not: not,
- ntilde: ntilde,
- oacute: oacute,
- ocirc: ocirc,
- ograve: ograve,
- ordf: ordf,
- ordm: ordm,
- oslash: oslash,
- otilde: otilde,
- ouml: ouml,
- para: para,
- plusmn: plusmn,
- pound: pound,
- quot: quot,
- raquo: raquo,
- reg: reg,
- sect: sect,
- shy: shy,
- sup1: sup1,
- sup2: sup2,
- sup3: sup3,
- szlig: szlig,
- thorn: thorn,
- times: times,
- uacute: uacute,
- ucirc: ucirc,
- ugrave: ugrave,
- uml: uml,
- uuml: uuml,
- yacute: yacute,
- yen: yen,
- yuml: yuml,
- default: index$2
-});
+ message.fatal = false
-var index$3 = {
- "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": "Ÿ"
-};
+ this.messages.push(message)
-var characterReferenceInvalid = Object.freeze({
- default: index$3
-});
+ return message
+}
-var isDecimal = decimal;
+// Fail. Creates a vmessage, associates it with the file, and throws it.
+function fail() {
+ var message = this.message.apply(this, arguments)
-/* 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;
+ message.fatal = true
- return code >= 48 && code <= 57 /* 0-9 */
+ throw message
}
-var isHexadecimal = hexadecimal;
+// Info. Creates a vmessage, associates it with the file, and marks the
+// fatality as null.
+function info() {
+ var message = this.message.apply(this, arguments)
-/* 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;
+ message.fatal = null
- return (
- (code >= 97 /* a */ && code <= 102) /* z */ ||
- (code >= 65 /* A */ && code <= 70) /* Z */ ||
- (code >= 48 /* A */ && code <= 57) /* Z */
- )
+ return message
}
-var isAlphabetical = 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;
+/***/ }),
+/* 206 */
+/***/ (function(module, exports, __webpack_require__) {
- return (
- (code >= 97 && code <= 122) /* a-z */ ||
- (code >= 65 && code <= 90) /* A-Z */
- )
-}
+"use strict";
-var isAlphanumerical = alphanumerical;
-/* Check if the given character code, or the character
- * code at the first character, is alphanumerical. */
-function alphanumerical(character) {
- return isAlphabetical(character) || isDecimal(character)
-}
-
-const AEli = "Æ";
-const AElig$1 = "Æ";
-const AM = "&";
-const AMP$1 = "&";
-const Aacut = "Á";
-const Aacute$1 = "Á";
-const Abreve = "Ă";
-const Acir = "Â";
-const Acirc$1 = "Â";
-const Acy = "А";
-const Afr = "𝔄";
-const Agrav = "À";
-const Agrave$1 = "À";
-const Alpha = "Α";
-const Amacr = "Ā";
-const And = "⩓";
-const Aogon = "Ą";
-const Aopf = "𝔸";
-const ApplyFunction = "⁡";
-const Arin = "Å";
-const Aring$1 = "Å";
-const Ascr = "𝒜";
-const Assign = "≔";
-const Atild = "Ã";
-const Atilde$1 = "Ã";
-const Aum = "Ä";
-const Auml$1 = "Ä";
-const Backslash = "∖";
-const Barv = "⫧";
-const Barwed = "⌆";
-const Bcy = "Б";
-const Because = "∵";
-const Bernoullis = "ℬ";
-const Beta = "Β";
-const Bfr = "𝔅";
-const Bopf = "𝔹";
-const Breve = "˘";
-const Bscr = "ℬ";
-const Bumpeq = "≎";
-const CHcy = "Ч";
-const COP = "©";
-const COPY$1 = "©";
-const Cacute = "Ć";
-const Cap = "⋒";
-const CapitalDifferentialD = "ⅅ";
-const Cayleys = "ℭ";
-const Ccaron = "Č";
-const Ccedi = "Ç";
-const Ccedil$1 = "Ç";
-const Ccirc = "Ĉ";
-const Cconint = "∰";
-const Cdot = "Ċ";
-const Cedilla = "¸";
-const CenterDot = "·";
-const Cfr = "ℭ";
-const Chi = "Χ";
-const CircleDot = "⊙";
-const CircleMinus = "⊖";
-const CirclePlus = "⊕";
-const CircleTimes = "⊗";
-const ClockwiseContourIntegral = "∲";
-const CloseCurlyDoubleQuote = "”";
-const CloseCurlyQuote = "’";
-const Colon = "∷";
-const Colone = "⩴";
-const Congruent = "≡";
-const Conint = "∯";
-const ContourIntegral = "∮";
-const Copf = "ℂ";
-const Coproduct = "∐";
-const CounterClockwiseContourIntegral = "∳";
-const Cross = "⨯";
-const Cscr = "𝒞";
-const Cup = "⋓";
-const CupCap = "≍";
-const DD = "ⅅ";
-const DDotrahd = "⤑";
-const DJcy = "Ђ";
-const DScy = "Ѕ";
-const DZcy = "Џ";
-const Dagger = "‡";
-const Darr = "↡";
-const Dashv = "⫤";
-const Dcaron = "Ď";
-const Dcy = "Д";
-const Del = "∇";
-const Delta = "Δ";
-const Dfr = "𝔇";
-const DiacriticalAcute = "´";
-const DiacriticalDot = "˙";
-const DiacriticalDoubleAcute = "˝";
-const DiacriticalGrave = "`";
-const DiacriticalTilde = "˜";
-const Diamond = "⋄";
-const DifferentialD = "ⅆ";
-const Dopf = "𝔻";
-const Dot = "¨";
-const DotDot = "⃜";
-const DotEqual = "≐";
-const DoubleContourIntegral = "∯";
-const DoubleDot = "¨";
-const DoubleDownArrow = "⇓";
-const DoubleLeftArrow = "⇐";
-const DoubleLeftRightArrow = "⇔";
-const DoubleLeftTee = "⫤";
-const DoubleLongLeftArrow = "⟸";
-const DoubleLongLeftRightArrow = "⟺";
-const DoubleLongRightArrow = "⟹";
-const DoubleRightArrow = "⇒";
-const DoubleRightTee = "⊨";
-const DoubleUpArrow = "⇑";
-const DoubleUpDownArrow = "⇕";
-const DoubleVerticalBar = "∥";
-const DownArrow = "↓";
-const DownArrowBar = "⤓";
-const DownArrowUpArrow = "⇵";
-const DownBreve = "̑";
-const DownLeftRightVector = "⥐";
-const DownLeftTeeVector = "⥞";
-const DownLeftVector = "↽";
-const DownLeftVectorBar = "⥖";
-const DownRightTeeVector = "⥟";
-const DownRightVector = "⇁";
-const DownRightVectorBar = "⥗";
-const DownTee = "⊤";
-const DownTeeArrow = "↧";
-const Downarrow = "⇓";
-const Dscr = "𝒟";
-const Dstrok = "Đ";
-const ENG = "Ŋ";
-const ET = "Ð";
-const ETH$1 = "Ð";
-const Eacut = "É";
-const Eacute$1 = "É";
-const Ecaron = "Ě";
-const Ecir = "Ê";
-const Ecirc$1 = "Ê";
-const Ecy = "Э";
-const Edot = "Ė";
-const Efr = "𝔈";
-const Egrav = "È";
-const Egrave$1 = "È";
-const Element = "∈";
-const Emacr = "Ē";
-const EmptySmallSquare = "◻";
-const EmptyVerySmallSquare = "▫";
-const Eogon = "Ę";
-const Eopf = "𝔼";
-const Epsilon = "Ε";
-const Equal = "⩵";
-const EqualTilde = "≂";
-const Equilibrium = "⇌";
-const Escr = "ℰ";
-const Esim = "⩳";
-const Eta = "Η";
-const Eum = "Ë";
-const Euml$1 = "Ë";
-const Exists = "∃";
-const ExponentialE = "ⅇ";
-const Fcy = "Ф";
-const Ffr = "𝔉";
-const FilledSmallSquare = "◼";
-const FilledVerySmallSquare = "▪";
-const Fopf = "𝔽";
-const ForAll = "∀";
-const Fouriertrf = "ℱ";
-const Fscr = "ℱ";
-const GJcy = "Ѓ";
-const G = ">";
-const GT$1 = ">";
-const Gamma = "Γ";
-const Gammad = "Ϝ";
-const Gbreve = "Ğ";
-const Gcedil = "Ģ";
-const Gcirc = "Ĝ";
-const Gcy = "Г";
-const Gdot = "Ġ";
-const Gfr = "𝔊";
-const Gg = "⋙";
-const Gopf = "𝔾";
-const GreaterEqual = "≥";
-const GreaterEqualLess = "⋛";
-const GreaterFullEqual = "≧";
-const GreaterGreater = "⪢";
-const GreaterLess = "≷";
-const GreaterSlantEqual = "⩾";
-const GreaterTilde = "≳";
-const Gscr = "𝒢";
-const Gt = "≫";
-const HARDcy = "Ъ";
-const Hacek = "ˇ";
-const Hat = "^";
-const Hcirc = "Ĥ";
-const Hfr = "ℌ";
-const HilbertSpace = "ℋ";
-const Hopf = "ℍ";
-const HorizontalLine = "─";
-const Hscr = "ℋ";
-const Hstrok = "Ħ";
-const HumpDownHump = "≎";
-const HumpEqual = "≏";
-const IEcy = "Е";
-const IJlig = "IJ";
-const IOcy = "Ё";
-const Iacut = "Í";
-const Iacute$1 = "Í";
-const Icir = "Î";
-const Icirc$1 = "Î";
-const Icy = "И";
-const Idot = "İ";
-const Ifr = "ℑ";
-const Igrav = "Ì";
-const Igrave$1 = "Ì";
-const Im = "ℑ";
-const Imacr = "Ī";
-const ImaginaryI = "ⅈ";
-const Implies = "⇒";
-const Int = "∬";
-const Integral = "∫";
-const Intersection = "⋂";
-const InvisibleComma = "⁣";
-const InvisibleTimes = "⁢";
-const Iogon = "Į";
-const Iopf = "𝕀";
-const Iota = "Ι";
-const Iscr = "ℐ";
-const Itilde = "Ĩ";
-const Iukcy = "І";
-const Ium = "Ï";
-const Iuml$1 = "Ï";
-const Jcirc = "Ĵ";
-const Jcy = "Й";
-const Jfr = "𝔍";
-const Jopf = "𝕁";
-const Jscr = "𝒥";
-const Jsercy = "Ј";
-const Jukcy = "Є";
-const KHcy = "Х";
-const KJcy = "Ќ";
-const Kappa = "Κ";
-const Kcedil = "Ķ";
-const Kcy = "К";
-const Kfr = "𝔎";
-const Kopf = "𝕂";
-const Kscr = "𝒦";
-const LJcy = "Љ";
-const L = "<";
-const LT$1 = "<";
-const Lacute = "Ĺ";
-const Lambda = "Λ";
-const Lang = "⟪";
-const Laplacetrf = "ℒ";
-const Larr = "↞";
-const Lcaron = "Ľ";
-const Lcedil = "Ļ";
-const Lcy = "Л";
-const LeftAngleBracket = "⟨";
-const LeftArrow = "←";
-const LeftArrowBar = "⇤";
-const LeftArrowRightArrow = "⇆";
-const LeftCeiling = "⌈";
-const LeftDoubleBracket = "⟦";
-const LeftDownTeeVector = "⥡";
-const LeftDownVector = "⇃";
-const LeftDownVectorBar = "⥙";
-const LeftFloor = "⌊";
-const LeftRightArrow = "↔";
-const LeftRightVector = "⥎";
-const LeftTee = "⊣";
-const LeftTeeArrow = "↤";
-const LeftTeeVector = "⥚";
-const LeftTriangle = "⊲";
-const LeftTriangleBar = "⧏";
-const LeftTriangleEqual = "⊴";
-const LeftUpDownVector = "⥑";
-const LeftUpTeeVector = "⥠";
-const LeftUpVector = "↿";
-const LeftUpVectorBar = "⥘";
-const LeftVector = "↼";
-const LeftVectorBar = "⥒";
-const Leftarrow = "⇐";
-const Leftrightarrow = "⇔";
-const LessEqualGreater = "⋚";
-const LessFullEqual = "≦";
-const LessGreater = "≶";
-const LessLess = "⪡";
-const LessSlantEqual = "⩽";
-const LessTilde = "≲";
-const Lfr = "𝔏";
-const Ll = "⋘";
-const Lleftarrow = "⇚";
-const Lmidot = "Ŀ";
-const LongLeftArrow = "⟵";
-const LongLeftRightArrow = "⟷";
-const LongRightArrow = "⟶";
-const Longleftarrow = "⟸";
-const Longleftrightarrow = "⟺";
-const Longrightarrow = "⟹";
-const Lopf = "𝕃";
-const LowerLeftArrow = "↙";
-const LowerRightArrow = "↘";
-const Lscr = "ℒ";
-const Lsh = "↰";
-const Lstrok = "Ł";
-const Lt = "≪";
-const Mcy = "М";
-const MediumSpace = " ";
-const Mellintrf = "ℳ";
-const Mfr = "𝔐";
-const MinusPlus = "∓";
-const Mopf = "𝕄";
-const Mscr = "ℳ";
-const Mu = "Μ";
-const NJcy = "Њ";
-const Nacute = "Ń";
-const Ncaron = "Ň";
-const Ncedil = "Ņ";
-const Ncy = "Н";
-const NegativeMediumSpace = "​";
-const NegativeThickSpace = "​";
-const NegativeThinSpace = "​";
-const NegativeVeryThinSpace = "​";
-const NestedGreaterGreater = "≫";
-const NestedLessLess = "≪";
-const NewLine = "\n";
-const Nfr = "𝔑";
-const NoBreak = "⁠";
-const NonBreakingSpace = " ";
-const Nopf = "ℕ";
-const Not = "⫬";
-const NotCongruent = "≢";
-const NotCupCap = "≭";
-const NotDoubleVerticalBar = "∦";
-const NotElement = "∉";
-const NotEqual = "≠";
-const NotEqualTilde = "≂̸";
-const NotExists = "∄";
-const NotGreater = "≯";
-const NotGreaterEqual = "≱";
-const NotGreaterFullEqual = "≧̸";
-const NotGreaterGreater = "≫̸";
-const NotGreaterLess = "≹";
-const NotGreaterSlantEqual = "⩾̸";
-const NotGreaterTilde = "≵";
-const NotHumpDownHump = "≎̸";
-const NotHumpEqual = "≏̸";
-const NotLeftTriangle = "⋪";
-const NotLeftTriangleBar = "⧏̸";
-const NotLeftTriangleEqual = "⋬";
-const NotLess = "≮";
-const NotLessEqual = "≰";
-const NotLessGreater = "≸";
-const NotLessLess = "≪̸";
-const NotLessSlantEqual = "⩽̸";
-const NotLessTilde = "≴";
-const NotNestedGreaterGreater = "⪢̸";
-const NotNestedLessLess = "⪡̸";
-const NotPrecedes = "⊀";
-const NotPrecedesEqual = "⪯̸";
-const NotPrecedesSlantEqual = "⋠";
-const NotReverseElement = "∌";
-const NotRightTriangle = "⋫";
-const NotRightTriangleBar = "⧐̸";
-const NotRightTriangleEqual = "⋭";
-const NotSquareSubset = "⊏̸";
-const NotSquareSubsetEqual = "⋢";
-const NotSquareSuperset = "⊐̸";
-const NotSquareSupersetEqual = "⋣";
-const NotSubset = "⊂⃒";
-const NotSubsetEqual = "⊈";
-const NotSucceeds = "⊁";
-const NotSucceedsEqual = "⪰̸";
-const NotSucceedsSlantEqual = "⋡";
-const NotSucceedsTilde = "≿̸";
-const NotSuperset = "⊃⃒";
-const NotSupersetEqual = "⊉";
-const NotTilde = "≁";
-const NotTildeEqual = "≄";
-const NotTildeFullEqual = "≇";
-const NotTildeTilde = "≉";
-const NotVerticalBar = "∤";
-const Nscr = "𝒩";
-const Ntild = "Ñ";
-const Ntilde$1 = "Ñ";
-const Nu = "Ν";
-const OElig = "Œ";
-const Oacut = "Ó";
-const Oacute$1 = "Ó";
-const Ocir = "Ô";
-const Ocirc$1 = "Ô";
-const Ocy = "О";
-const Odblac = "Ő";
-const Ofr = "𝔒";
-const Ograv = "Ò";
-const Ograve$1 = "Ò";
-const Omacr = "Ō";
-const Omega = "Ω";
-const Omicron = "Ο";
-const Oopf = "𝕆";
-const OpenCurlyDoubleQuote = "“";
-const OpenCurlyQuote = "‘";
-const Or = "⩔";
-const Oscr = "𝒪";
-const Oslas = "Ø";
-const Oslash$1 = "Ø";
-const Otild = "Õ";
-const Otilde$1 = "Õ";
-const Otimes = "⨷";
-const Oum = "Ö";
-const Ouml$1 = "Ö";
-const OverBar = "‾";
-const OverBrace = "⏞";
-const OverBracket = "⎴";
-const OverParenthesis = "⏜";
-const PartialD = "∂";
-const Pcy = "П";
-const Pfr = "𝔓";
-const Phi = "Φ";
-const Pi = "Π";
-const PlusMinus = "±";
-const Poincareplane = "ℌ";
-const Popf = "ℙ";
-const Pr = "⪻";
-const Precedes = "≺";
-const PrecedesEqual = "⪯";
-const PrecedesSlantEqual = "≼";
-const PrecedesTilde = "≾";
-const Prime = "″";
-const Product = "∏";
-const Proportion = "∷";
-const Proportional = "∝";
-const Pscr = "𝒫";
-const Psi = "Ψ";
-const QUO = "\"";
-const QUOT$1 = "\"";
-const Qfr = "𝔔";
-const Qopf = "ℚ";
-const Qscr = "𝒬";
-const RBarr = "⤐";
-const RE = "®";
-const REG$1 = "®";
-const Racute = "Ŕ";
-const Rang = "⟫";
-const Rarr = "↠";
-const Rarrtl = "⤖";
-const Rcaron = "Ř";
-const Rcedil = "Ŗ";
-const Rcy = "Р";
-const Re = "ℜ";
-const ReverseElement = "∋";
-const ReverseEquilibrium = "⇋";
-const ReverseUpEquilibrium = "⥯";
-const Rfr = "ℜ";
-const Rho = "Ρ";
-const RightAngleBracket = "⟩";
-const RightArrow = "→";
-const RightArrowBar = "⇥";
-const RightArrowLeftArrow = "⇄";
-const RightCeiling = "⌉";
-const RightDoubleBracket = "⟧";
-const RightDownTeeVector = "⥝";
-const RightDownVector = "⇂";
-const RightDownVectorBar = "⥕";
-const RightFloor = "⌋";
-const RightTee = "⊢";
-const RightTeeArrow = "↦";
-const RightTeeVector = "⥛";
-const RightTriangle = "⊳";
-const RightTriangleBar = "⧐";
-const RightTriangleEqual = "⊵";
-const RightUpDownVector = "⥏";
-const RightUpTeeVector = "⥜";
-const RightUpVector = "↾";
-const RightUpVectorBar = "⥔";
-const RightVector = "⇀";
-const RightVectorBar = "⥓";
-const Rightarrow = "⇒";
-const Ropf = "ℝ";
-const RoundImplies = "⥰";
-const Rrightarrow = "⇛";
-const Rscr = "ℛ";
-const Rsh = "↱";
-const RuleDelayed = "⧴";
-const SHCHcy = "Щ";
-const SHcy = "Ш";
-const SOFTcy = "Ь";
-const Sacute = "Ś";
-const Sc = "⪼";
-const Scaron = "Š";
-const Scedil = "Ş";
-const Scirc = "Ŝ";
-const Scy = "С";
-const Sfr = "𝔖";
-const ShortDownArrow = "↓";
-const ShortLeftArrow = "←";
-const ShortRightArrow = "→";
-const ShortUpArrow = "↑";
-const Sigma = "Σ";
-const SmallCircle = "∘";
-const Sopf = "𝕊";
-const Sqrt = "√";
-const Square = "□";
-const SquareIntersection = "⊓";
-const SquareSubset = "⊏";
-const SquareSubsetEqual = "⊑";
-const SquareSuperset = "⊐";
-const SquareSupersetEqual = "⊒";
-const SquareUnion = "⊔";
-const Sscr = "𝒮";
-const Star = "⋆";
-const Sub = "⋐";
-const Subset = "⋐";
-const SubsetEqual = "⊆";
-const Succeeds = "≻";
-const SucceedsEqual = "⪰";
-const SucceedsSlantEqual = "≽";
-const SucceedsTilde = "≿";
-const SuchThat = "∋";
-const Sum = "∑";
-const Sup = "⋑";
-const Superset = "⊃";
-const SupersetEqual = "⊇";
-const Supset = "⋑";
-const THOR = "Þ";
-const THORN$1 = "Þ";
-const TRADE = "™";
-const TSHcy = "Ћ";
-const TScy = "Ц";
-const Tab = "\t";
-const Tau = "Τ";
-const Tcaron = "Ť";
-const Tcedil = "Ţ";
-const Tcy = "Т";
-const Tfr = "𝔗";
-const Therefore = "∴";
-const Theta = "Θ";
-const ThickSpace = "  ";
-const ThinSpace = " ";
-const Tilde = "∼";
-const TildeEqual = "≃";
-const TildeFullEqual = "≅";
-const TildeTilde = "≈";
-const Topf = "𝕋";
-const TripleDot = "⃛";
-const Tscr = "𝒯";
-const Tstrok = "Ŧ";
-const Uacut = "Ú";
-const Uacute$1 = "Ú";
-const Uarr = "↟";
-const Uarrocir = "⥉";
-const Ubrcy = "Ў";
-const Ubreve = "Ŭ";
-const Ucir = "Û";
-const Ucirc$1 = "Û";
-const Ucy = "У";
-const Udblac = "Ű";
-const Ufr = "𝔘";
-const Ugrav = "Ù";
-const Ugrave$1 = "Ù";
-const Umacr = "Ū";
-const UnderBar = "_";
-const UnderBrace = "⏟";
-const UnderBracket = "⎵";
-const UnderParenthesis = "⏝";
-const Union = "⋃";
-const UnionPlus = "⊎";
-const Uogon = "Ų";
-const Uopf = "𝕌";
-const UpArrow = "↑";
-const UpArrowBar = "⤒";
-const UpArrowDownArrow = "⇅";
-const UpDownArrow = "↕";
-const UpEquilibrium = "⥮";
-const UpTee = "⊥";
-const UpTeeArrow = "↥";
-const Uparrow = "⇑";
-const Updownarrow = "⇕";
-const UpperLeftArrow = "↖";
-const UpperRightArrow = "↗";
-const Upsi = "ϒ";
-const Upsilon = "Υ";
-const Uring = "Ů";
-const Uscr = "𝒰";
-const Utilde = "Ũ";
-const Uum = "Ü";
-const Uuml$1 = "Ü";
-const VDash = "⊫";
-const Vbar = "⫫";
-const Vcy = "В";
-const Vdash = "⊩";
-const Vdashl = "⫦";
-const Vee = "⋁";
-const Verbar = "‖";
-const Vert = "‖";
-const VerticalBar = "∣";
-const VerticalLine = "|";
-const VerticalSeparator = "❘";
-const VerticalTilde = "≀";
-const VeryThinSpace = " ";
-const Vfr = "𝔙";
-const Vopf = "𝕍";
-const Vscr = "𝒱";
-const Vvdash = "⊪";
-const Wcirc = "Ŵ";
-const Wedge = "⋀";
-const Wfr = "𝔚";
-const Wopf = "𝕎";
-const Wscr = "𝒲";
-const Xfr = "𝔛";
-const Xi = "Ξ";
-const Xopf = "𝕏";
-const Xscr = "𝒳";
-const YAcy = "Я";
-const YIcy = "Ї";
-const YUcy = "Ю";
-const Yacut = "Ý";
-const Yacute$1 = "Ý";
-const Ycirc = "Ŷ";
-const Ycy = "Ы";
-const Yfr = "𝔜";
-const Yopf = "𝕐";
-const Yscr = "𝒴";
-const Yuml = "Ÿ";
-const ZHcy = "Ж";
-const Zacute = "Ź";
-const Zcaron = "Ž";
-const Zcy = "З";
-const Zdot = "Ż";
-const ZeroWidthSpace = "​";
-const Zeta = "Ζ";
-const Zfr = "ℨ";
-const Zopf = "ℤ";
-const Zscr = "𝒵";
-const aacut = "á";
-const aacute$1 = "á";
-const abreve = "ă";
-const ac = "∾";
-const acE = "∾̳";
-const acd = "∿";
-const acir = "â";
-const acirc$1 = "â";
-const acut = "´";
-const acute$1 = "´";
-const acy = "а";
-const aeli = "æ";
-const aelig$1 = "æ";
-const af = "⁡";
-const afr = "𝔞";
-const agrav = "à";
-const agrave$1 = "à";
-const alefsym = "ℵ";
-const aleph = "ℵ";
-const alpha = "α";
-const amacr = "ā";
-const amalg = "⨿";
-const am = "&";
-const amp$1 = "&";
-const and = "∧";
-const andand = "⩕";
-const andd = "⩜";
-const andslope = "⩘";
-const andv = "⩚";
-const ang = "∠";
-const ange = "⦤";
-const angle = "∠";
-const angmsd = "∡";
-const angmsdaa = "⦨";
-const angmsdab = "⦩";
-const angmsdac = "⦪";
-const angmsdad = "⦫";
-const angmsdae = "⦬";
-const angmsdaf = "⦭";
-const angmsdag = "⦮";
-const angmsdah = "⦯";
-const angrt = "∟";
-const angrtvb = "⊾";
-const angrtvbd = "⦝";
-const angsph = "∢";
-const angst = "Å";
-const angzarr = "⍼";
-const aogon = "ą";
-const aopf = "𝕒";
-const ap = "≈";
-const apE = "⩰";
-const apacir = "⩯";
-const ape = "≊";
-const apid = "≋";
-const apos = "'";
-const approx = "≈";
-const approxeq = "≊";
-const arin = "å";
-const aring$1 = "å";
-const ascr = "𝒶";
-const ast = "*";
-const asymp = "≈";
-const asympeq = "≍";
-const atild = "ã";
-const atilde$1 = "ã";
-const aum = "ä";
-const auml$1 = "ä";
-const awconint = "∳";
-const awint = "⨑";
-const bNot = "⫭";
-const backcong = "≌";
-const backepsilon = "϶";
-const backprime = "‵";
-const backsim = "∽";
-const backsimeq = "⋍";
-const barvee = "⊽";
-const barwed = "⌅";
-const barwedge = "⌅";
-const bbrk = "⎵";
-const bbrktbrk = "⎶";
-const bcong = "≌";
-const bcy = "б";
-const bdquo = "„";
-const becaus = "∵";
-const because = "∵";
-const bemptyv = "⦰";
-const bepsi = "϶";
-const bernou = "ℬ";
-const beta = "β";
-const beth = "ℶ";
-const between = "≬";
-const bfr = "𝔟";
-const bigcap = "⋂";
-const bigcirc = "◯";
-const bigcup = "⋃";
-const bigodot = "⨀";
-const bigoplus = "⨁";
-const bigotimes = "⨂";
-const bigsqcup = "⨆";
-const bigstar = "★";
-const bigtriangledown = "▽";
-const bigtriangleup = "△";
-const biguplus = "⨄";
-const bigvee = "⋁";
-const bigwedge = "⋀";
-const bkarow = "⤍";
-const blacklozenge = "⧫";
-const blacksquare = "▪";
-const blacktriangle = "▴";
-const blacktriangledown = "▾";
-const blacktriangleleft = "◂";
-const blacktriangleright = "▸";
-const blank = "␣";
-const blk12 = "▒";
-const blk14 = "░";
-const blk34 = "▓";
-const block = "█";
-const bne = "=⃥";
-const bnequiv = "≡⃥";
-const bnot = "⌐";
-const bopf = "𝕓";
-const bot = "⊥";
-const bottom = "⊥";
-const bowtie = "⋈";
-const boxDL = "╗";
-const boxDR = "╔";
-const boxDl = "╖";
-const boxDr = "╓";
-const boxH = "═";
-const boxHD = "╦";
-const boxHU = "╩";
-const boxHd = "╤";
-const boxHu = "╧";
-const boxUL = "╝";
-const boxUR = "╚";
-const boxUl = "╜";
-const boxUr = "╙";
-const boxV = "║";
-const boxVH = "╬";
-const boxVL = "╣";
-const boxVR = "╠";
-const boxVh = "╫";
-const boxVl = "╢";
-const boxVr = "╟";
-const boxbox = "⧉";
-const boxdL = "╕";
-const boxdR = "╒";
-const boxdl = "┐";
-const boxdr = "┌";
-const boxh = "─";
-const boxhD = "╥";
-const boxhU = "╨";
-const boxhd = "┬";
-const boxhu = "┴";
-const boxminus = "⊟";
-const boxplus = "⊞";
-const boxtimes = "⊠";
-const boxuL = "╛";
-const boxuR = "╘";
-const boxul = "┘";
-const boxur = "└";
-const boxv = "│";
-const boxvH = "╪";
-const boxvL = "╡";
-const boxvR = "╞";
-const boxvh = "┼";
-const boxvl = "┤";
-const boxvr = "├";
-const bprime = "‵";
-const breve = "˘";
-const brvba = "¦";
-const brvbar$1 = "¦";
-const bscr = "𝒷";
-const bsemi = "⁏";
-const bsim = "∽";
-const bsime = "⋍";
-const bsol = "\\";
-const bsolb = "⧅";
-const bsolhsub = "⟈";
-const bull = "•";
-const bullet = "•";
-const bump = "≎";
-const bumpE = "⪮";
-const bumpe = "≏";
-const bumpeq = "≏";
-const cacute = "ć";
-const cap = "∩";
-const capand = "⩄";
-const capbrcup = "⩉";
-const capcap = "⩋";
-const capcup = "⩇";
-const capdot = "⩀";
-const caps = "∩︀";
-const caret = "⁁";
-const caron = "ˇ";
-const ccaps = "⩍";
-const ccaron = "č";
-const ccedi = "ç";
-const ccedil$1 = "ç";
-const ccirc = "ĉ";
-const ccups = "⩌";
-const ccupssm = "⩐";
-const cdot = "ċ";
-const cedi = "¸";
-const cedil$1 = "¸";
-const cemptyv = "⦲";
-const cen = "¢";
-const cent$1 = "¢";
-const centerdot = "·";
-const cfr = "𝔠";
-const chcy = "ч";
-const check$2 = "✓";
-const checkmark = "✓";
-const chi = "χ";
-const cir = "○";
-const cirE = "⧃";
-const circ = "ˆ";
-const circeq = "≗";
-const circlearrowleft = "↺";
-const circlearrowright = "↻";
-const circledR = "®";
-const circledS = "Ⓢ";
-const circledast = "⊛";
-const circledcirc = "⊚";
-const circleddash = "⊝";
-const cire = "≗";
-const cirfnint = "⨐";
-const cirmid = "⫯";
-const cirscir = "⧂";
-const clubs = "♣";
-const clubsuit = "♣";
-const colon = ":";
-const colone = "≔";
-const coloneq = "≔";
-const comma = ",";
-const commat = "@";
-const comp = "∁";
-const compfn = "∘";
-const complement = "∁";
-const complexes = "ℂ";
-const cong = "≅";
-const congdot = "⩭";
-const conint = "∮";
-const copf = "𝕔";
-const coprod = "∐";
-const cop = "©";
-const copy$3 = "©";
-const copysr = "℗";
-const crarr = "↵";
-const cross = "✗";
-const cscr = "𝒸";
-const csub = "⫏";
-const csube = "⫑";
-const csup = "⫐";
-const csupe = "⫒";
-const ctdot = "⋯";
-const cudarrl = "⤸";
-const cudarrr = "⤵";
-const cuepr = "⋞";
-const cuesc = "⋟";
-const cularr = "↶";
-const cularrp = "⤽";
-const cup = "∪";
-const cupbrcap = "⩈";
-const cupcap = "⩆";
-const cupcup = "⩊";
-const cupdot = "⊍";
-const cupor = "⩅";
-const cups = "∪︀";
-const curarr = "↷";
-const curarrm = "⤼";
-const curlyeqprec = "⋞";
-const curlyeqsucc = "⋟";
-const curlyvee = "⋎";
-const curlywedge = "⋏";
-const curre = "¤";
-const curren$1 = "¤";
-const curvearrowleft = "↶";
-const curvearrowright = "↷";
-const cuvee = "⋎";
-const cuwed = "⋏";
-const cwconint = "∲";
-const cwint = "∱";
-const cylcty = "⌭";
-const dArr = "⇓";
-const dHar = "⥥";
-const dagger = "†";
-const daleth = "ℸ";
-const darr = "↓";
-const dash = "‐";
-const dashv = "⊣";
-const dbkarow = "⤏";
-const dblac = "˝";
-const dcaron = "ď";
-const dcy = "д";
-const dd = "ⅆ";
-const ddagger = "‡";
-const ddarr = "⇊";
-const ddotseq = "⩷";
-const de = "°";
-const deg$1 = "°";
-const delta = "δ";
-const demptyv = "⦱";
-const dfisht = "⥿";
-const dfr = "𝔡";
-const dharl = "⇃";
-const dharr = "⇂";
-const diam = "⋄";
-const diamond = "⋄";
-const diamondsuit = "♦";
-const diams = "♦";
-const die = "¨";
-const digamma = "ϝ";
-const disin = "⋲";
-const div = "÷";
-const divid = "÷";
-const divide$1 = "÷";
-const divideontimes = "⋇";
-const divonx = "⋇";
-const djcy = "ђ";
-const dlcorn = "⌞";
-const dlcrop = "⌍";
-const dollar = "$";
-const dopf = "𝕕";
-const dot = "˙";
-const doteq = "≐";
-const doteqdot = "≑";
-const dotminus = "∸";
-const dotplus = "∔";
-const dotsquare = "⊡";
-const doublebarwedge = "⌆";
-const downarrow = "↓";
-const downdownarrows = "⇊";
-const downharpoonleft = "⇃";
-const downharpoonright = "⇂";
-const drbkarow = "⤐";
-const drcorn = "⌟";
-const drcrop = "⌌";
-const dscr = "𝒹";
-const dscy = "ѕ";
-const dsol = "⧶";
-const dstrok = "đ";
-const dtdot = "⋱";
-const dtri = "▿";
-const dtrif = "▾";
-const duarr = "⇵";
-const duhar = "⥯";
-const dwangle = "⦦";
-const dzcy = "џ";
-const dzigrarr = "⟿";
-const eDDot = "⩷";
-const eDot = "≑";
-const eacut = "é";
-const eacute$1 = "é";
-const easter = "⩮";
-const ecaron = "ě";
-const ecir = "ê";
-const ecirc$1 = "ê";
-const ecolon = "≕";
-const ecy = "э";
-const edot = "ė";
-const ee = "ⅇ";
-const efDot = "≒";
-const efr = "𝔢";
-const eg = "⪚";
-const egrav = "è";
-const egrave$1 = "è";
-const egs = "⪖";
-const egsdot = "⪘";
-const el = "⪙";
-const elinters = "⏧";
-const ell = "ℓ";
-const els = "⪕";
-const elsdot = "⪗";
-const emacr = "ē";
-const empty = "∅";
-const emptyset = "∅";
-const emptyv = "∅";
-const emsp13 = " ";
-const emsp14 = " ";
-const emsp = " ";
-const eng = "ŋ";
-const ensp = " ";
-const eogon = "ę";
-const eopf = "𝕖";
-const epar = "⋕";
-const eparsl = "⧣";
-const eplus = "⩱";
-const epsi = "ε";
-const epsilon = "ε";
-const epsiv = "ϵ";
-const eqcirc = "≖";
-const eqcolon = "≕";
-const eqsim = "≂";
-const eqslantgtr = "⪖";
-const eqslantless = "⪕";
-const equals = "=";
-const equest = "≟";
-const equiv = "≡";
-const equivDD = "⩸";
-const eqvparsl = "⧥";
-const erDot = "≓";
-const erarr = "⥱";
-const escr = "ℯ";
-const esdot = "≐";
-const esim = "≂";
-const eta = "η";
-const et = "ð";
-const eth$1 = "ð";
-const eum = "ë";
-const euml$1 = "ë";
-const euro = "€";
-const excl = "!";
-const exist = "∃";
-const expectation = "ℰ";
-const exponentiale = "ⅇ";
-const fallingdotseq = "≒";
-const fcy = "ф";
-const female = "♀";
-const ffilig = "ffi";
-const fflig = "ff";
-const ffllig = "ffl";
-const ffr = "𝔣";
-const filig = "fi";
-const fjlig = "fj";
-const flat = "♭";
-const fllig = "fl";
-const fltns = "▱";
-const fnof = "ƒ";
-const fopf = "𝕗";
-const forall = "∀";
-const fork = "⋔";
-const forkv = "⫙";
-const fpartint = "⨍";
-const frac1 = "¼";
-const frac12$1 = "½";
-const frac13 = "⅓";
-const frac14$1 = "¼";
-const frac15 = "⅕";
-const frac16 = "⅙";
-const frac18 = "⅛";
-const frac23 = "⅔";
-const frac25 = "⅖";
-const frac3 = "¾";
-const frac34$1 = "¾";
-const frac35 = "⅗";
-const frac38 = "⅜";
-const frac45 = "⅘";
-const frac56 = "⅚";
-const frac58 = "⅝";
-const frac78 = "⅞";
-const frasl = "⁄";
-const frown = "⌢";
-const fscr = "𝒻";
-const gE = "≧";
-const gEl = "⪌";
-const gacute = "ǵ";
-const gamma = "γ";
-const gammad = "ϝ";
-const gap = "⪆";
-const gbreve = "ğ";
-const gcirc = "ĝ";
-const gcy = "г";
-const gdot = "ġ";
-const ge = "≥";
-const gel = "⋛";
-const geq = "≥";
-const geqq = "≧";
-const geqslant = "⩾";
-const ges = "⩾";
-const gescc = "⪩";
-const gesdot = "⪀";
-const gesdoto = "⪂";
-const gesdotol = "⪄";
-const gesl = "⋛︀";
-const gesles = "⪔";
-const gfr = "𝔤";
-const gg = "≫";
-const ggg = "⋙";
-const gimel = "ℷ";
-const gjcy = "ѓ";
-const gl = "≷";
-const glE = "⪒";
-const gla = "⪥";
-const glj = "⪤";
-const gnE = "≩";
-const gnap = "⪊";
-const gnapprox = "⪊";
-const gne = "⪈";
-const gneq = "⪈";
-const gneqq = "≩";
-const gnsim = "⋧";
-const gopf = "𝕘";
-const grave = "`";
-const gscr = "ℊ";
-const gsim = "≳";
-const gsime = "⪎";
-const gsiml = "⪐";
-const g = ">";
-const gt$1 = ">";
-const gtcc = "⪧";
-const gtcir = "⩺";
-const gtdot = "⋗";
-const gtlPar = "⦕";
-const gtquest = "⩼";
-const gtrapprox = "⪆";
-const gtrarr = "⥸";
-const gtrdot = "⋗";
-const gtreqless = "⋛";
-const gtreqqless = "⪌";
-const gtrless = "≷";
-const gtrsim = "≳";
-const gvertneqq = "≩︀";
-const gvnE = "≩︀";
-const hArr = "⇔";
-const hairsp = " ";
-const half = "½";
-const hamilt = "ℋ";
-const hardcy = "ъ";
-const harr = "↔";
-const harrcir = "⥈";
-const harrw = "↭";
-const hbar = "ℏ";
-const hcirc = "ĥ";
-const hearts = "♥";
-const heartsuit = "♥";
-const hellip = "…";
-const hercon = "⊹";
-const hfr = "𝔥";
-const hksearow = "⤥";
-const hkswarow = "⤦";
-const hoarr = "⇿";
-const homtht = "∻";
-const hookleftarrow = "↩";
-const hookrightarrow = "↪";
-const hopf = "𝕙";
-const horbar = "―";
-const hscr = "𝒽";
-const hslash = "ℏ";
-const hstrok = "ħ";
-const hybull = "⁃";
-const hyphen = "‐";
-const iacut = "í";
-const iacute$1 = "í";
-const ic = "⁣";
-const icir = "î";
-const icirc$1 = "î";
-const icy = "и";
-const iecy = "е";
-const iexc = "¡";
-const iexcl$1 = "¡";
-const iff = "⇔";
-const ifr = "𝔦";
-const igrav = "ì";
-const igrave$1 = "ì";
-const ii = "ⅈ";
-const iiiint = "⨌";
-const iiint = "∭";
-const iinfin = "⧜";
-const iiota = "℩";
-const ijlig = "ij";
-const imacr = "ī";
-const image = "ℑ";
-const imagline = "ℐ";
-const imagpart = "ℑ";
-const imath = "ı";
-const imof = "⊷";
-const imped = "Ƶ";
-const incare = "℅";
-const infin = "∞";
-const infintie = "⧝";
-const inodot = "ı";
-const int = "∫";
-const intcal = "⊺";
-const integers = "ℤ";
-const intercal = "⊺";
-const intlarhk = "⨗";
-const intprod = "⨼";
-const iocy = "ё";
-const iogon = "į";
-const iopf = "𝕚";
-const iota = "ι";
-const iprod = "⨼";
-const iques = "¿";
-const iquest$1 = "¿";
-const iscr = "𝒾";
-const isin = "∈";
-const isinE = "⋹";
-const isindot = "⋵";
-const isins = "⋴";
-const isinsv = "⋳";
-const isinv = "∈";
-const it = "⁢";
-const itilde = "ĩ";
-const iukcy = "і";
-const ium = "ï";
-const iuml$1 = "ï";
-const jcirc = "ĵ";
-const jcy = "й";
-const jfr = "𝔧";
-const jmath = "ȷ";
-const jopf = "𝕛";
-const jscr = "𝒿";
-const jsercy = "ј";
-const jukcy = "є";
-const kappa = "κ";
-const kappav = "ϰ";
-const kcedil = "ķ";
-const kcy = "к";
-const kfr = "𝔨";
-const kgreen = "ĸ";
-const khcy = "х";
-const kjcy = "ќ";
-const kopf = "𝕜";
-const kscr = "𝓀";
-const lAarr = "⇚";
-const lArr = "⇐";
-const lAtail = "⤛";
-const lBarr = "⤎";
-const lE = "≦";
-const lEg = "⪋";
-const lHar = "⥢";
-const lacute = "ĺ";
-const laemptyv = "⦴";
-const lagran = "ℒ";
-const lambda = "λ";
-const lang = "⟨";
-const langd = "⦑";
-const langle = "⟨";
-const lap = "⪅";
-const laqu = "«";
-const laquo$1 = "«";
-const larr = "←";
-const larrb = "⇤";
-const larrbfs = "⤟";
-const larrfs = "⤝";
-const larrhk = "↩";
-const larrlp = "↫";
-const larrpl = "⤹";
-const larrsim = "⥳";
-const larrtl = "↢";
-const lat = "⪫";
-const latail = "⤙";
-const late = "⪭";
-const lates = "⪭︀";
-const lbarr = "⤌";
-const lbbrk = "❲";
-const lbrace = "{";
-const lbrack = "[";
-const lbrke = "⦋";
-const lbrksld = "⦏";
-const lbrkslu = "⦍";
-const lcaron = "ľ";
-const lcedil = "ļ";
-const lceil = "⌈";
-const lcub = "{";
-const lcy = "л";
-const ldca = "⤶";
-const ldquo = "“";
-const ldquor = "„";
-const ldrdhar = "⥧";
-const ldrushar = "⥋";
-const ldsh = "↲";
-const le = "≤";
-const leftarrow = "←";
-const leftarrowtail = "↢";
-const leftharpoondown = "↽";
-const leftharpoonup = "↼";
-const leftleftarrows = "⇇";
-const leftrightarrow = "↔";
-const leftrightarrows = "⇆";
-const leftrightharpoons = "⇋";
-const leftrightsquigarrow = "↭";
-const leftthreetimes = "⋋";
-const leg = "⋚";
-const leq = "≤";
-const leqq = "≦";
-const leqslant = "⩽";
-const les = "⩽";
-const lescc = "⪨";
-const lesdot = "⩿";
-const lesdoto = "⪁";
-const lesdotor = "⪃";
-const lesg = "⋚︀";
-const lesges = "⪓";
-const lessapprox = "⪅";
-const lessdot = "⋖";
-const lesseqgtr = "⋚";
-const lesseqqgtr = "⪋";
-const lessgtr = "≶";
-const lesssim = "≲";
-const lfisht = "⥼";
-const lfloor = "⌊";
-const lfr = "𝔩";
-const lg = "≶";
-const lgE = "⪑";
-const lhard = "↽";
-const lharu = "↼";
-const lharul = "⥪";
-const lhblk = "▄";
-const ljcy = "љ";
-const ll = "≪";
-const llarr = "⇇";
-const llcorner = "⌞";
-const llhard = "⥫";
-const lltri = "◺";
-const lmidot = "ŀ";
-const lmoust = "⎰";
-const lmoustache = "⎰";
-const lnE = "≨";
-const lnap = "⪉";
-const lnapprox = "⪉";
-const lne = "⪇";
-const lneq = "⪇";
-const lneqq = "≨";
-const lnsim = "⋦";
-const loang = "⟬";
-const loarr = "⇽";
-const lobrk = "⟦";
-const longleftarrow = "⟵";
-const longleftrightarrow = "⟷";
-const longmapsto = "⟼";
-const longrightarrow = "⟶";
-const looparrowleft = "↫";
-const looparrowright = "↬";
-const lopar = "⦅";
-const lopf = "𝕝";
-const loplus = "⨭";
-const lotimes = "⨴";
-const lowast = "∗";
-const lowbar = "_";
-const loz = "◊";
-const lozenge = "◊";
-const lozf = "⧫";
-const lpar = "(";
-const lparlt = "⦓";
-const lrarr = "⇆";
-const lrcorner = "⌟";
-const lrhar = "⇋";
-const lrhard = "⥭";
-const lrm = "‎";
-const lrtri = "⊿";
-const lsaquo = "‹";
-const lscr = "𝓁";
-const lsh = "↰";
-const lsim = "≲";
-const lsime = "⪍";
-const lsimg = "⪏";
-const lsqb = "[";
-const lsquo = "‘";
-const lsquor = "‚";
-const lstrok = "ł";
-const l = "<";
-const lt$1 = "<";
-const ltcc = "⪦";
-const ltcir = "⩹";
-const ltdot = "⋖";
-const lthree = "⋋";
-const ltimes = "⋉";
-const ltlarr = "⥶";
-const ltquest = "⩻";
-const ltrPar = "⦖";
-const ltri = "◃";
-const ltrie = "⊴";
-const ltrif = "◂";
-const lurdshar = "⥊";
-const luruhar = "⥦";
-const lvertneqq = "≨︀";
-const lvnE = "≨︀";
-const mDDot = "∺";
-const mac = "¯";
-const macr$1 = "¯";
-const male = "♂";
-const malt = "✠";
-const maltese = "✠";
-const map$3 = "↦";
-const mapsto = "↦";
-const mapstodown = "↧";
-const mapstoleft = "↤";
-const mapstoup = "↥";
-const marker = "▮";
-const mcomma = "⨩";
-const mcy = "м";
-const mdash = "—";
-const measuredangle = "∡";
-const mfr = "𝔪";
-const mho = "℧";
-const micr = "µ";
-const micro$1 = "µ";
-const mid = "∣";
-const midast = "*";
-const midcir = "⫰";
-const middo = "·";
-const middot$1 = "·";
-const minus = "−";
-const minusb = "⊟";
-const minusd = "∸";
-const minusdu = "⨪";
-const mlcp = "⫛";
-const mldr = "…";
-const mnplus = "∓";
-const models = "⊧";
-const mopf = "𝕞";
-const mp = "∓";
-const mscr = "𝓂";
-const mstpos = "∾";
-const mu = "μ";
-const multimap = "⊸";
-const mumap = "⊸";
-const nGg = "⋙̸";
-const nGt = "≫⃒";
-const nGtv = "≫̸";
-const nLeftarrow = "⇍";
-const nLeftrightarrow = "⇎";
-const nLl = "⋘̸";
-const nLt = "≪⃒";
-const nLtv = "≪̸";
-const nRightarrow = "⇏";
-const nVDash = "⊯";
-const nVdash = "⊮";
-const nabla = "∇";
-const nacute = "ń";
-const nang = "∠⃒";
-const nap = "≉";
-const napE = "⩰̸";
-const napid = "≋̸";
-const napos = "ʼn";
-const napprox = "≉";
-const natur = "♮";
-const natural = "♮";
-const naturals = "ℕ";
-const nbs = " ";
-const nbsp$1 = " ";
-const nbump = "≎̸";
-const nbumpe = "≏̸";
-const ncap = "⩃";
-const ncaron = "ň";
-const ncedil = "ņ";
-const ncong = "≇";
-const ncongdot = "⩭̸";
-const ncup = "⩂";
-const ncy = "н";
-const ndash = "–";
-const ne = "≠";
-const neArr = "⇗";
-const nearhk = "⤤";
-const nearr = "↗";
-const nearrow = "↗";
-const nedot = "≐̸";
-const nequiv = "≢";
-const nesear = "⤨";
-const nesim = "≂̸";
-const nexist = "∄";
-const nexists = "∄";
-const nfr = "𝔫";
-const ngE = "≧̸";
-const nge = "≱";
-const ngeq = "≱";
-const ngeqq = "≧̸";
-const ngeqslant = "⩾̸";
-const nges = "⩾̸";
-const ngsim = "≵";
-const ngt = "≯";
-const ngtr = "≯";
-const nhArr = "⇎";
-const nharr = "↮";
-const nhpar = "⫲";
-const ni = "∋";
-const nis = "⋼";
-const nisd = "⋺";
-const niv = "∋";
-const njcy = "њ";
-const nlArr = "⇍";
-const nlE = "≦̸";
-const nlarr = "↚";
-const nldr = "‥";
-const nle = "≰";
-const nleftarrow = "↚";
-const nleftrightarrow = "↮";
-const nleq = "≰";
-const nleqq = "≦̸";
-const nleqslant = "⩽̸";
-const nles = "⩽̸";
-const nless = "≮";
-const nlsim = "≴";
-const nlt = "≮";
-const nltri = "⋪";
-const nltrie = "⋬";
-const nmid = "∤";
-const nopf = "𝕟";
-const no = "¬";
-const not$1 = "¬";
-const notin = "∉";
-const notinE = "⋹̸";
-const notindot = "⋵̸";
-const notinva = "∉";
-const notinvb = "⋷";
-const notinvc = "⋶";
-const notni = "∌";
-const notniva = "∌";
-const notnivb = "⋾";
-const notnivc = "⋽";
-const npar = "∦";
-const nparallel = "∦";
-const nparsl = "⫽⃥";
-const npart = "∂̸";
-const npolint = "⨔";
-const npr = "⊀";
-const nprcue = "⋠";
-const npre = "⪯̸";
-const nprec = "⊀";
-const npreceq = "⪯̸";
-const nrArr = "⇏";
-const nrarr = "↛";
-const nrarrc = "⤳̸";
-const nrarrw = "↝̸";
-const nrightarrow = "↛";
-const nrtri = "⋫";
-const nrtrie = "⋭";
-const nsc = "⊁";
-const nsccue = "⋡";
-const nsce = "⪰̸";
-const nscr = "𝓃";
-const nshortmid = "∤";
-const nshortparallel = "∦";
-const nsim = "≁";
-const nsime = "≄";
-const nsimeq = "≄";
-const nsmid = "∤";
-const nspar = "∦";
-const nsqsube = "⋢";
-const nsqsupe = "⋣";
-const nsub = "⊄";
-const nsubE = "⫅̸";
-const nsube = "⊈";
-const nsubset = "⊂⃒";
-const nsubseteq = "⊈";
-const nsubseteqq = "⫅̸";
-const nsucc = "⊁";
-const nsucceq = "⪰̸";
-const nsup = "⊅";
-const nsupE = "⫆̸";
-const nsupe = "⊉";
-const nsupset = "⊃⃒";
-const nsupseteq = "⊉";
-const nsupseteqq = "⫆̸";
-const ntgl = "≹";
-const ntild = "ñ";
-const ntilde$1 = "ñ";
-const ntlg = "≸";
-const ntriangleleft = "⋪";
-const ntrianglelefteq = "⋬";
-const ntriangleright = "⋫";
-const ntrianglerighteq = "⋭";
-const nu = "ν";
-const num = "#";
-const numero = "№";
-const numsp = " ";
-const nvDash = "⊭";
-const nvHarr = "⤄";
-const nvap = "≍⃒";
-const nvdash = "⊬";
-const nvge = "≥⃒";
-const nvgt = ">⃒";
-const nvinfin = "⧞";
-const nvlArr = "⤂";
-const nvle = "≤⃒";
-const nvlt = "<⃒";
-const nvltrie = "⊴⃒";
-const nvrArr = "⤃";
-const nvrtrie = "⊵⃒";
-const nvsim = "∼⃒";
-const nwArr = "⇖";
-const nwarhk = "⤣";
-const nwarr = "↖";
-const nwarrow = "↖";
-const nwnear = "⤧";
-const oS = "Ⓢ";
-const oacut = "ó";
-const oacute$1 = "ó";
-const oast = "⊛";
-const ocir = "ô";
-const ocirc$1 = "ô";
-const ocy = "о";
-const odash = "⊝";
-const odblac = "ő";
-const odiv = "⨸";
-const odot = "⊙";
-const odsold = "⦼";
-const oelig = "œ";
-const ofcir = "⦿";
-const ofr = "𝔬";
-const ogon = "˛";
-const ograv = "ò";
-const ograve$1 = "ò";
-const ogt = "⧁";
-const ohbar = "⦵";
-const ohm = "Ω";
-const oint = "∮";
-const olarr = "↺";
-const olcir = "⦾";
-const olcross = "⦻";
-const oline = "‾";
-const olt = "⧀";
-const omacr = "ō";
-const omega = "ω";
-const omicron = "ο";
-const omid = "⦶";
-const ominus = "⊖";
-const oopf = "𝕠";
-const opar = "⦷";
-const operp = "⦹";
-const oplus = "⊕";
-const or = "∨";
-const orarr = "↻";
-const ord = "º";
-const order$2 = "ℴ";
-const orderof = "ℴ";
-const ordf$1 = "ª";
-const ordm$1 = "º";
-const origof = "⊶";
-const oror = "⩖";
-const orslope = "⩗";
-const orv = "⩛";
-const oscr = "ℴ";
-const oslas = "ø";
-const oslash$1 = "ø";
-const osol = "⊘";
-const otild = "õ";
-const otilde$1 = "õ";
-const otimes = "⊗";
-const otimesas = "⨶";
-const oum = "ö";
-const ouml$1 = "ö";
-const ovbar = "⌽";
-const par = "¶";
-const para$1 = "¶";
-const parallel = "∥";
-const parsim = "⫳";
-const parsl = "⫽";
-const part = "∂";
-const pcy = "п";
-const percnt = "%";
-const period = ".";
-const permil = "‰";
-const perp = "⊥";
-const pertenk = "‱";
-const pfr = "𝔭";
-const phi = "φ";
-const phiv = "ϕ";
-const phmmat = "ℳ";
-const phone = "☎";
-const pi = "π";
-const pitchfork = "⋔";
-const piv = "ϖ";
-const planck = "ℏ";
-const planckh = "ℎ";
-const plankv = "ℏ";
-const plus = "+";
-const plusacir = "⨣";
-const plusb = "⊞";
-const pluscir = "⨢";
-const plusdo = "∔";
-const plusdu = "⨥";
-const pluse = "⩲";
-const plusm = "±";
-const plusmn$1 = "±";
-const plussim = "⨦";
-const plustwo = "⨧";
-const pm = "±";
-const pointint = "⨕";
-const popf = "𝕡";
-const poun = "£";
-const pound$1 = "£";
-const pr = "≺";
-const prE = "⪳";
-const prap = "⪷";
-const prcue = "≼";
-const pre = "⪯";
-const prec = "≺";
-const precapprox = "⪷";
-const preccurlyeq = "≼";
-const preceq = "⪯";
-const precnapprox = "⪹";
-const precneqq = "⪵";
-const precnsim = "⋨";
-const precsim = "≾";
-const prime = "′";
-const primes = "ℙ";
-const prnE = "⪵";
-const prnap = "⪹";
-const prnsim = "⋨";
-const prod = "∏";
-const profalar = "⌮";
-const profline = "⌒";
-const profsurf = "⌓";
-const prop = "∝";
-const propto = "∝";
-const prsim = "≾";
-const prurel = "⊰";
-const pscr = "𝓅";
-const psi = "ψ";
-const puncsp = " ";
-const qfr = "𝔮";
-const qint = "⨌";
-const qopf = "𝕢";
-const qprime = "⁗";
-const qscr = "𝓆";
-const quaternions = "ℍ";
-const quatint = "⨖";
-const quest = "?";
-const questeq = "≟";
-const quo = "\"";
-const quot$1 = "\"";
-const rAarr = "⇛";
-const rArr = "⇒";
-const rAtail = "⤜";
-const rBarr = "⤏";
-const rHar = "⥤";
-const race = "∽̱";
-const racute = "ŕ";
-const radic = "√";
-const raemptyv = "⦳";
-const rang = "⟩";
-const rangd = "⦒";
-const range$1 = "⦥";
-const rangle = "⟩";
-const raqu = "»";
-const raquo$1 = "»";
-const rarr = "→";
-const rarrap = "⥵";
-const rarrb = "⇥";
-const rarrbfs = "⤠";
-const rarrc = "⤳";
-const rarrfs = "⤞";
-const rarrhk = "↪";
-const rarrlp = "↬";
-const rarrpl = "⥅";
-const rarrsim = "⥴";
-const rarrtl = "↣";
-const rarrw = "↝";
-const ratail = "⤚";
-const ratio = "∶";
-const rationals = "ℚ";
-const rbarr = "⤍";
-const rbbrk = "❳";
-const rbrace = "}";
-const rbrack = "]";
-const rbrke = "⦌";
-const rbrksld = "⦎";
-const rbrkslu = "⦐";
-const rcaron = "ř";
-const rcedil = "ŗ";
-const rceil = "⌉";
-const rcub = "}";
-const rcy = "р";
-const rdca = "⤷";
-const rdldhar = "⥩";
-const rdquo = "”";
-const rdquor = "”";
-const rdsh = "↳";
-const real = "ℜ";
-const realine = "ℛ";
-const realpart = "ℜ";
-const reals = "ℝ";
-const rect = "▭";
-const re = "®";
-const reg$1 = "®";
-const rfisht = "⥽";
-const rfloor = "⌋";
-const rfr = "𝔯";
-const rhard = "⇁";
-const rharu = "⇀";
-const rharul = "⥬";
-const rho = "ρ";
-const rhov = "ϱ";
-const rightarrow = "→";
-const rightarrowtail = "↣";
-const rightharpoondown = "⇁";
-const rightharpoonup = "⇀";
-const rightleftarrows = "⇄";
-const rightleftharpoons = "⇌";
-const rightrightarrows = "⇉";
-const rightsquigarrow = "↝";
-const rightthreetimes = "⋌";
-const ring = "˚";
-const risingdotseq = "≓";
-const rlarr = "⇄";
-const rlhar = "⇌";
-const rlm = "‏";
-const rmoust = "⎱";
-const rmoustache = "⎱";
-const rnmid = "⫮";
-const roang = "⟭";
-const roarr = "⇾";
-const robrk = "⟧";
-const ropar = "⦆";
-const ropf = "𝕣";
-const roplus = "⨮";
-const rotimes = "⨵";
-const rpar = ")";
-const rpargt = "⦔";
-const rppolint = "⨒";
-const rrarr = "⇉";
-const rsaquo = "›";
-const rscr = "𝓇";
-const rsh = "↱";
-const rsqb = "]";
-const rsquo = "’";
-const rsquor = "’";
-const rthree = "⋌";
-const rtimes = "⋊";
-const rtri = "▹";
-const rtrie = "⊵";
-const rtrif = "▸";
-const rtriltri = "⧎";
-const ruluhar = "⥨";
-const rx = "℞";
-const sacute = "ś";
-const sbquo = "‚";
-const sc = "≻";
-const scE = "⪴";
-const scap = "⪸";
-const scaron = "š";
-const sccue = "≽";
-const sce = "⪰";
-const scedil = "ş";
-const scirc = "ŝ";
-const scnE = "⪶";
-const scnap = "⪺";
-const scnsim = "⋩";
-const scpolint = "⨓";
-const scsim = "≿";
-const scy = "с";
-const sdot = "⋅";
-const sdotb = "⊡";
-const sdote = "⩦";
-const seArr = "⇘";
-const searhk = "⤥";
-const searr = "↘";
-const searrow = "↘";
-const sec = "§";
-const sect$1 = "§";
-const semi = ";";
-const seswar = "⤩";
-const setminus = "∖";
-const setmn = "∖";
-const sext = "✶";
-const sfr = "𝔰";
-const sfrown = "⌢";
-const sharp = "♯";
-const shchcy = "щ";
-const shcy = "ш";
-const shortmid = "∣";
-const shortparallel = "∥";
-const sh = "­";
-const shy$1 = "­";
-const sigma = "σ";
-const sigmaf = "ς";
-const sigmav = "ς";
-const sim = "∼";
-const simdot = "⩪";
-const sime = "≃";
-const simeq = "≃";
-const simg = "⪞";
-const simgE = "⪠";
-const siml = "⪝";
-const simlE = "⪟";
-const simne = "≆";
-const simplus = "⨤";
-const simrarr = "⥲";
-const slarr = "←";
-const smallsetminus = "∖";
-const smashp = "⨳";
-const smeparsl = "⧤";
-const smid = "∣";
-const smile = "⌣";
-const smt = "⪪";
-const smte = "⪬";
-const smtes = "⪬︀";
-const softcy = "ь";
-const sol = "/";
-const solb = "⧄";
-const solbar = "⌿";
-const sopf = "𝕤";
-const spades = "♠";
-const spadesuit = "♠";
-const spar = "∥";
-const sqcap = "⊓";
-const sqcaps = "⊓︀";
-const sqcup = "⊔";
-const sqcups = "⊔︀";
-const sqsub = "⊏";
-const sqsube = "⊑";
-const sqsubset = "⊏";
-const sqsubseteq = "⊑";
-const sqsup = "⊐";
-const sqsupe = "⊒";
-const sqsupset = "⊐";
-const sqsupseteq = "⊒";
-const squ = "□";
-const square = "□";
-const squarf = "▪";
-const squf = "▪";
-const srarr = "→";
-const sscr = "𝓈";
-const ssetmn = "∖";
-const ssmile = "⌣";
-const sstarf = "⋆";
-const star$1 = "☆";
-const starf = "★";
-const straightepsilon = "ϵ";
-const straightphi = "ϕ";
-const strns = "¯";
-const sub = "⊂";
-const subE = "⫅";
-const subdot = "⪽";
-const sube = "⊆";
-const subedot = "⫃";
-const submult = "⫁";
-const subnE = "⫋";
-const subne = "⊊";
-const subplus = "⪿";
-const subrarr = "⥹";
-const subset = "⊂";
-const subseteq = "⊆";
-const subseteqq = "⫅";
-const subsetneq = "⊊";
-const subsetneqq = "⫋";
-const subsim = "⫇";
-const subsub = "⫕";
-const subsup = "⫓";
-const succ = "≻";
-const succapprox = "⪸";
-const succcurlyeq = "≽";
-const succeq = "⪰";
-const succnapprox = "⪺";
-const succneqq = "⪶";
-const succnsim = "⋩";
-const succsim = "≿";
-const sum = "∑";
-const sung = "♪";
-const sup = "⊃";
-const sup1$1 = "¹";
-const sup2$1 = "²";
-const sup3$1 = "³";
-const supE = "⫆";
-const supdot = "⪾";
-const supdsub = "⫘";
-const supe = "⊇";
-const supedot = "⫄";
-const suphsol = "⟉";
-const suphsub = "⫗";
-const suplarr = "⥻";
-const supmult = "⫂";
-const supnE = "⫌";
-const supne = "⊋";
-const supplus = "⫀";
-const supset = "⊃";
-const supseteq = "⊇";
-const supseteqq = "⫆";
-const supsetneq = "⊋";
-const supsetneqq = "⫌";
-const supsim = "⫈";
-const supsub = "⫔";
-const supsup = "⫖";
-const swArr = "⇙";
-const swarhk = "⤦";
-const swarr = "↙";
-const swarrow = "↙";
-const swnwar = "⤪";
-const szli = "ß";
-const szlig$1 = "ß";
-const target = "⌖";
-const tau = "τ";
-const tbrk = "⎴";
-const tcaron = "ť";
-const tcedil = "ţ";
-const tcy = "т";
-const tdot = "⃛";
-const telrec = "⌕";
-const tfr = "𝔱";
-const there4 = "∴";
-const therefore = "∴";
-const theta = "θ";
-const thetasym = "ϑ";
-const thetav = "ϑ";
-const thickapprox = "≈";
-const thicksim = "∼";
-const thinsp = " ";
-const thkap = "≈";
-const thksim = "∼";
-const thor = "þ";
-const thorn$1 = "þ";
-const tilde = "˜";
-const time = "×";
-const times$1 = "×";
-const timesb = "⊠";
-const timesbar = "⨱";
-const timesd = "⨰";
-const tint = "∭";
-const toea = "⤨";
-const top = "⊤";
-const topbot = "⌶";
-const topcir = "⫱";
-const topf = "𝕥";
-const topfork = "⫚";
-const tosa = "⤩";
-const tprime = "‴";
-const trade = "™";
-const triangle = "▵";
-const triangledown = "▿";
-const triangleleft = "◃";
-const trianglelefteq = "⊴";
-const triangleq = "≜";
-const triangleright = "▹";
-const trianglerighteq = "⊵";
-const tridot = "◬";
-const trie = "≜";
-const triminus = "⨺";
-const triplus = "⨹";
-const trisb = "⧍";
-const tritime = "⨻";
-const trpezium = "⏢";
-const tscr = "𝓉";
-const tscy = "ц";
-const tshcy = "ћ";
-const tstrok = "ŧ";
-const twixt = "≬";
-const twoheadleftarrow = "↞";
-const twoheadrightarrow = "↠";
-const uArr = "⇑";
-const uHar = "⥣";
-const uacut = "ú";
-const uacute$1 = "ú";
-const uarr = "↑";
-const ubrcy = "ў";
-const ubreve = "ŭ";
-const ucir = "û";
-const ucirc$1 = "û";
-const ucy = "у";
-const udarr = "⇅";
-const udblac = "ű";
-const udhar = "⥮";
-const ufisht = "⥾";
-const ufr = "𝔲";
-const ugrav = "ù";
-const ugrave$1 = "ù";
-const uharl = "↿";
-const uharr = "↾";
-const uhblk = "▀";
-const ulcorn = "⌜";
-const ulcorner = "⌜";
-const ulcrop = "⌏";
-const ultri = "◸";
-const umacr = "ū";
-const um = "¨";
-const uml$1 = "¨";
-const uogon = "ų";
-const uopf = "𝕦";
-const uparrow = "↑";
-const updownarrow = "↕";
-const upharpoonleft = "↿";
-const upharpoonright = "↾";
-const uplus = "⊎";
-const upsi = "υ";
-const upsih = "ϒ";
-const upsilon = "υ";
-const upuparrows = "⇈";
-const urcorn = "⌝";
-const urcorner = "⌝";
-const urcrop = "⌎";
-const uring = "ů";
-const urtri = "◹";
-const uscr = "𝓊";
-const utdot = "⋰";
-const utilde = "ũ";
-const utri = "▵";
-const utrif = "▴";
-const uuarr = "⇈";
-const uum = "ü";
-const uuml$1 = "ü";
-const uwangle = "⦧";
-const vArr = "⇕";
-const vBar = "⫨";
-const vBarv = "⫩";
-const vDash = "⊨";
-const vangrt = "⦜";
-const varepsilon = "ϵ";
-const varkappa = "ϰ";
-const varnothing = "∅";
-const varphi = "ϕ";
-const varpi = "ϖ";
-const varpropto = "∝";
-const varr = "↕";
-const varrho = "ϱ";
-const varsigma = "ς";
-const varsubsetneq = "⊊︀";
-const varsubsetneqq = "⫋︀";
-const varsupsetneq = "⊋︀";
-const varsupsetneqq = "⫌︀";
-const vartheta = "ϑ";
-const vartriangleleft = "⊲";
-const vartriangleright = "⊳";
-const vcy = "в";
-const vdash = "⊢";
-const vee = "∨";
-const veebar = "⊻";
-const veeeq = "≚";
-const vellip = "⋮";
-const verbar = "|";
-const vert = "|";
-const vfr = "𝔳";
-const vltri = "⊲";
-const vnsub = "⊂⃒";
-const vnsup = "⊃⃒";
-const vopf = "𝕧";
-const vprop = "∝";
-const vrtri = "⊳";
-const vscr = "𝓋";
-const vsubnE = "⫋︀";
-const vsubne = "⊊︀";
-const vsupnE = "⫌︀";
-const vsupne = "⊋︀";
-const vzigzag = "⦚";
-const wcirc = "ŵ";
-const wedbar = "⩟";
-const wedge = "∧";
-const wedgeq = "≙";
-const weierp = "℘";
-const wfr = "𝔴";
-const wopf = "𝕨";
-const wp = "℘";
-const wr = "≀";
-const wreath = "≀";
-const wscr = "𝓌";
-const xcap = "⋂";
-const xcirc = "◯";
-const xcup = "⋃";
-const xdtri = "▽";
-const xfr = "𝔵";
-const xhArr = "⟺";
-const xharr = "⟷";
-const xi = "ξ";
-const xlArr = "⟸";
-const xlarr = "⟵";
-const xmap = "⟼";
-const xnis = "⋻";
-const xodot = "⨀";
-const xopf = "𝕩";
-const xoplus = "⨁";
-const xotime = "⨂";
-const xrArr = "⟹";
-const xrarr = "⟶";
-const xscr = "𝓍";
-const xsqcup = "⨆";
-const xuplus = "⨄";
-const xutri = "△";
-const xvee = "⋁";
-const xwedge = "⋀";
-const yacut = "ý";
-const yacute$1 = "ý";
-const yacy = "я";
-const ycirc = "ŷ";
-const ycy = "ы";
-const ye = "¥";
-const yen$1 = "¥";
-const yfr = "𝔶";
-const yicy = "ї";
-const yopf = "𝕪";
-const yscr = "𝓎";
-const yucy = "ю";
-const yum = "ÿ";
-const yuml$1 = "ÿ";
-const zacute = "ź";
-const zcaron = "ž";
-const zcy = "з";
-const zdot = "ż";
-const zeetrf = "ℨ";
-const zeta = "ζ";
-const zfr = "𝔷";
-const zhcy = "ж";
-const zigrarr = "⇝";
-const zopf = "𝕫";
-const zscr = "𝓏";
-const zwj = "‍";
-const zwnj = "‌";
-var index$4 = {
- AEli: AEli,
- AElig: AElig$1,
- AM: AM,
- AMP: AMP$1,
- Aacut: Aacut,
- Aacute: Aacute$1,
- Abreve: Abreve,
- Acir: Acir,
- Acirc: Acirc$1,
- Acy: Acy,
- Afr: Afr,
- Agrav: Agrav,
- Agrave: Agrave$1,
- Alpha: Alpha,
- Amacr: Amacr,
- And: And,
- Aogon: Aogon,
- Aopf: Aopf,
- ApplyFunction: ApplyFunction,
- Arin: Arin,
- Aring: Aring$1,
- Ascr: Ascr,
- Assign: Assign,
- Atild: Atild,
- Atilde: Atilde$1,
- Aum: Aum,
- Auml: Auml$1,
- Backslash: Backslash,
- Barv: Barv,
- Barwed: Barwed,
- Bcy: Bcy,
- Because: Because,
- Bernoullis: Bernoullis,
- Beta: Beta,
- Bfr: Bfr,
- Bopf: Bopf,
- Breve: Breve,
- Bscr: Bscr,
- Bumpeq: Bumpeq,
- CHcy: CHcy,
- COP: COP,
- COPY: COPY$1,
- Cacute: Cacute,
- Cap: Cap,
- CapitalDifferentialD: CapitalDifferentialD,
- Cayleys: Cayleys,
- Ccaron: Ccaron,
- Ccedi: Ccedi,
- Ccedil: Ccedil$1,
- Ccirc: Ccirc,
- Cconint: Cconint,
- Cdot: Cdot,
- Cedilla: Cedilla,
- CenterDot: CenterDot,
- Cfr: Cfr,
- Chi: Chi,
- CircleDot: CircleDot,
- CircleMinus: CircleMinus,
- CirclePlus: CirclePlus,
- CircleTimes: CircleTimes,
- ClockwiseContourIntegral: ClockwiseContourIntegral,
- CloseCurlyDoubleQuote: CloseCurlyDoubleQuote,
- CloseCurlyQuote: CloseCurlyQuote,
- Colon: Colon,
- Colone: Colone,
- Congruent: Congruent,
- Conint: Conint,
- ContourIntegral: ContourIntegral,
- Copf: Copf,
- Coproduct: Coproduct,
- CounterClockwiseContourIntegral: CounterClockwiseContourIntegral,
- Cross: Cross,
- Cscr: Cscr,
- Cup: Cup,
- CupCap: CupCap,
- DD: DD,
- DDotrahd: DDotrahd,
- DJcy: DJcy,
- DScy: DScy,
- DZcy: DZcy,
- Dagger: Dagger,
- Darr: Darr,
- Dashv: Dashv,
- Dcaron: Dcaron,
- Dcy: Dcy,
- Del: Del,
- Delta: Delta,
- Dfr: Dfr,
- DiacriticalAcute: DiacriticalAcute,
- DiacriticalDot: DiacriticalDot,
- DiacriticalDoubleAcute: DiacriticalDoubleAcute,
- DiacriticalGrave: DiacriticalGrave,
- DiacriticalTilde: DiacriticalTilde,
- Diamond: Diamond,
- DifferentialD: DifferentialD,
- Dopf: Dopf,
- Dot: Dot,
- DotDot: DotDot,
- DotEqual: DotEqual,
- DoubleContourIntegral: DoubleContourIntegral,
- DoubleDot: DoubleDot,
- DoubleDownArrow: DoubleDownArrow,
- DoubleLeftArrow: DoubleLeftArrow,
- DoubleLeftRightArrow: DoubleLeftRightArrow,
- DoubleLeftTee: DoubleLeftTee,
- DoubleLongLeftArrow: DoubleLongLeftArrow,
- DoubleLongLeftRightArrow: DoubleLongLeftRightArrow,
- DoubleLongRightArrow: DoubleLongRightArrow,
- DoubleRightArrow: DoubleRightArrow,
- DoubleRightTee: DoubleRightTee,
- DoubleUpArrow: DoubleUpArrow,
- DoubleUpDownArrow: DoubleUpDownArrow,
- DoubleVerticalBar: DoubleVerticalBar,
- DownArrow: DownArrow,
- DownArrowBar: DownArrowBar,
- DownArrowUpArrow: DownArrowUpArrow,
- DownBreve: DownBreve,
- DownLeftRightVector: DownLeftRightVector,
- DownLeftTeeVector: DownLeftTeeVector,
- DownLeftVector: DownLeftVector,
- DownLeftVectorBar: DownLeftVectorBar,
- DownRightTeeVector: DownRightTeeVector,
- DownRightVector: DownRightVector,
- DownRightVectorBar: DownRightVectorBar,
- DownTee: DownTee,
- DownTeeArrow: DownTeeArrow,
- Downarrow: Downarrow,
- Dscr: Dscr,
- Dstrok: Dstrok,
- ENG: ENG,
- ET: ET,
- ETH: ETH$1,
- Eacut: Eacut,
- Eacute: Eacute$1,
- Ecaron: Ecaron,
- Ecir: Ecir,
- Ecirc: Ecirc$1,
- Ecy: Ecy,
- Edot: Edot,
- Efr: Efr,
- Egrav: Egrav,
- Egrave: Egrave$1,
- Element: Element,
- Emacr: Emacr,
- EmptySmallSquare: EmptySmallSquare,
- EmptyVerySmallSquare: EmptyVerySmallSquare,
- Eogon: Eogon,
- Eopf: Eopf,
- Epsilon: Epsilon,
- Equal: Equal,
- EqualTilde: EqualTilde,
- Equilibrium: Equilibrium,
- Escr: Escr,
- Esim: Esim,
- Eta: Eta,
- Eum: Eum,
- Euml: Euml$1,
- Exists: Exists,
- ExponentialE: ExponentialE,
- Fcy: Fcy,
- Ffr: Ffr,
- FilledSmallSquare: FilledSmallSquare,
- FilledVerySmallSquare: FilledVerySmallSquare,
- Fopf: Fopf,
- ForAll: ForAll,
- Fouriertrf: Fouriertrf,
- Fscr: Fscr,
- GJcy: GJcy,
- G: G,
- GT: GT$1,
- Gamma: Gamma,
- Gammad: Gammad,
- Gbreve: Gbreve,
- Gcedil: Gcedil,
- Gcirc: Gcirc,
- Gcy: Gcy,
- Gdot: Gdot,
- Gfr: Gfr,
- Gg: Gg,
- Gopf: Gopf,
- GreaterEqual: GreaterEqual,
- GreaterEqualLess: GreaterEqualLess,
- GreaterFullEqual: GreaterFullEqual,
- GreaterGreater: GreaterGreater,
- GreaterLess: GreaterLess,
- GreaterSlantEqual: GreaterSlantEqual,
- GreaterTilde: GreaterTilde,
- Gscr: Gscr,
- Gt: Gt,
- HARDcy: HARDcy,
- Hacek: Hacek,
- Hat: Hat,
- Hcirc: Hcirc,
- Hfr: Hfr,
- HilbertSpace: HilbertSpace,
- Hopf: Hopf,
- HorizontalLine: HorizontalLine,
- Hscr: Hscr,
- Hstrok: Hstrok,
- HumpDownHump: HumpDownHump,
- HumpEqual: HumpEqual,
- IEcy: IEcy,
- IJlig: IJlig,
- IOcy: IOcy,
- Iacut: Iacut,
- Iacute: Iacute$1,
- Icir: Icir,
- Icirc: Icirc$1,
- Icy: Icy,
- Idot: Idot,
- Ifr: Ifr,
- Igrav: Igrav,
- Igrave: Igrave$1,
- Im: Im,
- Imacr: Imacr,
- ImaginaryI: ImaginaryI,
- Implies: Implies,
- Int: Int,
- Integral: Integral,
- Intersection: Intersection,
- InvisibleComma: InvisibleComma,
- InvisibleTimes: InvisibleTimes,
- Iogon: Iogon,
- Iopf: Iopf,
- Iota: Iota,
- Iscr: Iscr,
- Itilde: Itilde,
- Iukcy: Iukcy,
- Ium: Ium,
- Iuml: Iuml$1,
- Jcirc: Jcirc,
- Jcy: Jcy,
- Jfr: Jfr,
- Jopf: Jopf,
- Jscr: Jscr,
- Jsercy: Jsercy,
- Jukcy: Jukcy,
- KHcy: KHcy,
- KJcy: KJcy,
- Kappa: Kappa,
- Kcedil: Kcedil,
- Kcy: Kcy,
- Kfr: Kfr,
- Kopf: Kopf,
- Kscr: Kscr,
- LJcy: LJcy,
- L: L,
- LT: LT$1,
- Lacute: Lacute,
- Lambda: Lambda,
- Lang: Lang,
- Laplacetrf: Laplacetrf,
- Larr: Larr,
- Lcaron: Lcaron,
- Lcedil: Lcedil,
- Lcy: Lcy,
- LeftAngleBracket: LeftAngleBracket,
- LeftArrow: LeftArrow,
- LeftArrowBar: LeftArrowBar,
- LeftArrowRightArrow: LeftArrowRightArrow,
- LeftCeiling: LeftCeiling,
- LeftDoubleBracket: LeftDoubleBracket,
- LeftDownTeeVector: LeftDownTeeVector,
- LeftDownVector: LeftDownVector,
- LeftDownVectorBar: LeftDownVectorBar,
- LeftFloor: LeftFloor,
- LeftRightArrow: LeftRightArrow,
- LeftRightVector: LeftRightVector,
- LeftTee: LeftTee,
- LeftTeeArrow: LeftTeeArrow,
- LeftTeeVector: LeftTeeVector,
- LeftTriangle: LeftTriangle,
- LeftTriangleBar: LeftTriangleBar,
- LeftTriangleEqual: LeftTriangleEqual,
- LeftUpDownVector: LeftUpDownVector,
- LeftUpTeeVector: LeftUpTeeVector,
- LeftUpVector: LeftUpVector,
- LeftUpVectorBar: LeftUpVectorBar,
- LeftVector: LeftVector,
- LeftVectorBar: LeftVectorBar,
- Leftarrow: Leftarrow,
- Leftrightarrow: Leftrightarrow,
- LessEqualGreater: LessEqualGreater,
- LessFullEqual: LessFullEqual,
- LessGreater: LessGreater,
- LessLess: LessLess,
- LessSlantEqual: LessSlantEqual,
- LessTilde: LessTilde,
- Lfr: Lfr,
- Ll: Ll,
- Lleftarrow: Lleftarrow,
- Lmidot: Lmidot,
- LongLeftArrow: LongLeftArrow,
- LongLeftRightArrow: LongLeftRightArrow,
- LongRightArrow: LongRightArrow,
- Longleftarrow: Longleftarrow,
- Longleftrightarrow: Longleftrightarrow,
- Longrightarrow: Longrightarrow,
- Lopf: Lopf,
- LowerLeftArrow: LowerLeftArrow,
- LowerRightArrow: LowerRightArrow,
- Lscr: Lscr,
- Lsh: Lsh,
- Lstrok: Lstrok,
- Lt: Lt,
- Mcy: Mcy,
- MediumSpace: MediumSpace,
- Mellintrf: Mellintrf,
- Mfr: Mfr,
- MinusPlus: MinusPlus,
- Mopf: Mopf,
- Mscr: Mscr,
- Mu: Mu,
- NJcy: NJcy,
- Nacute: Nacute,
- Ncaron: Ncaron,
- Ncedil: Ncedil,
- Ncy: Ncy,
- NegativeMediumSpace: NegativeMediumSpace,
- NegativeThickSpace: NegativeThickSpace,
- NegativeThinSpace: NegativeThinSpace,
- NegativeVeryThinSpace: NegativeVeryThinSpace,
- NestedGreaterGreater: NestedGreaterGreater,
- NestedLessLess: NestedLessLess,
- NewLine: NewLine,
- Nfr: Nfr,
- NoBreak: NoBreak,
- NonBreakingSpace: NonBreakingSpace,
- Nopf: Nopf,
- Not: Not,
- NotCongruent: NotCongruent,
- NotCupCap: NotCupCap,
- NotDoubleVerticalBar: NotDoubleVerticalBar,
- NotElement: NotElement,
- NotEqual: NotEqual,
- NotEqualTilde: NotEqualTilde,
- NotExists: NotExists,
- NotGreater: NotGreater,
- NotGreaterEqual: NotGreaterEqual,
- NotGreaterFullEqual: NotGreaterFullEqual,
- NotGreaterGreater: NotGreaterGreater,
- NotGreaterLess: NotGreaterLess,
- NotGreaterSlantEqual: NotGreaterSlantEqual,
- NotGreaterTilde: NotGreaterTilde,
- NotHumpDownHump: NotHumpDownHump,
- NotHumpEqual: NotHumpEqual,
- NotLeftTriangle: NotLeftTriangle,
- NotLeftTriangleBar: NotLeftTriangleBar,
- NotLeftTriangleEqual: NotLeftTriangleEqual,
- NotLess: NotLess,
- NotLessEqual: NotLessEqual,
- NotLessGreater: NotLessGreater,
- NotLessLess: NotLessLess,
- NotLessSlantEqual: NotLessSlantEqual,
- NotLessTilde: NotLessTilde,
- NotNestedGreaterGreater: NotNestedGreaterGreater,
- NotNestedLessLess: NotNestedLessLess,
- NotPrecedes: NotPrecedes,
- NotPrecedesEqual: NotPrecedesEqual,
- NotPrecedesSlantEqual: NotPrecedesSlantEqual,
- NotReverseElement: NotReverseElement,
- NotRightTriangle: NotRightTriangle,
- NotRightTriangleBar: NotRightTriangleBar,
- NotRightTriangleEqual: NotRightTriangleEqual,
- NotSquareSubset: NotSquareSubset,
- NotSquareSubsetEqual: NotSquareSubsetEqual,
- NotSquareSuperset: NotSquareSuperset,
- NotSquareSupersetEqual: NotSquareSupersetEqual,
- NotSubset: NotSubset,
- NotSubsetEqual: NotSubsetEqual,
- NotSucceeds: NotSucceeds,
- NotSucceedsEqual: NotSucceedsEqual,
- NotSucceedsSlantEqual: NotSucceedsSlantEqual,
- NotSucceedsTilde: NotSucceedsTilde,
- NotSuperset: NotSuperset,
- NotSupersetEqual: NotSupersetEqual,
- NotTilde: NotTilde,
- NotTildeEqual: NotTildeEqual,
- NotTildeFullEqual: NotTildeFullEqual,
- NotTildeTilde: NotTildeTilde,
- NotVerticalBar: NotVerticalBar,
- Nscr: Nscr,
- Ntild: Ntild,
- Ntilde: Ntilde$1,
- Nu: Nu,
- OElig: OElig,
- Oacut: Oacut,
- Oacute: Oacute$1,
- Ocir: Ocir,
- Ocirc: Ocirc$1,
- Ocy: Ocy,
- Odblac: Odblac,
- Ofr: Ofr,
- Ograv: Ograv,
- Ograve: Ograve$1,
- Omacr: Omacr,
- Omega: Omega,
- Omicron: Omicron,
- Oopf: Oopf,
- OpenCurlyDoubleQuote: OpenCurlyDoubleQuote,
- OpenCurlyQuote: OpenCurlyQuote,
- Or: Or,
- Oscr: Oscr,
- Oslas: Oslas,
- Oslash: Oslash$1,
- Otild: Otild,
- Otilde: Otilde$1,
- Otimes: Otimes,
- Oum: Oum,
- Ouml: Ouml$1,
- OverBar: OverBar,
- OverBrace: OverBrace,
- OverBracket: OverBracket,
- OverParenthesis: OverParenthesis,
- PartialD: PartialD,
- Pcy: Pcy,
- Pfr: Pfr,
- Phi: Phi,
- Pi: Pi,
- PlusMinus: PlusMinus,
- Poincareplane: Poincareplane,
- Popf: Popf,
- Pr: Pr,
- Precedes: Precedes,
- PrecedesEqual: PrecedesEqual,
- PrecedesSlantEqual: PrecedesSlantEqual,
- PrecedesTilde: PrecedesTilde,
- Prime: Prime,
- Product: Product,
- Proportion: Proportion,
- Proportional: Proportional,
- Pscr: Pscr,
- Psi: Psi,
- QUO: QUO,
- QUOT: QUOT$1,
- Qfr: Qfr,
- Qopf: Qopf,
- Qscr: Qscr,
- RBarr: RBarr,
- RE: RE,
- REG: REG$1,
- Racute: Racute,
- Rang: Rang,
- Rarr: Rarr,
- Rarrtl: Rarrtl,
- Rcaron: Rcaron,
- Rcedil: Rcedil,
- Rcy: Rcy,
- Re: Re,
- ReverseElement: ReverseElement,
- ReverseEquilibrium: ReverseEquilibrium,
- ReverseUpEquilibrium: ReverseUpEquilibrium,
- Rfr: Rfr,
- Rho: Rho,
- RightAngleBracket: RightAngleBracket,
- RightArrow: RightArrow,
- RightArrowBar: RightArrowBar,
- RightArrowLeftArrow: RightArrowLeftArrow,
- RightCeiling: RightCeiling,
- RightDoubleBracket: RightDoubleBracket,
- RightDownTeeVector: RightDownTeeVector,
- RightDownVector: RightDownVector,
- RightDownVectorBar: RightDownVectorBar,
- RightFloor: RightFloor,
- RightTee: RightTee,
- RightTeeArrow: RightTeeArrow,
- RightTeeVector: RightTeeVector,
- RightTriangle: RightTriangle,
- RightTriangleBar: RightTriangleBar,
- RightTriangleEqual: RightTriangleEqual,
- RightUpDownVector: RightUpDownVector,
- RightUpTeeVector: RightUpTeeVector,
- RightUpVector: RightUpVector,
- RightUpVectorBar: RightUpVectorBar,
- RightVector: RightVector,
- RightVectorBar: RightVectorBar,
- Rightarrow: Rightarrow,
- Ropf: Ropf,
- RoundImplies: RoundImplies,
- Rrightarrow: Rrightarrow,
- Rscr: Rscr,
- Rsh: Rsh,
- RuleDelayed: RuleDelayed,
- SHCHcy: SHCHcy,
- SHcy: SHcy,
- SOFTcy: SOFTcy,
- Sacute: Sacute,
- Sc: Sc,
- Scaron: Scaron,
- Scedil: Scedil,
- Scirc: Scirc,
- Scy: Scy,
- Sfr: Sfr,
- ShortDownArrow: ShortDownArrow,
- ShortLeftArrow: ShortLeftArrow,
- ShortRightArrow: ShortRightArrow,
- ShortUpArrow: ShortUpArrow,
- Sigma: Sigma,
- SmallCircle: SmallCircle,
- Sopf: Sopf,
- Sqrt: Sqrt,
- Square: Square,
- SquareIntersection: SquareIntersection,
- SquareSubset: SquareSubset,
- SquareSubsetEqual: SquareSubsetEqual,
- SquareSuperset: SquareSuperset,
- SquareSupersetEqual: SquareSupersetEqual,
- SquareUnion: SquareUnion,
- Sscr: Sscr,
- Star: Star,
- Sub: Sub,
- Subset: Subset,
- SubsetEqual: SubsetEqual,
- Succeeds: Succeeds,
- SucceedsEqual: SucceedsEqual,
- SucceedsSlantEqual: SucceedsSlantEqual,
- SucceedsTilde: SucceedsTilde,
- SuchThat: SuchThat,
- Sum: Sum,
- Sup: Sup,
- Superset: Superset,
- SupersetEqual: SupersetEqual,
- Supset: Supset,
- THOR: THOR,
- THORN: THORN$1,
- TRADE: TRADE,
- TSHcy: TSHcy,
- TScy: TScy,
- Tab: Tab,
- Tau: Tau,
- Tcaron: Tcaron,
- Tcedil: Tcedil,
- Tcy: Tcy,
- Tfr: Tfr,
- Therefore: Therefore,
- Theta: Theta,
- ThickSpace: ThickSpace,
- ThinSpace: ThinSpace,
- Tilde: Tilde,
- TildeEqual: TildeEqual,
- TildeFullEqual: TildeFullEqual,
- TildeTilde: TildeTilde,
- Topf: Topf,
- TripleDot: TripleDot,
- Tscr: Tscr,
- Tstrok: Tstrok,
- Uacut: Uacut,
- Uacute: Uacute$1,
- Uarr: Uarr,
- Uarrocir: Uarrocir,
- Ubrcy: Ubrcy,
- Ubreve: Ubreve,
- Ucir: Ucir,
- Ucirc: Ucirc$1,
- Ucy: Ucy,
- Udblac: Udblac,
- Ufr: Ufr,
- Ugrav: Ugrav,
- Ugrave: Ugrave$1,
- Umacr: Umacr,
- UnderBar: UnderBar,
- UnderBrace: UnderBrace,
- UnderBracket: UnderBracket,
- UnderParenthesis: UnderParenthesis,
- Union: Union,
- UnionPlus: UnionPlus,
- Uogon: Uogon,
- Uopf: Uopf,
- UpArrow: UpArrow,
- UpArrowBar: UpArrowBar,
- UpArrowDownArrow: UpArrowDownArrow,
- UpDownArrow: UpDownArrow,
- UpEquilibrium: UpEquilibrium,
- UpTee: UpTee,
- UpTeeArrow: UpTeeArrow,
- Uparrow: Uparrow,
- Updownarrow: Updownarrow,
- UpperLeftArrow: UpperLeftArrow,
- UpperRightArrow: UpperRightArrow,
- Upsi: Upsi,
- Upsilon: Upsilon,
- Uring: Uring,
- Uscr: Uscr,
- Utilde: Utilde,
- Uum: Uum,
- Uuml: Uuml$1,
- VDash: VDash,
- Vbar: Vbar,
- Vcy: Vcy,
- Vdash: Vdash,
- Vdashl: Vdashl,
- Vee: Vee,
- Verbar: Verbar,
- Vert: Vert,
- VerticalBar: VerticalBar,
- VerticalLine: VerticalLine,
- VerticalSeparator: VerticalSeparator,
- VerticalTilde: VerticalTilde,
- VeryThinSpace: VeryThinSpace,
- Vfr: Vfr,
- Vopf: Vopf,
- Vscr: Vscr,
- Vvdash: Vvdash,
- Wcirc: Wcirc,
- Wedge: Wedge,
- Wfr: Wfr,
- Wopf: Wopf,
- Wscr: Wscr,
- Xfr: Xfr,
- Xi: Xi,
- Xopf: Xopf,
- Xscr: Xscr,
- YAcy: YAcy,
- YIcy: YIcy,
- YUcy: YUcy,
- Yacut: Yacut,
- Yacute: Yacute$1,
- Ycirc: Ycirc,
- Ycy: Ycy,
- Yfr: Yfr,
- Yopf: Yopf,
- Yscr: Yscr,
- Yuml: Yuml,
- ZHcy: ZHcy,
- Zacute: Zacute,
- Zcaron: Zcaron,
- Zcy: Zcy,
- Zdot: Zdot,
- ZeroWidthSpace: ZeroWidthSpace,
- Zeta: Zeta,
- Zfr: Zfr,
- Zopf: Zopf,
- Zscr: Zscr,
- aacut: aacut,
- aacute: aacute$1,
- abreve: abreve,
- ac: ac,
- acE: acE,
- acd: acd,
- acir: acir,
- acirc: acirc$1,
- acut: acut,
- acute: acute$1,
- acy: acy,
- aeli: aeli,
- aelig: aelig$1,
- af: af,
- afr: afr,
- agrav: agrav,
- agrave: agrave$1,
- alefsym: alefsym,
- aleph: aleph,
- alpha: alpha,
- amacr: amacr,
- amalg: amalg,
- am: am,
- amp: amp$1,
- and: and,
- andand: andand,
- andd: andd,
- andslope: andslope,
- andv: andv,
- ang: ang,
- ange: ange,
- angle: angle,
- angmsd: angmsd,
- angmsdaa: angmsdaa,
- angmsdab: angmsdab,
- angmsdac: angmsdac,
- angmsdad: angmsdad,
- angmsdae: angmsdae,
- angmsdaf: angmsdaf,
- angmsdag: angmsdag,
- angmsdah: angmsdah,
- angrt: angrt,
- angrtvb: angrtvb,
- angrtvbd: angrtvbd,
- angsph: angsph,
- angst: angst,
- angzarr: angzarr,
- aogon: aogon,
- aopf: aopf,
- ap: ap,
- apE: apE,
- apacir: apacir,
- ape: ape,
- apid: apid,
- apos: apos,
- approx: approx,
- approxeq: approxeq,
- arin: arin,
- aring: aring$1,
- ascr: ascr,
- ast: ast,
- asymp: asymp,
- asympeq: asympeq,
- atild: atild,
- atilde: atilde$1,
- aum: aum,
- auml: auml$1,
- awconint: awconint,
- awint: awint,
- bNot: bNot,
- backcong: backcong,
- backepsilon: backepsilon,
- backprime: backprime,
- backsim: backsim,
- backsimeq: backsimeq,
- barvee: barvee,
- barwed: barwed,
- barwedge: barwedge,
- bbrk: bbrk,
- bbrktbrk: bbrktbrk,
- bcong: bcong,
- bcy: bcy,
- bdquo: bdquo,
- becaus: becaus,
- because: because,
- bemptyv: bemptyv,
- bepsi: bepsi,
- bernou: bernou,
- beta: beta,
- beth: beth,
- between: between,
- bfr: bfr,
- bigcap: bigcap,
- bigcirc: bigcirc,
- bigcup: bigcup,
- bigodot: bigodot,
- bigoplus: bigoplus,
- bigotimes: bigotimes,
- bigsqcup: bigsqcup,
- bigstar: bigstar,
- bigtriangledown: bigtriangledown,
- bigtriangleup: bigtriangleup,
- biguplus: biguplus,
- bigvee: bigvee,
- bigwedge: bigwedge,
- bkarow: bkarow,
- blacklozenge: blacklozenge,
- blacksquare: blacksquare,
- blacktriangle: blacktriangle,
- blacktriangledown: blacktriangledown,
- blacktriangleleft: blacktriangleleft,
- blacktriangleright: blacktriangleright,
- blank: blank,
- blk12: blk12,
- blk14: blk14,
- blk34: blk34,
- block: block,
- bne: bne,
- bnequiv: bnequiv,
- bnot: bnot,
- bopf: bopf,
- bot: bot,
- bottom: bottom,
- bowtie: bowtie,
- boxDL: boxDL,
- boxDR: boxDR,
- boxDl: boxDl,
- boxDr: boxDr,
- boxH: boxH,
- boxHD: boxHD,
- boxHU: boxHU,
- boxHd: boxHd,
- boxHu: boxHu,
- boxUL: boxUL,
- boxUR: boxUR,
- boxUl: boxUl,
- boxUr: boxUr,
- boxV: boxV,
- boxVH: boxVH,
- boxVL: boxVL,
- boxVR: boxVR,
- boxVh: boxVh,
- boxVl: boxVl,
- boxVr: boxVr,
- boxbox: boxbox,
- boxdL: boxdL,
- boxdR: boxdR,
- boxdl: boxdl,
- boxdr: boxdr,
- boxh: boxh,
- boxhD: boxhD,
- boxhU: boxhU,
- boxhd: boxhd,
- boxhu: boxhu,
- boxminus: boxminus,
- boxplus: boxplus,
- boxtimes: boxtimes,
- boxuL: boxuL,
- boxuR: boxuR,
- boxul: boxul,
- boxur: boxur,
- boxv: boxv,
- boxvH: boxvH,
- boxvL: boxvL,
- boxvR: boxvR,
- boxvh: boxvh,
- boxvl: boxvl,
- boxvr: boxvr,
- bprime: bprime,
- breve: breve,
- brvba: brvba,
- brvbar: brvbar$1,
- bscr: bscr,
- bsemi: bsemi,
- bsim: bsim,
- bsime: bsime,
- bsol: bsol,
- bsolb: bsolb,
- bsolhsub: bsolhsub,
- bull: bull,
- bullet: bullet,
- bump: bump,
- bumpE: bumpE,
- bumpe: bumpe,
- bumpeq: bumpeq,
- cacute: cacute,
- cap: cap,
- capand: capand,
- capbrcup: capbrcup,
- capcap: capcap,
- capcup: capcup,
- capdot: capdot,
- caps: caps,
- caret: caret,
- caron: caron,
- ccaps: ccaps,
- ccaron: ccaron,
- ccedi: ccedi,
- ccedil: ccedil$1,
- ccirc: ccirc,
- ccups: ccups,
- ccupssm: ccupssm,
- cdot: cdot,
- cedi: cedi,
- cedil: cedil$1,
- cemptyv: cemptyv,
- cen: cen,
- cent: cent$1,
- centerdot: centerdot,
- cfr: cfr,
- chcy: chcy,
- check: check$2,
- checkmark: checkmark,
- chi: chi,
- cir: cir,
- cirE: cirE,
- circ: circ,
- circeq: circeq,
- circlearrowleft: circlearrowleft,
- circlearrowright: circlearrowright,
- circledR: circledR,
- circledS: circledS,
- circledast: circledast,
- circledcirc: circledcirc,
- circleddash: circleddash,
- cire: cire,
- cirfnint: cirfnint,
- cirmid: cirmid,
- cirscir: cirscir,
- clubs: clubs,
- clubsuit: clubsuit,
- colon: colon,
- colone: colone,
- coloneq: coloneq,
- comma: comma,
- commat: commat,
- comp: comp,
- compfn: compfn,
- complement: complement,
- complexes: complexes,
- cong: cong,
- congdot: congdot,
- conint: conint,
- copf: copf,
- coprod: coprod,
- cop: cop,
- copy: copy$3,
- copysr: copysr,
- crarr: crarr,
- cross: cross,
- cscr: cscr,
- csub: csub,
- csube: csube,
- csup: csup,
- csupe: csupe,
- ctdot: ctdot,
- cudarrl: cudarrl,
- cudarrr: cudarrr,
- cuepr: cuepr,
- cuesc: cuesc,
- cularr: cularr,
- cularrp: cularrp,
- cup: cup,
- cupbrcap: cupbrcap,
- cupcap: cupcap,
- cupcup: cupcup,
- cupdot: cupdot,
- cupor: cupor,
- cups: cups,
- curarr: curarr,
- curarrm: curarrm,
- curlyeqprec: curlyeqprec,
- curlyeqsucc: curlyeqsucc,
- curlyvee: curlyvee,
- curlywedge: curlywedge,
- curre: curre,
- curren: curren$1,
- curvearrowleft: curvearrowleft,
- curvearrowright: curvearrowright,
- cuvee: cuvee,
- cuwed: cuwed,
- cwconint: cwconint,
- cwint: cwint,
- cylcty: cylcty,
- dArr: dArr,
- dHar: dHar,
- dagger: dagger,
- daleth: daleth,
- darr: darr,
- dash: dash,
- dashv: dashv,
- dbkarow: dbkarow,
- dblac: dblac,
- dcaron: dcaron,
- dcy: dcy,
- dd: dd,
- ddagger: ddagger,
- ddarr: ddarr,
- ddotseq: ddotseq,
- de: de,
- deg: deg$1,
- delta: delta,
- demptyv: demptyv,
- dfisht: dfisht,
- dfr: dfr,
- dharl: dharl,
- dharr: dharr,
- diam: diam,
- diamond: diamond,
- diamondsuit: diamondsuit,
- diams: diams,
- die: die,
- digamma: digamma,
- disin: disin,
- div: div,
- divid: divid,
- divide: divide$1,
- divideontimes: divideontimes,
- divonx: divonx,
- djcy: djcy,
- dlcorn: dlcorn,
- dlcrop: dlcrop,
- dollar: dollar,
- dopf: dopf,
- dot: dot,
- doteq: doteq,
- doteqdot: doteqdot,
- dotminus: dotminus,
- dotplus: dotplus,
- dotsquare: dotsquare,
- doublebarwedge: doublebarwedge,
- downarrow: downarrow,
- downdownarrows: downdownarrows,
- downharpoonleft: downharpoonleft,
- downharpoonright: downharpoonright,
- drbkarow: drbkarow,
- drcorn: drcorn,
- drcrop: drcrop,
- dscr: dscr,
- dscy: dscy,
- dsol: dsol,
- dstrok: dstrok,
- dtdot: dtdot,
- dtri: dtri,
- dtrif: dtrif,
- duarr: duarr,
- duhar: duhar,
- dwangle: dwangle,
- dzcy: dzcy,
- dzigrarr: dzigrarr,
- eDDot: eDDot,
- eDot: eDot,
- eacut: eacut,
- eacute: eacute$1,
- easter: easter,
- ecaron: ecaron,
- ecir: ecir,
- ecirc: ecirc$1,
- ecolon: ecolon,
- ecy: ecy,
- edot: edot,
- ee: ee,
- efDot: efDot,
- efr: efr,
- eg: eg,
- egrav: egrav,
- egrave: egrave$1,
- egs: egs,
- egsdot: egsdot,
- el: el,
- elinters: elinters,
- ell: ell,
- els: els,
- elsdot: elsdot,
- emacr: emacr,
- empty: empty,
- emptyset: emptyset,
- emptyv: emptyv,
- emsp13: emsp13,
- emsp14: emsp14,
- emsp: emsp,
- eng: eng,
- ensp: ensp,
- eogon: eogon,
- eopf: eopf,
- epar: epar,
- eparsl: eparsl,
- eplus: eplus,
- epsi: epsi,
- epsilon: epsilon,
- epsiv: epsiv,
- eqcirc: eqcirc,
- eqcolon: eqcolon,
- eqsim: eqsim,
- eqslantgtr: eqslantgtr,
- eqslantless: eqslantless,
- equals: equals,
- equest: equest,
- equiv: equiv,
- equivDD: equivDD,
- eqvparsl: eqvparsl,
- erDot: erDot,
- erarr: erarr,
- escr: escr,
- esdot: esdot,
- esim: esim,
- eta: eta,
- et: et,
- eth: eth$1,
- eum: eum,
- euml: euml$1,
- euro: euro,
- excl: excl,
- exist: exist,
- expectation: expectation,
- exponentiale: exponentiale,
- fallingdotseq: fallingdotseq,
- fcy: fcy,
- female: female,
- ffilig: ffilig,
- fflig: fflig,
- ffllig: ffllig,
- ffr: ffr,
- filig: filig,
- fjlig: fjlig,
- flat: flat,
- fllig: fllig,
- fltns: fltns,
- fnof: fnof,
- fopf: fopf,
- forall: forall,
- fork: fork,
- forkv: forkv,
- fpartint: fpartint,
- frac1: frac1,
- frac12: frac12$1,
- frac13: frac13,
- frac14: frac14$1,
- frac15: frac15,
- frac16: frac16,
- frac18: frac18,
- frac23: frac23,
- frac25: frac25,
- frac3: frac3,
- frac34: frac34$1,
- frac35: frac35,
- frac38: frac38,
- frac45: frac45,
- frac56: frac56,
- frac58: frac58,
- frac78: frac78,
- frasl: frasl,
- frown: frown,
- fscr: fscr,
- gE: gE,
- gEl: gEl,
- gacute: gacute,
- gamma: gamma,
- gammad: gammad,
- gap: gap,
- gbreve: gbreve,
- gcirc: gcirc,
- gcy: gcy,
- gdot: gdot,
- ge: ge,
- gel: gel,
- geq: geq,
- geqq: geqq,
- geqslant: geqslant,
- ges: ges,
- gescc: gescc,
- gesdot: gesdot,
- gesdoto: gesdoto,
- gesdotol: gesdotol,
- gesl: gesl,
- gesles: gesles,
- gfr: gfr,
- gg: gg,
- ggg: ggg,
- gimel: gimel,
- gjcy: gjcy,
- gl: gl,
- glE: glE,
- gla: gla,
- glj: glj,
- gnE: gnE,
- gnap: gnap,
- gnapprox: gnapprox,
- gne: gne,
- gneq: gneq,
- gneqq: gneqq,
- gnsim: gnsim,
- gopf: gopf,
- grave: grave,
- gscr: gscr,
- gsim: gsim,
- gsime: gsime,
- gsiml: gsiml,
- g: g,
- gt: gt$1,
- gtcc: gtcc,
- gtcir: gtcir,
- gtdot: gtdot,
- gtlPar: gtlPar,
- gtquest: gtquest,
- gtrapprox: gtrapprox,
- gtrarr: gtrarr,
- gtrdot: gtrdot,
- gtreqless: gtreqless,
- gtreqqless: gtreqqless,
- gtrless: gtrless,
- gtrsim: gtrsim,
- gvertneqq: gvertneqq,
- gvnE: gvnE,
- hArr: hArr,
- hairsp: hairsp,
- half: half,
- hamilt: hamilt,
- hardcy: hardcy,
- harr: harr,
- harrcir: harrcir,
- harrw: harrw,
- hbar: hbar,
- hcirc: hcirc,
- hearts: hearts,
- heartsuit: heartsuit,
- hellip: hellip,
- hercon: hercon,
- hfr: hfr,
- hksearow: hksearow,
- hkswarow: hkswarow,
- hoarr: hoarr,
- homtht: homtht,
- hookleftarrow: hookleftarrow,
- hookrightarrow: hookrightarrow,
- hopf: hopf,
- horbar: horbar,
- hscr: hscr,
- hslash: hslash,
- hstrok: hstrok,
- hybull: hybull,
- hyphen: hyphen,
- iacut: iacut,
- iacute: iacute$1,
- ic: ic,
- icir: icir,
- icirc: icirc$1,
- icy: icy,
- iecy: iecy,
- iexc: iexc,
- iexcl: iexcl$1,
- iff: iff,
- ifr: ifr,
- igrav: igrav,
- igrave: igrave$1,
- ii: ii,
- iiiint: iiiint,
- iiint: iiint,
- iinfin: iinfin,
- iiota: iiota,
- ijlig: ijlig,
- imacr: imacr,
- image: image,
- imagline: imagline,
- imagpart: imagpart,
- imath: imath,
- imof: imof,
- imped: imped,
- incare: incare,
- infin: infin,
- infintie: infintie,
- inodot: inodot,
- int: int,
- intcal: intcal,
- integers: integers,
- intercal: intercal,
- intlarhk: intlarhk,
- intprod: intprod,
- iocy: iocy,
- iogon: iogon,
- iopf: iopf,
- iota: iota,
- iprod: iprod,
- iques: iques,
- iquest: iquest$1,
- iscr: iscr,
- isin: isin,
- isinE: isinE,
- isindot: isindot,
- isins: isins,
- isinsv: isinsv,
- isinv: isinv,
- it: it,
- itilde: itilde,
- iukcy: iukcy,
- ium: ium,
- iuml: iuml$1,
- jcirc: jcirc,
- jcy: jcy,
- jfr: jfr,
- jmath: jmath,
- jopf: jopf,
- jscr: jscr,
- jsercy: jsercy,
- jukcy: jukcy,
- kappa: kappa,
- kappav: kappav,
- kcedil: kcedil,
- kcy: kcy,
- kfr: kfr,
- kgreen: kgreen,
- khcy: khcy,
- kjcy: kjcy,
- kopf: kopf,
- kscr: kscr,
- lAarr: lAarr,
- lArr: lArr,
- lAtail: lAtail,
- lBarr: lBarr,
- lE: lE,
- lEg: lEg,
- lHar: lHar,
- lacute: lacute,
- laemptyv: laemptyv,
- lagran: lagran,
- lambda: lambda,
- lang: lang,
- langd: langd,
- langle: langle,
- lap: lap,
- laqu: laqu,
- laquo: laquo$1,
- larr: larr,
- larrb: larrb,
- larrbfs: larrbfs,
- larrfs: larrfs,
- larrhk: larrhk,
- larrlp: larrlp,
- larrpl: larrpl,
- larrsim: larrsim,
- larrtl: larrtl,
- lat: lat,
- latail: latail,
- late: late,
- lates: lates,
- lbarr: lbarr,
- lbbrk: lbbrk,
- lbrace: lbrace,
- lbrack: lbrack,
- lbrke: lbrke,
- lbrksld: lbrksld,
- lbrkslu: lbrkslu,
- lcaron: lcaron,
- lcedil: lcedil,
- lceil: lceil,
- lcub: lcub,
- lcy: lcy,
- ldca: ldca,
- ldquo: ldquo,
- ldquor: ldquor,
- ldrdhar: ldrdhar,
- ldrushar: ldrushar,
- ldsh: ldsh,
- le: le,
- leftarrow: leftarrow,
- leftarrowtail: leftarrowtail,
- leftharpoondown: leftharpoondown,
- leftharpoonup: leftharpoonup,
- leftleftarrows: leftleftarrows,
- leftrightarrow: leftrightarrow,
- leftrightarrows: leftrightarrows,
- leftrightharpoons: leftrightharpoons,
- leftrightsquigarrow: leftrightsquigarrow,
- leftthreetimes: leftthreetimes,
- leg: leg,
- leq: leq,
- leqq: leqq,
- leqslant: leqslant,
- les: les,
- lescc: lescc,
- lesdot: lesdot,
- lesdoto: lesdoto,
- lesdotor: lesdotor,
- lesg: lesg,
- lesges: lesges,
- lessapprox: lessapprox,
- lessdot: lessdot,
- lesseqgtr: lesseqgtr,
- lesseqqgtr: lesseqqgtr,
- lessgtr: lessgtr,
- lesssim: lesssim,
- lfisht: lfisht,
- lfloor: lfloor,
- lfr: lfr,
- lg: lg,
- lgE: lgE,
- lhard: lhard,
- lharu: lharu,
- lharul: lharul,
- lhblk: lhblk,
- ljcy: ljcy,
- ll: ll,
- llarr: llarr,
- llcorner: llcorner,
- llhard: llhard,
- lltri: lltri,
- lmidot: lmidot,
- lmoust: lmoust,
- lmoustache: lmoustache,
- lnE: lnE,
- lnap: lnap,
- lnapprox: lnapprox,
- lne: lne,
- lneq: lneq,
- lneqq: lneqq,
- lnsim: lnsim,
- loang: loang,
- loarr: loarr,
- lobrk: lobrk,
- longleftarrow: longleftarrow,
- longleftrightarrow: longleftrightarrow,
- longmapsto: longmapsto,
- longrightarrow: longrightarrow,
- looparrowleft: looparrowleft,
- looparrowright: looparrowright,
- lopar: lopar,
- lopf: lopf,
- loplus: loplus,
- lotimes: lotimes,
- lowast: lowast,
- lowbar: lowbar,
- loz: loz,
- lozenge: lozenge,
- lozf: lozf,
- lpar: lpar,
- lparlt: lparlt,
- lrarr: lrarr,
- lrcorner: lrcorner,
- lrhar: lrhar,
- lrhard: lrhard,
- lrm: lrm,
- lrtri: lrtri,
- lsaquo: lsaquo,
- lscr: lscr,
- lsh: lsh,
- lsim: lsim,
- lsime: lsime,
- lsimg: lsimg,
- lsqb: lsqb,
- lsquo: lsquo,
- lsquor: lsquor,
- lstrok: lstrok,
- l: l,
- lt: lt$1,
- ltcc: ltcc,
- ltcir: ltcir,
- ltdot: ltdot,
- lthree: lthree,
- ltimes: ltimes,
- ltlarr: ltlarr,
- ltquest: ltquest,
- ltrPar: ltrPar,
- ltri: ltri,
- ltrie: ltrie,
- ltrif: ltrif,
- lurdshar: lurdshar,
- luruhar: luruhar,
- lvertneqq: lvertneqq,
- lvnE: lvnE,
- mDDot: mDDot,
- mac: mac,
- macr: macr$1,
- male: male,
- malt: malt,
- maltese: maltese,
- map: map$3,
- mapsto: mapsto,
- mapstodown: mapstodown,
- mapstoleft: mapstoleft,
- mapstoup: mapstoup,
- marker: marker,
- mcomma: mcomma,
- mcy: mcy,
- mdash: mdash,
- measuredangle: measuredangle,
- mfr: mfr,
- mho: mho,
- micr: micr,
- micro: micro$1,
- mid: mid,
- midast: midast,
- midcir: midcir,
- middo: middo,
- middot: middot$1,
- minus: minus,
- minusb: minusb,
- minusd: minusd,
- minusdu: minusdu,
- mlcp: mlcp,
- mldr: mldr,
- mnplus: mnplus,
- models: models,
- mopf: mopf,
- mp: mp,
- mscr: mscr,
- mstpos: mstpos,
- mu: mu,
- multimap: multimap,
- mumap: mumap,
- nGg: nGg,
- nGt: nGt,
- nGtv: nGtv,
- nLeftarrow: nLeftarrow,
- nLeftrightarrow: nLeftrightarrow,
- nLl: nLl,
- nLt: nLt,
- nLtv: nLtv,
- nRightarrow: nRightarrow,
- nVDash: nVDash,
- nVdash: nVdash,
- nabla: nabla,
- nacute: nacute,
- nang: nang,
- nap: nap,
- napE: napE,
- napid: napid,
- napos: napos,
- napprox: napprox,
- natur: natur,
- natural: natural,
- naturals: naturals,
- nbs: nbs,
- nbsp: nbsp$1,
- nbump: nbump,
- nbumpe: nbumpe,
- ncap: ncap,
- ncaron: ncaron,
- ncedil: ncedil,
- ncong: ncong,
- ncongdot: ncongdot,
- ncup: ncup,
- ncy: ncy,
- ndash: ndash,
- ne: ne,
- neArr: neArr,
- nearhk: nearhk,
- nearr: nearr,
- nearrow: nearrow,
- nedot: nedot,
- nequiv: nequiv,
- nesear: nesear,
- nesim: nesim,
- nexist: nexist,
- nexists: nexists,
- nfr: nfr,
- ngE: ngE,
- nge: nge,
- ngeq: ngeq,
- ngeqq: ngeqq,
- ngeqslant: ngeqslant,
- nges: nges,
- ngsim: ngsim,
- ngt: ngt,
- ngtr: ngtr,
- nhArr: nhArr,
- nharr: nharr,
- nhpar: nhpar,
- ni: ni,
- nis: nis,
- nisd: nisd,
- niv: niv,
- njcy: njcy,
- nlArr: nlArr,
- nlE: nlE,
- nlarr: nlarr,
- nldr: nldr,
- nle: nle,
- nleftarrow: nleftarrow,
- nleftrightarrow: nleftrightarrow,
- nleq: nleq,
- nleqq: nleqq,
- nleqslant: nleqslant,
- nles: nles,
- nless: nless,
- nlsim: nlsim,
- nlt: nlt,
- nltri: nltri,
- nltrie: nltrie,
- nmid: nmid,
- nopf: nopf,
- no: no,
- not: not$1,
- notin: notin,
- notinE: notinE,
- notindot: notindot,
- notinva: notinva,
- notinvb: notinvb,
- notinvc: notinvc,
- notni: notni,
- notniva: notniva,
- notnivb: notnivb,
- notnivc: notnivc,
- npar: npar,
- nparallel: nparallel,
- nparsl: nparsl,
- npart: npart,
- npolint: npolint,
- npr: npr,
- nprcue: nprcue,
- npre: npre,
- nprec: nprec,
- npreceq: npreceq,
- nrArr: nrArr,
- nrarr: nrarr,
- nrarrc: nrarrc,
- nrarrw: nrarrw,
- nrightarrow: nrightarrow,
- nrtri: nrtri,
- nrtrie: nrtrie,
- nsc: nsc,
- nsccue: nsccue,
- nsce: nsce,
- nscr: nscr,
- nshortmid: nshortmid,
- nshortparallel: nshortparallel,
- nsim: nsim,
- nsime: nsime,
- nsimeq: nsimeq,
- nsmid: nsmid,
- nspar: nspar,
- nsqsube: nsqsube,
- nsqsupe: nsqsupe,
- nsub: nsub,
- nsubE: nsubE,
- nsube: nsube,
- nsubset: nsubset,
- nsubseteq: nsubseteq,
- nsubseteqq: nsubseteqq,
- nsucc: nsucc,
- nsucceq: nsucceq,
- nsup: nsup,
- nsupE: nsupE,
- nsupe: nsupe,
- nsupset: nsupset,
- nsupseteq: nsupseteq,
- nsupseteqq: nsupseteqq,
- ntgl: ntgl,
- ntild: ntild,
- ntilde: ntilde$1,
- ntlg: ntlg,
- ntriangleleft: ntriangleleft,
- ntrianglelefteq: ntrianglelefteq,
- ntriangleright: ntriangleright,
- ntrianglerighteq: ntrianglerighteq,
- nu: nu,
- num: num,
- numero: numero,
- numsp: numsp,
- nvDash: nvDash,
- nvHarr: nvHarr,
- nvap: nvap,
- nvdash: nvdash,
- nvge: nvge,
- nvgt: nvgt,
- nvinfin: nvinfin,
- nvlArr: nvlArr,
- nvle: nvle,
- nvlt: nvlt,
- nvltrie: nvltrie,
- nvrArr: nvrArr,
- nvrtrie: nvrtrie,
- nvsim: nvsim,
- nwArr: nwArr,
- nwarhk: nwarhk,
- nwarr: nwarr,
- nwarrow: nwarrow,
- nwnear: nwnear,
- oS: oS,
- oacut: oacut,
- oacute: oacute$1,
- oast: oast,
- ocir: ocir,
- ocirc: ocirc$1,
- ocy: ocy,
- odash: odash,
- odblac: odblac,
- odiv: odiv,
- odot: odot,
- odsold: odsold,
- oelig: oelig,
- ofcir: ofcir,
- ofr: ofr,
- ogon: ogon,
- ograv: ograv,
- ograve: ograve$1,
- ogt: ogt,
- ohbar: ohbar,
- ohm: ohm,
- oint: oint,
- olarr: olarr,
- olcir: olcir,
- olcross: olcross,
- oline: oline,
- olt: olt,
- omacr: omacr,
- omega: omega,
- omicron: omicron,
- omid: omid,
- ominus: ominus,
- oopf: oopf,
- opar: opar,
- operp: operp,
- oplus: oplus,
- or: or,
- orarr: orarr,
- ord: ord,
- order: order$2,
- orderof: orderof,
- ordf: ordf$1,
- ordm: ordm$1,
- origof: origof,
- oror: oror,
- orslope: orslope,
- orv: orv,
- oscr: oscr,
- oslas: oslas,
- oslash: oslash$1,
- osol: osol,
- otild: otild,
- otilde: otilde$1,
- otimes: otimes,
- otimesas: otimesas,
- oum: oum,
- ouml: ouml$1,
- ovbar: ovbar,
- par: par,
- para: para$1,
- parallel: parallel,
- parsim: parsim,
- parsl: parsl,
- part: part,
- pcy: pcy,
- percnt: percnt,
- period: period,
- permil: permil,
- perp: perp,
- pertenk: pertenk,
- pfr: pfr,
- phi: phi,
- phiv: phiv,
- phmmat: phmmat,
- phone: phone,
- pi: pi,
- pitchfork: pitchfork,
- piv: piv,
- planck: planck,
- planckh: planckh,
- plankv: plankv,
- plus: plus,
- plusacir: plusacir,
- plusb: plusb,
- pluscir: pluscir,
- plusdo: plusdo,
- plusdu: plusdu,
- pluse: pluse,
- plusm: plusm,
- plusmn: plusmn$1,
- plussim: plussim,
- plustwo: plustwo,
- pm: pm,
- pointint: pointint,
- popf: popf,
- poun: poun,
- pound: pound$1,
- pr: pr,
- prE: prE,
- prap: prap,
- prcue: prcue,
- pre: pre,
- prec: prec,
- precapprox: precapprox,
- preccurlyeq: preccurlyeq,
- preceq: preceq,
- precnapprox: precnapprox,
- precneqq: precneqq,
- precnsim: precnsim,
- precsim: precsim,
- prime: prime,
- primes: primes,
- prnE: prnE,
- prnap: prnap,
- prnsim: prnsim,
- prod: prod,
- profalar: profalar,
- profline: profline,
- profsurf: profsurf,
- prop: prop,
- propto: propto,
- prsim: prsim,
- prurel: prurel,
- pscr: pscr,
- psi: psi,
- puncsp: puncsp,
- qfr: qfr,
- qint: qint,
- qopf: qopf,
- qprime: qprime,
- qscr: qscr,
- quaternions: quaternions,
- quatint: quatint,
- quest: quest,
- questeq: questeq,
- quo: quo,
- quot: quot$1,
- rAarr: rAarr,
- rArr: rArr,
- rAtail: rAtail,
- rBarr: rBarr,
- rHar: rHar,
- race: race,
- racute: racute,
- radic: radic,
- raemptyv: raemptyv,
- rang: rang,
- rangd: rangd,
- range: range$1,
- rangle: rangle,
- raqu: raqu,
- raquo: raquo$1,
- rarr: rarr,
- rarrap: rarrap,
- rarrb: rarrb,
- rarrbfs: rarrbfs,
- rarrc: rarrc,
- rarrfs: rarrfs,
- rarrhk: rarrhk,
- rarrlp: rarrlp,
- rarrpl: rarrpl,
- rarrsim: rarrsim,
- rarrtl: rarrtl,
- rarrw: rarrw,
- ratail: ratail,
- ratio: ratio,
- rationals: rationals,
- rbarr: rbarr,
- rbbrk: rbbrk,
- rbrace: rbrace,
- rbrack: rbrack,
- rbrke: rbrke,
- rbrksld: rbrksld,
- rbrkslu: rbrkslu,
- rcaron: rcaron,
- rcedil: rcedil,
- rceil: rceil,
- rcub: rcub,
- rcy: rcy,
- rdca: rdca,
- rdldhar: rdldhar,
- rdquo: rdquo,
- rdquor: rdquor,
- rdsh: rdsh,
- real: real,
- realine: realine,
- realpart: realpart,
- reals: reals,
- rect: rect,
- re: re,
- reg: reg$1,
- rfisht: rfisht,
- rfloor: rfloor,
- rfr: rfr,
- rhard: rhard,
- rharu: rharu,
- rharul: rharul,
- rho: rho,
- rhov: rhov,
- rightarrow: rightarrow,
- rightarrowtail: rightarrowtail,
- rightharpoondown: rightharpoondown,
- rightharpoonup: rightharpoonup,
- rightleftarrows: rightleftarrows,
- rightleftharpoons: rightleftharpoons,
- rightrightarrows: rightrightarrows,
- rightsquigarrow: rightsquigarrow,
- rightthreetimes: rightthreetimes,
- ring: ring,
- risingdotseq: risingdotseq,
- rlarr: rlarr,
- rlhar: rlhar,
- rlm: rlm,
- rmoust: rmoust,
- rmoustache: rmoustache,
- rnmid: rnmid,
- roang: roang,
- roarr: roarr,
- robrk: robrk,
- ropar: ropar,
- ropf: ropf,
- roplus: roplus,
- rotimes: rotimes,
- rpar: rpar,
- rpargt: rpargt,
- rppolint: rppolint,
- rrarr: rrarr,
- rsaquo: rsaquo,
- rscr: rscr,
- rsh: rsh,
- rsqb: rsqb,
- rsquo: rsquo,
- rsquor: rsquor,
- rthree: rthree,
- rtimes: rtimes,
- rtri: rtri,
- rtrie: rtrie,
- rtrif: rtrif,
- rtriltri: rtriltri,
- ruluhar: ruluhar,
- rx: rx,
- sacute: sacute,
- sbquo: sbquo,
- sc: sc,
- scE: scE,
- scap: scap,
- scaron: scaron,
- sccue: sccue,
- sce: sce,
- scedil: scedil,
- scirc: scirc,
- scnE: scnE,
- scnap: scnap,
- scnsim: scnsim,
- scpolint: scpolint,
- scsim: scsim,
- scy: scy,
- sdot: sdot,
- sdotb: sdotb,
- sdote: sdote,
- seArr: seArr,
- searhk: searhk,
- searr: searr,
- searrow: searrow,
- sec: sec,
- sect: sect$1,
- semi: semi,
- seswar: seswar,
- setminus: setminus,
- setmn: setmn,
- sext: sext,
- sfr: sfr,
- sfrown: sfrown,
- sharp: sharp,
- shchcy: shchcy,
- shcy: shcy,
- shortmid: shortmid,
- shortparallel: shortparallel,
- sh: sh,
- shy: shy$1,
- sigma: sigma,
- sigmaf: sigmaf,
- sigmav: sigmav,
- sim: sim,
- simdot: simdot,
- sime: sime,
- simeq: simeq,
- simg: simg,
- simgE: simgE,
- siml: siml,
- simlE: simlE,
- simne: simne,
- simplus: simplus,
- simrarr: simrarr,
- slarr: slarr,
- smallsetminus: smallsetminus,
- smashp: smashp,
- smeparsl: smeparsl,
- smid: smid,
- smile: smile,
- smt: smt,
- smte: smte,
- smtes: smtes,
- softcy: softcy,
- sol: sol,
- solb: solb,
- solbar: solbar,
- sopf: sopf,
- spades: spades,
- spadesuit: spadesuit,
- spar: spar,
- sqcap: sqcap,
- sqcaps: sqcaps,
- sqcup: sqcup,
- sqcups: sqcups,
- sqsub: sqsub,
- sqsube: sqsube,
- sqsubset: sqsubset,
- sqsubseteq: sqsubseteq,
- sqsup: sqsup,
- sqsupe: sqsupe,
- sqsupset: sqsupset,
- sqsupseteq: sqsupseteq,
- squ: squ,
- square: square,
- squarf: squarf,
- squf: squf,
- srarr: srarr,
- sscr: sscr,
- ssetmn: ssetmn,
- ssmile: ssmile,
- sstarf: sstarf,
- star: star$1,
- starf: starf,
- straightepsilon: straightepsilon,
- straightphi: straightphi,
- strns: strns,
- sub: sub,
- subE: subE,
- subdot: subdot,
- sube: sube,
- subedot: subedot,
- submult: submult,
- subnE: subnE,
- subne: subne,
- subplus: subplus,
- subrarr: subrarr,
- subset: subset,
- subseteq: subseteq,
- subseteqq: subseteqq,
- subsetneq: subsetneq,
- subsetneqq: subsetneqq,
- subsim: subsim,
- subsub: subsub,
- subsup: subsup,
- succ: succ,
- succapprox: succapprox,
- succcurlyeq: succcurlyeq,
- succeq: succeq,
- succnapprox: succnapprox,
- succneqq: succneqq,
- succnsim: succnsim,
- succsim: succsim,
- sum: sum,
- sung: sung,
- sup: sup,
- sup1: sup1$1,
- sup2: sup2$1,
- sup3: sup3$1,
- supE: supE,
- supdot: supdot,
- supdsub: supdsub,
- supe: supe,
- supedot: supedot,
- suphsol: suphsol,
- suphsub: suphsub,
- suplarr: suplarr,
- supmult: supmult,
- supnE: supnE,
- supne: supne,
- supplus: supplus,
- supset: supset,
- supseteq: supseteq,
- supseteqq: supseteqq,
- supsetneq: supsetneq,
- supsetneqq: supsetneqq,
- supsim: supsim,
- supsub: supsub,
- supsup: supsup,
- swArr: swArr,
- swarhk: swarhk,
- swarr: swarr,
- swarrow: swarrow,
- swnwar: swnwar,
- szli: szli,
- szlig: szlig$1,
- target: target,
- tau: tau,
- tbrk: tbrk,
- tcaron: tcaron,
- tcedil: tcedil,
- tcy: tcy,
- tdot: tdot,
- telrec: telrec,
- tfr: tfr,
- there4: there4,
- therefore: therefore,
- theta: theta,
- thetasym: thetasym,
- thetav: thetav,
- thickapprox: thickapprox,
- thicksim: thicksim,
- thinsp: thinsp,
- thkap: thkap,
- thksim: thksim,
- thor: thor,
- thorn: thorn$1,
- tilde: tilde,
- time: time,
- times: times$1,
- timesb: timesb,
- timesbar: timesbar,
- timesd: timesd,
- tint: tint,
- toea: toea,
- top: top,
- topbot: topbot,
- topcir: topcir,
- topf: topf,
- topfork: topfork,
- tosa: tosa,
- tprime: tprime,
- trade: trade,
- triangle: triangle,
- triangledown: triangledown,
- triangleleft: triangleleft,
- trianglelefteq: trianglelefteq,
- triangleq: triangleq,
- triangleright: triangleright,
- trianglerighteq: trianglerighteq,
- tridot: tridot,
- trie: trie,
- triminus: triminus,
- triplus: triplus,
- trisb: trisb,
- tritime: tritime,
- trpezium: trpezium,
- tscr: tscr,
- tscy: tscy,
- tshcy: tshcy,
- tstrok: tstrok,
- twixt: twixt,
- twoheadleftarrow: twoheadleftarrow,
- twoheadrightarrow: twoheadrightarrow,
- uArr: uArr,
- uHar: uHar,
- uacut: uacut,
- uacute: uacute$1,
- uarr: uarr,
- ubrcy: ubrcy,
- ubreve: ubreve,
- ucir: ucir,
- ucirc: ucirc$1,
- ucy: ucy,
- udarr: udarr,
- udblac: udblac,
- udhar: udhar,
- ufisht: ufisht,
- ufr: ufr,
- ugrav: ugrav,
- ugrave: ugrave$1,
- uharl: uharl,
- uharr: uharr,
- uhblk: uhblk,
- ulcorn: ulcorn,
- ulcorner: ulcorner,
- ulcrop: ulcrop,
- ultri: ultri,
- umacr: umacr,
- um: um,
- uml: uml$1,
- uogon: uogon,
- uopf: uopf,
- uparrow: uparrow,
- updownarrow: updownarrow,
- upharpoonleft: upharpoonleft,
- upharpoonright: upharpoonright,
- uplus: uplus,
- upsi: upsi,
- upsih: upsih,
- upsilon: upsilon,
- upuparrows: upuparrows,
- urcorn: urcorn,
- urcorner: urcorner,
- urcrop: urcrop,
- uring: uring,
- urtri: urtri,
- uscr: uscr,
- utdot: utdot,
- utilde: utilde,
- utri: utri,
- utrif: utrif,
- uuarr: uuarr,
- uum: uum,
- uuml: uuml$1,
- uwangle: uwangle,
- vArr: vArr,
- vBar: vBar,
- vBarv: vBarv,
- vDash: vDash,
- vangrt: vangrt,
- varepsilon: varepsilon,
- varkappa: varkappa,
- varnothing: varnothing,
- varphi: varphi,
- varpi: varpi,
- varpropto: varpropto,
- varr: varr,
- varrho: varrho,
- varsigma: varsigma,
- varsubsetneq: varsubsetneq,
- varsubsetneqq: varsubsetneqq,
- varsupsetneq: varsupsetneq,
- varsupsetneqq: varsupsetneqq,
- vartheta: vartheta,
- vartriangleleft: vartriangleleft,
- vartriangleright: vartriangleright,
- vcy: vcy,
- vdash: vdash,
- vee: vee,
- veebar: veebar,
- veeeq: veeeq,
- vellip: vellip,
- verbar: verbar,
- vert: vert,
- vfr: vfr,
- vltri: vltri,
- vnsub: vnsub,
- vnsup: vnsup,
- vopf: vopf,
- vprop: vprop,
- vrtri: vrtri,
- vscr: vscr,
- vsubnE: vsubnE,
- vsubne: vsubne,
- vsupnE: vsupnE,
- vsupne: vsupne,
- vzigzag: vzigzag,
- wcirc: wcirc,
- wedbar: wedbar,
- wedge: wedge,
- wedgeq: wedgeq,
- weierp: weierp,
- wfr: wfr,
- wopf: wopf,
- wp: wp,
- wr: wr,
- wreath: wreath,
- wscr: wscr,
- xcap: xcap,
- xcirc: xcirc,
- xcup: xcup,
- xdtri: xdtri,
- xfr: xfr,
- xhArr: xhArr,
- xharr: xharr,
- xi: xi,
- xlArr: xlArr,
- xlarr: xlarr,
- xmap: xmap,
- xnis: xnis,
- xodot: xodot,
- xopf: xopf,
- xoplus: xoplus,
- xotime: xotime,
- xrArr: xrArr,
- xrarr: xrarr,
- xscr: xscr,
- xsqcup: xsqcup,
- xuplus: xuplus,
- xutri: xutri,
- xvee: xvee,
- xwedge: xwedge,
- yacut: yacut,
- yacute: yacute$1,
- yacy: yacy,
- ycirc: ycirc,
- ycy: ycy,
- ye: ye,
- yen: yen$1,
- yfr: yfr,
- yicy: yicy,
- yopf: yopf,
- yscr: yscr,
- yucy: yucy,
- yum: yum,
- yuml: yuml$1,
- zacute: zacute,
- zcaron: zcaron,
- zcy: zcy,
- zdot: zdot,
- zeetrf: zeetrf,
- zeta: zeta,
- zfr: zfr,
- zhcy: zhcy,
- zigrarr: zigrarr,
- zopf: zopf,
- zscr: zscr,
- zwj: zwj,
- zwnj: zwnj,
- "Map": "⤅",
- "in": "∈"
-};
+var path = __webpack_require__(4)
+var replace = __webpack_require__(66)
+var buffer = __webpack_require__(207)
-var characterEntities = Object.freeze({
- AEli: AEli,
- AElig: AElig$1,
- AM: AM,
- AMP: AMP$1,
- Aacut: Aacut,
- Aacute: Aacute$1,
- Abreve: Abreve,
- Acir: Acir,
- Acirc: Acirc$1,
- Acy: Acy,
- Afr: Afr,
- Agrav: Agrav,
- Agrave: Agrave$1,
- Alpha: Alpha,
- Amacr: Amacr,
- And: And,
- Aogon: Aogon,
- Aopf: Aopf,
- ApplyFunction: ApplyFunction,
- Arin: Arin,
- Aring: Aring$1,
- Ascr: Ascr,
- Assign: Assign,
- Atild: Atild,
- Atilde: Atilde$1,
- Aum: Aum,
- Auml: Auml$1,
- Backslash: Backslash,
- Barv: Barv,
- Barwed: Barwed,
- Bcy: Bcy,
- Because: Because,
- Bernoullis: Bernoullis,
- Beta: Beta,
- Bfr: Bfr,
- Bopf: Bopf,
- Breve: Breve,
- Bscr: Bscr,
- Bumpeq: Bumpeq,
- CHcy: CHcy,
- COP: COP,
- COPY: COPY$1,
- Cacute: Cacute,
- Cap: Cap,
- CapitalDifferentialD: CapitalDifferentialD,
- Cayleys: Cayleys,
- Ccaron: Ccaron,
- Ccedi: Ccedi,
- Ccedil: Ccedil$1,
- Ccirc: Ccirc,
- Cconint: Cconint,
- Cdot: Cdot,
- Cedilla: Cedilla,
- CenterDot: CenterDot,
- Cfr: Cfr,
- Chi: Chi,
- CircleDot: CircleDot,
- CircleMinus: CircleMinus,
- CirclePlus: CirclePlus,
- CircleTimes: CircleTimes,
- ClockwiseContourIntegral: ClockwiseContourIntegral,
- CloseCurlyDoubleQuote: CloseCurlyDoubleQuote,
- CloseCurlyQuote: CloseCurlyQuote,
- Colon: Colon,
- Colone: Colone,
- Congruent: Congruent,
- Conint: Conint,
- ContourIntegral: ContourIntegral,
- Copf: Copf,
- Coproduct: Coproduct,
- CounterClockwiseContourIntegral: CounterClockwiseContourIntegral,
- Cross: Cross,
- Cscr: Cscr,
- Cup: Cup,
- CupCap: CupCap,
- DD: DD,
- DDotrahd: DDotrahd,
- DJcy: DJcy,
- DScy: DScy,
- DZcy: DZcy,
- Dagger: Dagger,
- Darr: Darr,
- Dashv: Dashv,
- Dcaron: Dcaron,
- Dcy: Dcy,
- Del: Del,
- Delta: Delta,
- Dfr: Dfr,
- DiacriticalAcute: DiacriticalAcute,
- DiacriticalDot: DiacriticalDot,
- DiacriticalDoubleAcute: DiacriticalDoubleAcute,
- DiacriticalGrave: DiacriticalGrave,
- DiacriticalTilde: DiacriticalTilde,
- Diamond: Diamond,
- DifferentialD: DifferentialD,
- Dopf: Dopf,
- Dot: Dot,
- DotDot: DotDot,
- DotEqual: DotEqual,
- DoubleContourIntegral: DoubleContourIntegral,
- DoubleDot: DoubleDot,
- DoubleDownArrow: DoubleDownArrow,
- DoubleLeftArrow: DoubleLeftArrow,
- DoubleLeftRightArrow: DoubleLeftRightArrow,
- DoubleLeftTee: DoubleLeftTee,
- DoubleLongLeftArrow: DoubleLongLeftArrow,
- DoubleLongLeftRightArrow: DoubleLongLeftRightArrow,
- DoubleLongRightArrow: DoubleLongRightArrow,
- DoubleRightArrow: DoubleRightArrow,
- DoubleRightTee: DoubleRightTee,
- DoubleUpArrow: DoubleUpArrow,
- DoubleUpDownArrow: DoubleUpDownArrow,
- DoubleVerticalBar: DoubleVerticalBar,
- DownArrow: DownArrow,
- DownArrowBar: DownArrowBar,
- DownArrowUpArrow: DownArrowUpArrow,
- DownBreve: DownBreve,
- DownLeftRightVector: DownLeftRightVector,
- DownLeftTeeVector: DownLeftTeeVector,
- DownLeftVector: DownLeftVector,
- DownLeftVectorBar: DownLeftVectorBar,
- DownRightTeeVector: DownRightTeeVector,
- DownRightVector: DownRightVector,
- DownRightVectorBar: DownRightVectorBar,
- DownTee: DownTee,
- DownTeeArrow: DownTeeArrow,
- Downarrow: Downarrow,
- Dscr: Dscr,
- Dstrok: Dstrok,
- ENG: ENG,
- ET: ET,
- ETH: ETH$1,
- Eacut: Eacut,
- Eacute: Eacute$1,
- Ecaron: Ecaron,
- Ecir: Ecir,
- Ecirc: Ecirc$1,
- Ecy: Ecy,
- Edot: Edot,
- Efr: Efr,
- Egrav: Egrav,
- Egrave: Egrave$1,
- Element: Element,
- Emacr: Emacr,
- EmptySmallSquare: EmptySmallSquare,
- EmptyVerySmallSquare: EmptyVerySmallSquare,
- Eogon: Eogon,
- Eopf: Eopf,
- Epsilon: Epsilon,
- Equal: Equal,
- EqualTilde: EqualTilde,
- Equilibrium: Equilibrium,
- Escr: Escr,
- Esim: Esim,
- Eta: Eta,
- Eum: Eum,
- Euml: Euml$1,
- Exists: Exists,
- ExponentialE: ExponentialE,
- Fcy: Fcy,
- Ffr: Ffr,
- FilledSmallSquare: FilledSmallSquare,
- FilledVerySmallSquare: FilledVerySmallSquare,
- Fopf: Fopf,
- ForAll: ForAll,
- Fouriertrf: Fouriertrf,
- Fscr: Fscr,
- GJcy: GJcy,
- G: G,
- GT: GT$1,
- Gamma: Gamma,
- Gammad: Gammad,
- Gbreve: Gbreve,
- Gcedil: Gcedil,
- Gcirc: Gcirc,
- Gcy: Gcy,
- Gdot: Gdot,
- Gfr: Gfr,
- Gg: Gg,
- Gopf: Gopf,
- GreaterEqual: GreaterEqual,
- GreaterEqualLess: GreaterEqualLess,
- GreaterFullEqual: GreaterFullEqual,
- GreaterGreater: GreaterGreater,
- GreaterLess: GreaterLess,
- GreaterSlantEqual: GreaterSlantEqual,
- GreaterTilde: GreaterTilde,
- Gscr: Gscr,
- Gt: Gt,
- HARDcy: HARDcy,
- Hacek: Hacek,
- Hat: Hat,
- Hcirc: Hcirc,
- Hfr: Hfr,
- HilbertSpace: HilbertSpace,
- Hopf: Hopf,
- HorizontalLine: HorizontalLine,
- Hscr: Hscr,
- Hstrok: Hstrok,
- HumpDownHump: HumpDownHump,
- HumpEqual: HumpEqual,
- IEcy: IEcy,
- IJlig: IJlig,
- IOcy: IOcy,
- Iacut: Iacut,
- Iacute: Iacute$1,
- Icir: Icir,
- Icirc: Icirc$1,
- Icy: Icy,
- Idot: Idot,
- Ifr: Ifr,
- Igrav: Igrav,
- Igrave: Igrave$1,
- Im: Im,
- Imacr: Imacr,
- ImaginaryI: ImaginaryI,
- Implies: Implies,
- Int: Int,
- Integral: Integral,
- Intersection: Intersection,
- InvisibleComma: InvisibleComma,
- InvisibleTimes: InvisibleTimes,
- Iogon: Iogon,
- Iopf: Iopf,
- Iota: Iota,
- Iscr: Iscr,
- Itilde: Itilde,
- Iukcy: Iukcy,
- Ium: Ium,
- Iuml: Iuml$1,
- Jcirc: Jcirc,
- Jcy: Jcy,
- Jfr: Jfr,
- Jopf: Jopf,
- Jscr: Jscr,
- Jsercy: Jsercy,
- Jukcy: Jukcy,
- KHcy: KHcy,
- KJcy: KJcy,
- Kappa: Kappa,
- Kcedil: Kcedil,
- Kcy: Kcy,
- Kfr: Kfr,
- Kopf: Kopf,
- Kscr: Kscr,
- LJcy: LJcy,
- L: L,
- LT: LT$1,
- Lacute: Lacute,
- Lambda: Lambda,
- Lang: Lang,
- Laplacetrf: Laplacetrf,
- Larr: Larr,
- Lcaron: Lcaron,
- Lcedil: Lcedil,
- Lcy: Lcy,
- LeftAngleBracket: LeftAngleBracket,
- LeftArrow: LeftArrow,
- LeftArrowBar: LeftArrowBar,
- LeftArrowRightArrow: LeftArrowRightArrow,
- LeftCeiling: LeftCeiling,
- LeftDoubleBracket: LeftDoubleBracket,
- LeftDownTeeVector: LeftDownTeeVector,
- LeftDownVector: LeftDownVector,
- LeftDownVectorBar: LeftDownVectorBar,
- LeftFloor: LeftFloor,
- LeftRightArrow: LeftRightArrow,
- LeftRightVector: LeftRightVector,
- LeftTee: LeftTee,
- LeftTeeArrow: LeftTeeArrow,
- LeftTeeVector: LeftTeeVector,
- LeftTriangle: LeftTriangle,
- LeftTriangleBar: LeftTriangleBar,
- LeftTriangleEqual: LeftTriangleEqual,
- LeftUpDownVector: LeftUpDownVector,
- LeftUpTeeVector: LeftUpTeeVector,
- LeftUpVector: LeftUpVector,
- LeftUpVectorBar: LeftUpVectorBar,
- LeftVector: LeftVector,
- LeftVectorBar: LeftVectorBar,
- Leftarrow: Leftarrow,
- Leftrightarrow: Leftrightarrow,
- LessEqualGreater: LessEqualGreater,
- LessFullEqual: LessFullEqual,
- LessGreater: LessGreater,
- LessLess: LessLess,
- LessSlantEqual: LessSlantEqual,
- LessTilde: LessTilde,
- Lfr: Lfr,
- Ll: Ll,
- Lleftarrow: Lleftarrow,
- Lmidot: Lmidot,
- LongLeftArrow: LongLeftArrow,
- LongLeftRightArrow: LongLeftRightArrow,
- LongRightArrow: LongRightArrow,
- Longleftarrow: Longleftarrow,
- Longleftrightarrow: Longleftrightarrow,
- Longrightarrow: Longrightarrow,
- Lopf: Lopf,
- LowerLeftArrow: LowerLeftArrow,
- LowerRightArrow: LowerRightArrow,
- Lscr: Lscr,
- Lsh: Lsh,
- Lstrok: Lstrok,
- Lt: Lt,
- Mcy: Mcy,
- MediumSpace: MediumSpace,
- Mellintrf: Mellintrf,
- Mfr: Mfr,
- MinusPlus: MinusPlus,
- Mopf: Mopf,
- Mscr: Mscr,
- Mu: Mu,
- NJcy: NJcy,
- Nacute: Nacute,
- Ncaron: Ncaron,
- Ncedil: Ncedil,
- Ncy: Ncy,
- NegativeMediumSpace: NegativeMediumSpace,
- NegativeThickSpace: NegativeThickSpace,
- NegativeThinSpace: NegativeThinSpace,
- NegativeVeryThinSpace: NegativeVeryThinSpace,
- NestedGreaterGreater: NestedGreaterGreater,
- NestedLessLess: NestedLessLess,
- NewLine: NewLine,
- Nfr: Nfr,
- NoBreak: NoBreak,
- NonBreakingSpace: NonBreakingSpace,
- Nopf: Nopf,
- Not: Not,
- NotCongruent: NotCongruent,
- NotCupCap: NotCupCap,
- NotDoubleVerticalBar: NotDoubleVerticalBar,
- NotElement: NotElement,
- NotEqual: NotEqual,
- NotEqualTilde: NotEqualTilde,
- NotExists: NotExists,
- NotGreater: NotGreater,
- NotGreaterEqual: NotGreaterEqual,
- NotGreaterFullEqual: NotGreaterFullEqual,
- NotGreaterGreater: NotGreaterGreater,
- NotGreaterLess: NotGreaterLess,
- NotGreaterSlantEqual: NotGreaterSlantEqual,
- NotGreaterTilde: NotGreaterTilde,
- NotHumpDownHump: NotHumpDownHump,
- NotHumpEqual: NotHumpEqual,
- NotLeftTriangle: NotLeftTriangle,
- NotLeftTriangleBar: NotLeftTriangleBar,
- NotLeftTriangleEqual: NotLeftTriangleEqual,
- NotLess: NotLess,
- NotLessEqual: NotLessEqual,
- NotLessGreater: NotLessGreater,
- NotLessLess: NotLessLess,
- NotLessSlantEqual: NotLessSlantEqual,
- NotLessTilde: NotLessTilde,
- NotNestedGreaterGreater: NotNestedGreaterGreater,
- NotNestedLessLess: NotNestedLessLess,
- NotPrecedes: NotPrecedes,
- NotPrecedesEqual: NotPrecedesEqual,
- NotPrecedesSlantEqual: NotPrecedesSlantEqual,
- NotReverseElement: NotReverseElement,
- NotRightTriangle: NotRightTriangle,
- NotRightTriangleBar: NotRightTriangleBar,
- NotRightTriangleEqual: NotRightTriangleEqual,
- NotSquareSubset: NotSquareSubset,
- NotSquareSubsetEqual: NotSquareSubsetEqual,
- NotSquareSuperset: NotSquareSuperset,
- NotSquareSupersetEqual: NotSquareSupersetEqual,
- NotSubset: NotSubset,
- NotSubsetEqual: NotSubsetEqual,
- NotSucceeds: NotSucceeds,
- NotSucceedsEqual: NotSucceedsEqual,
- NotSucceedsSlantEqual: NotSucceedsSlantEqual,
- NotSucceedsTilde: NotSucceedsTilde,
- NotSuperset: NotSuperset,
- NotSupersetEqual: NotSupersetEqual,
- NotTilde: NotTilde,
- NotTildeEqual: NotTildeEqual,
- NotTildeFullEqual: NotTildeFullEqual,
- NotTildeTilde: NotTildeTilde,
- NotVerticalBar: NotVerticalBar,
- Nscr: Nscr,
- Ntild: Ntild,
- Ntilde: Ntilde$1,
- Nu: Nu,
- OElig: OElig,
- Oacut: Oacut,
- Oacute: Oacute$1,
- Ocir: Ocir,
- Ocirc: Ocirc$1,
- Ocy: Ocy,
- Odblac: Odblac,
- Ofr: Ofr,
- Ograv: Ograv,
- Ograve: Ograve$1,
- Omacr: Omacr,
- Omega: Omega,
- Omicron: Omicron,
- Oopf: Oopf,
- OpenCurlyDoubleQuote: OpenCurlyDoubleQuote,
- OpenCurlyQuote: OpenCurlyQuote,
- Or: Or,
- Oscr: Oscr,
- Oslas: Oslas,
- Oslash: Oslash$1,
- Otild: Otild,
- Otilde: Otilde$1,
- Otimes: Otimes,
- Oum: Oum,
- Ouml: Ouml$1,
- OverBar: OverBar,
- OverBrace: OverBrace,
- OverBracket: OverBracket,
- OverParenthesis: OverParenthesis,
- PartialD: PartialD,
- Pcy: Pcy,
- Pfr: Pfr,
- Phi: Phi,
- Pi: Pi,
- PlusMinus: PlusMinus,
- Poincareplane: Poincareplane,
- Popf: Popf,
- Pr: Pr,
- Precedes: Precedes,
- PrecedesEqual: PrecedesEqual,
- PrecedesSlantEqual: PrecedesSlantEqual,
- PrecedesTilde: PrecedesTilde,
- Prime: Prime,
- Product: Product,
- Proportion: Proportion,
- Proportional: Proportional,
- Pscr: Pscr,
- Psi: Psi,
- QUO: QUO,
- QUOT: QUOT$1,
- Qfr: Qfr,
- Qopf: Qopf,
- Qscr: Qscr,
- RBarr: RBarr,
- RE: RE,
- REG: REG$1,
- Racute: Racute,
- Rang: Rang,
- Rarr: Rarr,
- Rarrtl: Rarrtl,
- Rcaron: Rcaron,
- Rcedil: Rcedil,
- Rcy: Rcy,
- Re: Re,
- ReverseElement: ReverseElement,
- ReverseEquilibrium: ReverseEquilibrium,
- ReverseUpEquilibrium: ReverseUpEquilibrium,
- Rfr: Rfr,
- Rho: Rho,
- RightAngleBracket: RightAngleBracket,
- RightArrow: RightArrow,
- RightArrowBar: RightArrowBar,
- RightArrowLeftArrow: RightArrowLeftArrow,
- RightCeiling: RightCeiling,
- RightDoubleBracket: RightDoubleBracket,
- RightDownTeeVector: RightDownTeeVector,
- RightDownVector: RightDownVector,
- RightDownVectorBar: RightDownVectorBar,
- RightFloor: RightFloor,
- RightTee: RightTee,
- RightTeeArrow: RightTeeArrow,
- RightTeeVector: RightTeeVector,
- RightTriangle: RightTriangle,
- RightTriangleBar: RightTriangleBar,
- RightTriangleEqual: RightTriangleEqual,
- RightUpDownVector: RightUpDownVector,
- RightUpTeeVector: RightUpTeeVector,
- RightUpVector: RightUpVector,
- RightUpVectorBar: RightUpVectorBar,
- RightVector: RightVector,
- RightVectorBar: RightVectorBar,
- Rightarrow: Rightarrow,
- Ropf: Ropf,
- RoundImplies: RoundImplies,
- Rrightarrow: Rrightarrow,
- Rscr: Rscr,
- Rsh: Rsh,
- RuleDelayed: RuleDelayed,
- SHCHcy: SHCHcy,
- SHcy: SHcy,
- SOFTcy: SOFTcy,
- Sacute: Sacute,
- Sc: Sc,
- Scaron: Scaron,
- Scedil: Scedil,
- Scirc: Scirc,
- Scy: Scy,
- Sfr: Sfr,
- ShortDownArrow: ShortDownArrow,
- ShortLeftArrow: ShortLeftArrow,
- ShortRightArrow: ShortRightArrow,
- ShortUpArrow: ShortUpArrow,
- Sigma: Sigma,
- SmallCircle: SmallCircle,
- Sopf: Sopf,
- Sqrt: Sqrt,
- Square: Square,
- SquareIntersection: SquareIntersection,
- SquareSubset: SquareSubset,
- SquareSubsetEqual: SquareSubsetEqual,
- SquareSuperset: SquareSuperset,
- SquareSupersetEqual: SquareSupersetEqual,
- SquareUnion: SquareUnion,
- Sscr: Sscr,
- Star: Star,
- Sub: Sub,
- Subset: Subset,
- SubsetEqual: SubsetEqual,
- Succeeds: Succeeds,
- SucceedsEqual: SucceedsEqual,
- SucceedsSlantEqual: SucceedsSlantEqual,
- SucceedsTilde: SucceedsTilde,
- SuchThat: SuchThat,
- Sum: Sum,
- Sup: Sup,
- Superset: Superset,
- SupersetEqual: SupersetEqual,
- Supset: Supset,
- THOR: THOR,
- THORN: THORN$1,
- TRADE: TRADE,
- TSHcy: TSHcy,
- TScy: TScy,
- Tab: Tab,
- Tau: Tau,
- Tcaron: Tcaron,
- Tcedil: Tcedil,
- Tcy: Tcy,
- Tfr: Tfr,
- Therefore: Therefore,
- Theta: Theta,
- ThickSpace: ThickSpace,
- ThinSpace: ThinSpace,
- Tilde: Tilde,
- TildeEqual: TildeEqual,
- TildeFullEqual: TildeFullEqual,
- TildeTilde: TildeTilde,
- Topf: Topf,
- TripleDot: TripleDot,
- Tscr: Tscr,
- Tstrok: Tstrok,
- Uacut: Uacut,
- Uacute: Uacute$1,
- Uarr: Uarr,
- Uarrocir: Uarrocir,
- Ubrcy: Ubrcy,
- Ubreve: Ubreve,
- Ucir: Ucir,
- Ucirc: Ucirc$1,
- Ucy: Ucy,
- Udblac: Udblac,
- Ufr: Ufr,
- Ugrav: Ugrav,
- Ugrave: Ugrave$1,
- Umacr: Umacr,
- UnderBar: UnderBar,
- UnderBrace: UnderBrace,
- UnderBracket: UnderBracket,
- UnderParenthesis: UnderParenthesis,
- Union: Union,
- UnionPlus: UnionPlus,
- Uogon: Uogon,
- Uopf: Uopf,
- UpArrow: UpArrow,
- UpArrowBar: UpArrowBar,
- UpArrowDownArrow: UpArrowDownArrow,
- UpDownArrow: UpDownArrow,
- UpEquilibrium: UpEquilibrium,
- UpTee: UpTee,
- UpTeeArrow: UpTeeArrow,
- Uparrow: Uparrow,
- Updownarrow: Updownarrow,
- UpperLeftArrow: UpperLeftArrow,
- UpperRightArrow: UpperRightArrow,
- Upsi: Upsi,
- Upsilon: Upsilon,
- Uring: Uring,
- Uscr: Uscr,
- Utilde: Utilde,
- Uum: Uum,
- Uuml: Uuml$1,
- VDash: VDash,
- Vbar: Vbar,
- Vcy: Vcy,
- Vdash: Vdash,
- Vdashl: Vdashl,
- Vee: Vee,
- Verbar: Verbar,
- Vert: Vert,
- VerticalBar: VerticalBar,
- VerticalLine: VerticalLine,
- VerticalSeparator: VerticalSeparator,
- VerticalTilde: VerticalTilde,
- VeryThinSpace: VeryThinSpace,
- Vfr: Vfr,
- Vopf: Vopf,
- Vscr: Vscr,
- Vvdash: Vvdash,
- Wcirc: Wcirc,
- Wedge: Wedge,
- Wfr: Wfr,
- Wopf: Wopf,
- Wscr: Wscr,
- Xfr: Xfr,
- Xi: Xi,
- Xopf: Xopf,
- Xscr: Xscr,
- YAcy: YAcy,
- YIcy: YIcy,
- YUcy: YUcy,
- Yacut: Yacut,
- Yacute: Yacute$1,
- Ycirc: Ycirc,
- Ycy: Ycy,
- Yfr: Yfr,
- Yopf: Yopf,
- Yscr: Yscr,
- Yuml: Yuml,
- ZHcy: ZHcy,
- Zacute: Zacute,
- Zcaron: Zcaron,
- Zcy: Zcy,
- Zdot: Zdot,
- ZeroWidthSpace: ZeroWidthSpace,
- Zeta: Zeta,
- Zfr: Zfr,
- Zopf: Zopf,
- Zscr: Zscr,
- aacut: aacut,
- aacute: aacute$1,
- abreve: abreve,
- ac: ac,
- acE: acE,
- acd: acd,
- acir: acir,
- acirc: acirc$1,
- acut: acut,
- acute: acute$1,
- acy: acy,
- aeli: aeli,
- aelig: aelig$1,
- af: af,
- afr: afr,
- agrav: agrav,
- agrave: agrave$1,
- alefsym: alefsym,
- aleph: aleph,
- alpha: alpha,
- amacr: amacr,
- amalg: amalg,
- am: am,
- amp: amp$1,
- and: and,
- andand: andand,
- andd: andd,
- andslope: andslope,
- andv: andv,
- ang: ang,
- ange: ange,
- angle: angle,
- angmsd: angmsd,
- angmsdaa: angmsdaa,
- angmsdab: angmsdab,
- angmsdac: angmsdac,
- angmsdad: angmsdad,
- angmsdae: angmsdae,
- angmsdaf: angmsdaf,
- angmsdag: angmsdag,
- angmsdah: angmsdah,
- angrt: angrt,
- angrtvb: angrtvb,
- angrtvbd: angrtvbd,
- angsph: angsph,
- angst: angst,
- angzarr: angzarr,
- aogon: aogon,
- aopf: aopf,
- ap: ap,
- apE: apE,
- apacir: apacir,
- ape: ape,
- apid: apid,
- apos: apos,
- approx: approx,
- approxeq: approxeq,
- arin: arin,
- aring: aring$1,
- ascr: ascr,
- ast: ast,
- asymp: asymp,
- asympeq: asympeq,
- atild: atild,
- atilde: atilde$1,
- aum: aum,
- auml: auml$1,
- awconint: awconint,
- awint: awint,
- bNot: bNot,
- backcong: backcong,
- backepsilon: backepsilon,
- backprime: backprime,
- backsim: backsim,
- backsimeq: backsimeq,
- barvee: barvee,
- barwed: barwed,
- barwedge: barwedge,
- bbrk: bbrk,
- bbrktbrk: bbrktbrk,
- bcong: bcong,
- bcy: bcy,
- bdquo: bdquo,
- becaus: becaus,
- because: because,
- bemptyv: bemptyv,
- bepsi: bepsi,
- bernou: bernou,
- beta: beta,
- beth: beth,
- between: between,
- bfr: bfr,
- bigcap: bigcap,
- bigcirc: bigcirc,
- bigcup: bigcup,
- bigodot: bigodot,
- bigoplus: bigoplus,
- bigotimes: bigotimes,
- bigsqcup: bigsqcup,
- bigstar: bigstar,
- bigtriangledown: bigtriangledown,
- bigtriangleup: bigtriangleup,
- biguplus: biguplus,
- bigvee: bigvee,
- bigwedge: bigwedge,
- bkarow: bkarow,
- blacklozenge: blacklozenge,
- blacksquare: blacksquare,
- blacktriangle: blacktriangle,
- blacktriangledown: blacktriangledown,
- blacktriangleleft: blacktriangleleft,
- blacktriangleright: blacktriangleright,
- blank: blank,
- blk12: blk12,
- blk14: blk14,
- blk34: blk34,
- block: block,
- bne: bne,
- bnequiv: bnequiv,
- bnot: bnot,
- bopf: bopf,
- bot: bot,
- bottom: bottom,
- bowtie: bowtie,
- boxDL: boxDL,
- boxDR: boxDR,
- boxDl: boxDl,
- boxDr: boxDr,
- boxH: boxH,
- boxHD: boxHD,
- boxHU: boxHU,
- boxHd: boxHd,
- boxHu: boxHu,
- boxUL: boxUL,
- boxUR: boxUR,
- boxUl: boxUl,
- boxUr: boxUr,
- boxV: boxV,
- boxVH: boxVH,
- boxVL: boxVL,
- boxVR: boxVR,
- boxVh: boxVh,
- boxVl: boxVl,
- boxVr: boxVr,
- boxbox: boxbox,
- boxdL: boxdL,
- boxdR: boxdR,
- boxdl: boxdl,
- boxdr: boxdr,
- boxh: boxh,
- boxhD: boxhD,
- boxhU: boxhU,
- boxhd: boxhd,
- boxhu: boxhu,
- boxminus: boxminus,
- boxplus: boxplus,
- boxtimes: boxtimes,
- boxuL: boxuL,
- boxuR: boxuR,
- boxul: boxul,
- boxur: boxur,
- boxv: boxv,
- boxvH: boxvH,
- boxvL: boxvL,
- boxvR: boxvR,
- boxvh: boxvh,
- boxvl: boxvl,
- boxvr: boxvr,
- bprime: bprime,
- breve: breve,
- brvba: brvba,
- brvbar: brvbar$1,
- bscr: bscr,
- bsemi: bsemi,
- bsim: bsim,
- bsime: bsime,
- bsol: bsol,
- bsolb: bsolb,
- bsolhsub: bsolhsub,
- bull: bull,
- bullet: bullet,
- bump: bump,
- bumpE: bumpE,
- bumpe: bumpe,
- bumpeq: bumpeq,
- cacute: cacute,
- cap: cap,
- capand: capand,
- capbrcup: capbrcup,
- capcap: capcap,
- capcup: capcup,
- capdot: capdot,
- caps: caps,
- caret: caret,
- caron: caron,
- ccaps: ccaps,
- ccaron: ccaron,
- ccedi: ccedi,
- ccedil: ccedil$1,
- ccirc: ccirc,
- ccups: ccups,
- ccupssm: ccupssm,
- cdot: cdot,
- cedi: cedi,
- cedil: cedil$1,
- cemptyv: cemptyv,
- cen: cen,
- cent: cent$1,
- centerdot: centerdot,
- cfr: cfr,
- chcy: chcy,
- check: check$2,
- checkmark: checkmark,
- chi: chi,
- cir: cir,
- cirE: cirE,
- circ: circ,
- circeq: circeq,
- circlearrowleft: circlearrowleft,
- circlearrowright: circlearrowright,
- circledR: circledR,
- circledS: circledS,
- circledast: circledast,
- circledcirc: circledcirc,
- circleddash: circleddash,
- cire: cire,
- cirfnint: cirfnint,
- cirmid: cirmid,
- cirscir: cirscir,
- clubs: clubs,
- clubsuit: clubsuit,
- colon: colon,
- colone: colone,
- coloneq: coloneq,
- comma: comma,
- commat: commat,
- comp: comp,
- compfn: compfn,
- complement: complement,
- complexes: complexes,
- cong: cong,
- congdot: congdot,
- conint: conint,
- copf: copf,
- coprod: coprod,
- cop: cop,
- copy: copy$3,
- copysr: copysr,
- crarr: crarr,
- cross: cross,
- cscr: cscr,
- csub: csub,
- csube: csube,
- csup: csup,
- csupe: csupe,
- ctdot: ctdot,
- cudarrl: cudarrl,
- cudarrr: cudarrr,
- cuepr: cuepr,
- cuesc: cuesc,
- cularr: cularr,
- cularrp: cularrp,
- cup: cup,
- cupbrcap: cupbrcap,
- cupcap: cupcap,
- cupcup: cupcup,
- cupdot: cupdot,
- cupor: cupor,
- cups: cups,
- curarr: curarr,
- curarrm: curarrm,
- curlyeqprec: curlyeqprec,
- curlyeqsucc: curlyeqsucc,
- curlyvee: curlyvee,
- curlywedge: curlywedge,
- curre: curre,
- curren: curren$1,
- curvearrowleft: curvearrowleft,
- curvearrowright: curvearrowright,
- cuvee: cuvee,
- cuwed: cuwed,
- cwconint: cwconint,
- cwint: cwint,
- cylcty: cylcty,
- dArr: dArr,
- dHar: dHar,
- dagger: dagger,
- daleth: daleth,
- darr: darr,
- dash: dash,
- dashv: dashv,
- dbkarow: dbkarow,
- dblac: dblac,
- dcaron: dcaron,
- dcy: dcy,
- dd: dd,
- ddagger: ddagger,
- ddarr: ddarr,
- ddotseq: ddotseq,
- de: de,
- deg: deg$1,
- delta: delta,
- demptyv: demptyv,
- dfisht: dfisht,
- dfr: dfr,
- dharl: dharl,
- dharr: dharr,
- diam: diam,
- diamond: diamond,
- diamondsuit: diamondsuit,
- diams: diams,
- die: die,
- digamma: digamma,
- disin: disin,
- div: div,
- divid: divid,
- divide: divide$1,
- divideontimes: divideontimes,
- divonx: divonx,
- djcy: djcy,
- dlcorn: dlcorn,
- dlcrop: dlcrop,
- dollar: dollar,
- dopf: dopf,
- dot: dot,
- doteq: doteq,
- doteqdot: doteqdot,
- dotminus: dotminus,
- dotplus: dotplus,
- dotsquare: dotsquare,
- doublebarwedge: doublebarwedge,
- downarrow: downarrow,
- downdownarrows: downdownarrows,
- downharpoonleft: downharpoonleft,
- downharpoonright: downharpoonright,
- drbkarow: drbkarow,
- drcorn: drcorn,
- drcrop: drcrop,
- dscr: dscr,
- dscy: dscy,
- dsol: dsol,
- dstrok: dstrok,
- dtdot: dtdot,
- dtri: dtri,
- dtrif: dtrif,
- duarr: duarr,
- duhar: duhar,
- dwangle: dwangle,
- dzcy: dzcy,
- dzigrarr: dzigrarr,
- eDDot: eDDot,
- eDot: eDot,
- eacut: eacut,
- eacute: eacute$1,
- easter: easter,
- ecaron: ecaron,
- ecir: ecir,
- ecirc: ecirc$1,
- ecolon: ecolon,
- ecy: ecy,
- edot: edot,
- ee: ee,
- efDot: efDot,
- efr: efr,
- eg: eg,
- egrav: egrav,
- egrave: egrave$1,
- egs: egs,
- egsdot: egsdot,
- el: el,
- elinters: elinters,
- ell: ell,
- els: els,
- elsdot: elsdot,
- emacr: emacr,
- empty: empty,
- emptyset: emptyset,
- emptyv: emptyv,
- emsp13: emsp13,
- emsp14: emsp14,
- emsp: emsp,
- eng: eng,
- ensp: ensp,
- eogon: eogon,
- eopf: eopf,
- epar: epar,
- eparsl: eparsl,
- eplus: eplus,
- epsi: epsi,
- epsilon: epsilon,
- epsiv: epsiv,
- eqcirc: eqcirc,
- eqcolon: eqcolon,
- eqsim: eqsim,
- eqslantgtr: eqslantgtr,
- eqslantless: eqslantless,
- equals: equals,
- equest: equest,
- equiv: equiv,
- equivDD: equivDD,
- eqvparsl: eqvparsl,
- erDot: erDot,
- erarr: erarr,
- escr: escr,
- esdot: esdot,
- esim: esim,
- eta: eta,
- et: et,
- eth: eth$1,
- eum: eum,
- euml: euml$1,
- euro: euro,
- excl: excl,
- exist: exist,
- expectation: expectation,
- exponentiale: exponentiale,
- fallingdotseq: fallingdotseq,
- fcy: fcy,
- female: female,
- ffilig: ffilig,
- fflig: fflig,
- ffllig: ffllig,
- ffr: ffr,
- filig: filig,
- fjlig: fjlig,
- flat: flat,
- fllig: fllig,
- fltns: fltns,
- fnof: fnof,
- fopf: fopf,
- forall: forall,
- fork: fork,
- forkv: forkv,
- fpartint: fpartint,
- frac1: frac1,
- frac12: frac12$1,
- frac13: frac13,
- frac14: frac14$1,
- frac15: frac15,
- frac16: frac16,
- frac18: frac18,
- frac23: frac23,
- frac25: frac25,
- frac3: frac3,
- frac34: frac34$1,
- frac35: frac35,
- frac38: frac38,
- frac45: frac45,
- frac56: frac56,
- frac58: frac58,
- frac78: frac78,
- frasl: frasl,
- frown: frown,
- fscr: fscr,
- gE: gE,
- gEl: gEl,
- gacute: gacute,
- gamma: gamma,
- gammad: gammad,
- gap: gap,
- gbreve: gbreve,
- gcirc: gcirc,
- gcy: gcy,
- gdot: gdot,
- ge: ge,
- gel: gel,
- geq: geq,
- geqq: geqq,
- geqslant: geqslant,
- ges: ges,
- gescc: gescc,
- gesdot: gesdot,
- gesdoto: gesdoto,
- gesdotol: gesdotol,
- gesl: gesl,
- gesles: gesles,
- gfr: gfr,
- gg: gg,
- ggg: ggg,
- gimel: gimel,
- gjcy: gjcy,
- gl: gl,
- glE: glE,
- gla: gla,
- glj: glj,
- gnE: gnE,
- gnap: gnap,
- gnapprox: gnapprox,
- gne: gne,
- gneq: gneq,
- gneqq: gneqq,
- gnsim: gnsim,
- gopf: gopf,
- grave: grave,
- gscr: gscr,
- gsim: gsim,
- gsime: gsime,
- gsiml: gsiml,
- g: g,
- gt: gt$1,
- gtcc: gtcc,
- gtcir: gtcir,
- gtdot: gtdot,
- gtlPar: gtlPar,
- gtquest: gtquest,
- gtrapprox: gtrapprox,
- gtrarr: gtrarr,
- gtrdot: gtrdot,
- gtreqless: gtreqless,
- gtreqqless: gtreqqless,
- gtrless: gtrless,
- gtrsim: gtrsim,
- gvertneqq: gvertneqq,
- gvnE: gvnE,
- hArr: hArr,
- hairsp: hairsp,
- half: half,
- hamilt: hamilt,
- hardcy: hardcy,
- harr: harr,
- harrcir: harrcir,
- harrw: harrw,
- hbar: hbar,
- hcirc: hcirc,
- hearts: hearts,
- heartsuit: heartsuit,
- hellip: hellip,
- hercon: hercon,
- hfr: hfr,
- hksearow: hksearow,
- hkswarow: hkswarow,
- hoarr: hoarr,
- homtht: homtht,
- hookleftarrow: hookleftarrow,
- hookrightarrow: hookrightarrow,
- hopf: hopf,
- horbar: horbar,
- hscr: hscr,
- hslash: hslash,
- hstrok: hstrok,
- hybull: hybull,
- hyphen: hyphen,
- iacut: iacut,
- iacute: iacute$1,
- ic: ic,
- icir: icir,
- icirc: icirc$1,
- icy: icy,
- iecy: iecy,
- iexc: iexc,
- iexcl: iexcl$1,
- iff: iff,
- ifr: ifr,
- igrav: igrav,
- igrave: igrave$1,
- ii: ii,
- iiiint: iiiint,
- iiint: iiint,
- iinfin: iinfin,
- iiota: iiota,
- ijlig: ijlig,
- imacr: imacr,
- image: image,
- imagline: imagline,
- imagpart: imagpart,
- imath: imath,
- imof: imof,
- imped: imped,
- incare: incare,
- infin: infin,
- infintie: infintie,
- inodot: inodot,
- int: int,
- intcal: intcal,
- integers: integers,
- intercal: intercal,
- intlarhk: intlarhk,
- intprod: intprod,
- iocy: iocy,
- iogon: iogon,
- iopf: iopf,
- iota: iota,
- iprod: iprod,
- iques: iques,
- iquest: iquest$1,
- iscr: iscr,
- isin: isin,
- isinE: isinE,
- isindot: isindot,
- isins: isins,
- isinsv: isinsv,
- isinv: isinv,
- it: it,
- itilde: itilde,
- iukcy: iukcy,
- ium: ium,
- iuml: iuml$1,
- jcirc: jcirc,
- jcy: jcy,
- jfr: jfr,
- jmath: jmath,
- jopf: jopf,
- jscr: jscr,
- jsercy: jsercy,
- jukcy: jukcy,
- kappa: kappa,
- kappav: kappav,
- kcedil: kcedil,
- kcy: kcy,
- kfr: kfr,
- kgreen: kgreen,
- khcy: khcy,
- kjcy: kjcy,
- kopf: kopf,
- kscr: kscr,
- lAarr: lAarr,
- lArr: lArr,
- lAtail: lAtail,
- lBarr: lBarr,
- lE: lE,
- lEg: lEg,
- lHar: lHar,
- lacute: lacute,
- laemptyv: laemptyv,
- lagran: lagran,
- lambda: lambda,
- lang: lang,
- langd: langd,
- langle: langle,
- lap: lap,
- laqu: laqu,
- laquo: laquo$1,
- larr: larr,
- larrb: larrb,
- larrbfs: larrbfs,
- larrfs: larrfs,
- larrhk: larrhk,
- larrlp: larrlp,
- larrpl: larrpl,
- larrsim: larrsim,
- larrtl: larrtl,
- lat: lat,
- latail: latail,
- late: late,
- lates: lates,
- lbarr: lbarr,
- lbbrk: lbbrk,
- lbrace: lbrace,
- lbrack: lbrack,
- lbrke: lbrke,
- lbrksld: lbrksld,
- lbrkslu: lbrkslu,
- lcaron: lcaron,
- lcedil: lcedil,
- lceil: lceil,
- lcub: lcub,
- lcy: lcy,
- ldca: ldca,
- ldquo: ldquo,
- ldquor: ldquor,
- ldrdhar: ldrdhar,
- ldrushar: ldrushar,
- ldsh: ldsh,
- le: le,
- leftarrow: leftarrow,
- leftarrowtail: leftarrowtail,
- leftharpoondown: leftharpoondown,
- leftharpoonup: leftharpoonup,
- leftleftarrows: leftleftarrows,
- leftrightarrow: leftrightarrow,
- leftrightarrows: leftrightarrows,
- leftrightharpoons: leftrightharpoons,
- leftrightsquigarrow: leftrightsquigarrow,
- leftthreetimes: leftthreetimes,
- leg: leg,
- leq: leq,
- leqq: leqq,
- leqslant: leqslant,
- les: les,
- lescc: lescc,
- lesdot: lesdot,
- lesdoto: lesdoto,
- lesdotor: lesdotor,
- lesg: lesg,
- lesges: lesges,
- lessapprox: lessapprox,
- lessdot: lessdot,
- lesseqgtr: lesseqgtr,
- lesseqqgtr: lesseqqgtr,
- lessgtr: lessgtr,
- lesssim: lesssim,
- lfisht: lfisht,
- lfloor: lfloor,
- lfr: lfr,
- lg: lg,
- lgE: lgE,
- lhard: lhard,
- lharu: lharu,
- lharul: lharul,
- lhblk: lhblk,
- ljcy: ljcy,
- ll: ll,
- llarr: llarr,
- llcorner: llcorner,
- llhard: llhard,
- lltri: lltri,
- lmidot: lmidot,
- lmoust: lmoust,
- lmoustache: lmoustache,
- lnE: lnE,
- lnap: lnap,
- lnapprox: lnapprox,
- lne: lne,
- lneq: lneq,
- lneqq: lneqq,
- lnsim: lnsim,
- loang: loang,
- loarr: loarr,
- lobrk: lobrk,
- longleftarrow: longleftarrow,
- longleftrightarrow: longleftrightarrow,
- longmapsto: longmapsto,
- longrightarrow: longrightarrow,
- looparrowleft: looparrowleft,
- looparrowright: looparrowright,
- lopar: lopar,
- lopf: lopf,
- loplus: loplus,
- lotimes: lotimes,
- lowast: lowast,
- lowbar: lowbar,
- loz: loz,
- lozenge: lozenge,
- lozf: lozf,
- lpar: lpar,
- lparlt: lparlt,
- lrarr: lrarr,
- lrcorner: lrcorner,
- lrhar: lrhar,
- lrhard: lrhard,
- lrm: lrm,
- lrtri: lrtri,
- lsaquo: lsaquo,
- lscr: lscr,
- lsh: lsh,
- lsim: lsim,
- lsime: lsime,
- lsimg: lsimg,
- lsqb: lsqb,
- lsquo: lsquo,
- lsquor: lsquor,
- lstrok: lstrok,
- l: l,
- lt: lt$1,
- ltcc: ltcc,
- ltcir: ltcir,
- ltdot: ltdot,
- lthree: lthree,
- ltimes: ltimes,
- ltlarr: ltlarr,
- ltquest: ltquest,
- ltrPar: ltrPar,
- ltri: ltri,
- ltrie: ltrie,
- ltrif: ltrif,
- lurdshar: lurdshar,
- luruhar: luruhar,
- lvertneqq: lvertneqq,
- lvnE: lvnE,
- mDDot: mDDot,
- mac: mac,
- macr: macr$1,
- male: male,
- malt: malt,
- maltese: maltese,
- map: map$3,
- mapsto: mapsto,
- mapstodown: mapstodown,
- mapstoleft: mapstoleft,
- mapstoup: mapstoup,
- marker: marker,
- mcomma: mcomma,
- mcy: mcy,
- mdash: mdash,
- measuredangle: measuredangle,
- mfr: mfr,
- mho: mho,
- micr: micr,
- micro: micro$1,
- mid: mid,
- midast: midast,
- midcir: midcir,
- middo: middo,
- middot: middot$1,
- minus: minus,
- minusb: minusb,
- minusd: minusd,
- minusdu: minusdu,
- mlcp: mlcp,
- mldr: mldr,
- mnplus: mnplus,
- models: models,
- mopf: mopf,
- mp: mp,
- mscr: mscr,
- mstpos: mstpos,
- mu: mu,
- multimap: multimap,
- mumap: mumap,
- nGg: nGg,
- nGt: nGt,
- nGtv: nGtv,
- nLeftarrow: nLeftarrow,
- nLeftrightarrow: nLeftrightarrow,
- nLl: nLl,
- nLt: nLt,
- nLtv: nLtv,
- nRightarrow: nRightarrow,
- nVDash: nVDash,
- nVdash: nVdash,
- nabla: nabla,
- nacute: nacute,
- nang: nang,
- nap: nap,
- napE: napE,
- napid: napid,
- napos: napos,
- napprox: napprox,
- natur: natur,
- natural: natural,
- naturals: naturals,
- nbs: nbs,
- nbsp: nbsp$1,
- nbump: nbump,
- nbumpe: nbumpe,
- ncap: ncap,
- ncaron: ncaron,
- ncedil: ncedil,
- ncong: ncong,
- ncongdot: ncongdot,
- ncup: ncup,
- ncy: ncy,
- ndash: ndash,
- ne: ne,
- neArr: neArr,
- nearhk: nearhk,
- nearr: nearr,
- nearrow: nearrow,
- nedot: nedot,
- nequiv: nequiv,
- nesear: nesear,
- nesim: nesim,
- nexist: nexist,
- nexists: nexists,
- nfr: nfr,
- ngE: ngE,
- nge: nge,
- ngeq: ngeq,
- ngeqq: ngeqq,
- ngeqslant: ngeqslant,
- nges: nges,
- ngsim: ngsim,
- ngt: ngt,
- ngtr: ngtr,
- nhArr: nhArr,
- nharr: nharr,
- nhpar: nhpar,
- ni: ni,
- nis: nis,
- nisd: nisd,
- niv: niv,
- njcy: njcy,
- nlArr: nlArr,
- nlE: nlE,
- nlarr: nlarr,
- nldr: nldr,
- nle: nle,
- nleftarrow: nleftarrow,
- nleftrightarrow: nleftrightarrow,
- nleq: nleq,
- nleqq: nleqq,
- nleqslant: nleqslant,
- nles: nles,
- nless: nless,
- nlsim: nlsim,
- nlt: nlt,
- nltri: nltri,
- nltrie: nltrie,
- nmid: nmid,
- nopf: nopf,
- no: no,
- not: not$1,
- notin: notin,
- notinE: notinE,
- notindot: notindot,
- notinva: notinva,
- notinvb: notinvb,
- notinvc: notinvc,
- notni: notni,
- notniva: notniva,
- notnivb: notnivb,
- notnivc: notnivc,
- npar: npar,
- nparallel: nparallel,
- nparsl: nparsl,
- npart: npart,
- npolint: npolint,
- npr: npr,
- nprcue: nprcue,
- npre: npre,
- nprec: nprec,
- npreceq: npreceq,
- nrArr: nrArr,
- nrarr: nrarr,
- nrarrc: nrarrc,
- nrarrw: nrarrw,
- nrightarrow: nrightarrow,
- nrtri: nrtri,
- nrtrie: nrtrie,
- nsc: nsc,
- nsccue: nsccue,
- nsce: nsce,
- nscr: nscr,
- nshortmid: nshortmid,
- nshortparallel: nshortparallel,
- nsim: nsim,
- nsime: nsime,
- nsimeq: nsimeq,
- nsmid: nsmid,
- nspar: nspar,
- nsqsube: nsqsube,
- nsqsupe: nsqsupe,
- nsub: nsub,
- nsubE: nsubE,
- nsube: nsube,
- nsubset: nsubset,
- nsubseteq: nsubseteq,
- nsubseteqq: nsubseteqq,
- nsucc: nsucc,
- nsucceq: nsucceq,
- nsup: nsup,
- nsupE: nsupE,
- nsupe: nsupe,
- nsupset: nsupset,
- nsupseteq: nsupseteq,
- nsupseteqq: nsupseteqq,
- ntgl: ntgl,
- ntild: ntild,
- ntilde: ntilde$1,
- ntlg: ntlg,
- ntriangleleft: ntriangleleft,
- ntrianglelefteq: ntrianglelefteq,
- ntriangleright: ntriangleright,
- ntrianglerighteq: ntrianglerighteq,
- nu: nu,
- num: num,
- numero: numero,
- numsp: numsp,
- nvDash: nvDash,
- nvHarr: nvHarr,
- nvap: nvap,
- nvdash: nvdash,
- nvge: nvge,
- nvgt: nvgt,
- nvinfin: nvinfin,
- nvlArr: nvlArr,
- nvle: nvle,
- nvlt: nvlt,
- nvltrie: nvltrie,
- nvrArr: nvrArr,
- nvrtrie: nvrtrie,
- nvsim: nvsim,
- nwArr: nwArr,
- nwarhk: nwarhk,
- nwarr: nwarr,
- nwarrow: nwarrow,
- nwnear: nwnear,
- oS: oS,
- oacut: oacut,
- oacute: oacute$1,
- oast: oast,
- ocir: ocir,
- ocirc: ocirc$1,
- ocy: ocy,
- odash: odash,
- odblac: odblac,
- odiv: odiv,
- odot: odot,
- odsold: odsold,
- oelig: oelig,
- ofcir: ofcir,
- ofr: ofr,
- ogon: ogon,
- ograv: ograv,
- ograve: ograve$1,
- ogt: ogt,
- ohbar: ohbar,
- ohm: ohm,
- oint: oint,
- olarr: olarr,
- olcir: olcir,
- olcross: olcross,
- oline: oline,
- olt: olt,
- omacr: omacr,
- omega: omega,
- omicron: omicron,
- omid: omid,
- ominus: ominus,
- oopf: oopf,
- opar: opar,
- operp: operp,
- oplus: oplus,
- or: or,
- orarr: orarr,
- ord: ord,
- order: order$2,
- orderof: orderof,
- ordf: ordf$1,
- ordm: ordm$1,
- origof: origof,
- oror: oror,
- orslope: orslope,
- orv: orv,
- oscr: oscr,
- oslas: oslas,
- oslash: oslash$1,
- osol: osol,
- otild: otild,
- otilde: otilde$1,
- otimes: otimes,
- otimesas: otimesas,
- oum: oum,
- ouml: ouml$1,
- ovbar: ovbar,
- par: par,
- para: para$1,
- parallel: parallel,
- parsim: parsim,
- parsl: parsl,
- part: part,
- pcy: pcy,
- percnt: percnt,
- period: period,
- permil: permil,
- perp: perp,
- pertenk: pertenk,
- pfr: pfr,
- phi: phi,
- phiv: phiv,
- phmmat: phmmat,
- phone: phone,
- pi: pi,
- pitchfork: pitchfork,
- piv: piv,
- planck: planck,
- planckh: planckh,
- plankv: plankv,
- plus: plus,
- plusacir: plusacir,
- plusb: plusb,
- pluscir: pluscir,
- plusdo: plusdo,
- plusdu: plusdu,
- pluse: pluse,
- plusm: plusm,
- plusmn: plusmn$1,
- plussim: plussim,
- plustwo: plustwo,
- pm: pm,
- pointint: pointint,
- popf: popf,
- poun: poun,
- pound: pound$1,
- pr: pr,
- prE: prE,
- prap: prap,
- prcue: prcue,
- pre: pre,
- prec: prec,
- precapprox: precapprox,
- preccurlyeq: preccurlyeq,
- preceq: preceq,
- precnapprox: precnapprox,
- precneqq: precneqq,
- precnsim: precnsim,
- precsim: precsim,
- prime: prime,
- primes: primes,
- prnE: prnE,
- prnap: prnap,
- prnsim: prnsim,
- prod: prod,
- profalar: profalar,
- profline: profline,
- profsurf: profsurf,
- prop: prop,
- propto: propto,
- prsim: prsim,
- prurel: prurel,
- pscr: pscr,
- psi: psi,
- puncsp: puncsp,
- qfr: qfr,
- qint: qint,
- qopf: qopf,
- qprime: qprime,
- qscr: qscr,
- quaternions: quaternions,
- quatint: quatint,
- quest: quest,
- questeq: questeq,
- quo: quo,
- quot: quot$1,
- rAarr: rAarr,
- rArr: rArr,
- rAtail: rAtail,
- rBarr: rBarr,
- rHar: rHar,
- race: race,
- racute: racute,
- radic: radic,
- raemptyv: raemptyv,
- rang: rang,
- rangd: rangd,
- range: range$1,
- rangle: rangle,
- raqu: raqu,
- raquo: raquo$1,
- rarr: rarr,
- rarrap: rarrap,
- rarrb: rarrb,
- rarrbfs: rarrbfs,
- rarrc: rarrc,
- rarrfs: rarrfs,
- rarrhk: rarrhk,
- rarrlp: rarrlp,
- rarrpl: rarrpl,
- rarrsim: rarrsim,
- rarrtl: rarrtl,
- rarrw: rarrw,
- ratail: ratail,
- ratio: ratio,
- rationals: rationals,
- rbarr: rbarr,
- rbbrk: rbbrk,
- rbrace: rbrace,
- rbrack: rbrack,
- rbrke: rbrke,
- rbrksld: rbrksld,
- rbrkslu: rbrkslu,
- rcaron: rcaron,
- rcedil: rcedil,
- rceil: rceil,
- rcub: rcub,
- rcy: rcy,
- rdca: rdca,
- rdldhar: rdldhar,
- rdquo: rdquo,
- rdquor: rdquor,
- rdsh: rdsh,
- real: real,
- realine: realine,
- realpart: realpart,
- reals: reals,
- rect: rect,
- re: re,
- reg: reg$1,
- rfisht: rfisht,
- rfloor: rfloor,
- rfr: rfr,
- rhard: rhard,
- rharu: rharu,
- rharul: rharul,
- rho: rho,
- rhov: rhov,
- rightarrow: rightarrow,
- rightarrowtail: rightarrowtail,
- rightharpoondown: rightharpoondown,
- rightharpoonup: rightharpoonup,
- rightleftarrows: rightleftarrows,
- rightleftharpoons: rightleftharpoons,
- rightrightarrows: rightrightarrows,
- rightsquigarrow: rightsquigarrow,
- rightthreetimes: rightthreetimes,
- ring: ring,
- risingdotseq: risingdotseq,
- rlarr: rlarr,
- rlhar: rlhar,
- rlm: rlm,
- rmoust: rmoust,
- rmoustache: rmoustache,
- rnmid: rnmid,
- roang: roang,
- roarr: roarr,
- robrk: robrk,
- ropar: ropar,
- ropf: ropf,
- roplus: roplus,
- rotimes: rotimes,
- rpar: rpar,
- rpargt: rpargt,
- rppolint: rppolint,
- rrarr: rrarr,
- rsaquo: rsaquo,
- rscr: rscr,
- rsh: rsh,
- rsqb: rsqb,
- rsquo: rsquo,
- rsquor: rsquor,
- rthree: rthree,
- rtimes: rtimes,
- rtri: rtri,
- rtrie: rtrie,
- rtrif: rtrif,
- rtriltri: rtriltri,
- ruluhar: ruluhar,
- rx: rx,
- sacute: sacute,
- sbquo: sbquo,
- sc: sc,
- scE: scE,
- scap: scap,
- scaron: scaron,
- sccue: sccue,
- sce: sce,
- scedil: scedil,
- scirc: scirc,
- scnE: scnE,
- scnap: scnap,
- scnsim: scnsim,
- scpolint: scpolint,
- scsim: scsim,
- scy: scy,
- sdot: sdot,
- sdotb: sdotb,
- sdote: sdote,
- seArr: seArr,
- searhk: searhk,
- searr: searr,
- searrow: searrow,
- sec: sec,
- sect: sect$1,
- semi: semi,
- seswar: seswar,
- setminus: setminus,
- setmn: setmn,
- sext: sext,
- sfr: sfr,
- sfrown: sfrown,
- sharp: sharp,
- shchcy: shchcy,
- shcy: shcy,
- shortmid: shortmid,
- shortparallel: shortparallel,
- sh: sh,
- shy: shy$1,
- sigma: sigma,
- sigmaf: sigmaf,
- sigmav: sigmav,
- sim: sim,
- simdot: simdot,
- sime: sime,
- simeq: simeq,
- simg: simg,
- simgE: simgE,
- siml: siml,
- simlE: simlE,
- simne: simne,
- simplus: simplus,
- simrarr: simrarr,
- slarr: slarr,
- smallsetminus: smallsetminus,
- smashp: smashp,
- smeparsl: smeparsl,
- smid: smid,
- smile: smile,
- smt: smt,
- smte: smte,
- smtes: smtes,
- softcy: softcy,
- sol: sol,
- solb: solb,
- solbar: solbar,
- sopf: sopf,
- spades: spades,
- spadesuit: spadesuit,
- spar: spar,
- sqcap: sqcap,
- sqcaps: sqcaps,
- sqcup: sqcup,
- sqcups: sqcups,
- sqsub: sqsub,
- sqsube: sqsube,
- sqsubset: sqsubset,
- sqsubseteq: sqsubseteq,
- sqsup: sqsup,
- sqsupe: sqsupe,
- sqsupset: sqsupset,
- sqsupseteq: sqsupseteq,
- squ: squ,
- square: square,
- squarf: squarf,
- squf: squf,
- srarr: srarr,
- sscr: sscr,
- ssetmn: ssetmn,
- ssmile: ssmile,
- sstarf: sstarf,
- star: star$1,
- starf: starf,
- straightepsilon: straightepsilon,
- straightphi: straightphi,
- strns: strns,
- sub: sub,
- subE: subE,
- subdot: subdot,
- sube: sube,
- subedot: subedot,
- submult: submult,
- subnE: subnE,
- subne: subne,
- subplus: subplus,
- subrarr: subrarr,
- subset: subset,
- subseteq: subseteq,
- subseteqq: subseteqq,
- subsetneq: subsetneq,
- subsetneqq: subsetneqq,
- subsim: subsim,
- subsub: subsub,
- subsup: subsup,
- succ: succ,
- succapprox: succapprox,
- succcurlyeq: succcurlyeq,
- succeq: succeq,
- succnapprox: succnapprox,
- succneqq: succneqq,
- succnsim: succnsim,
- succsim: succsim,
- sum: sum,
- sung: sung,
- sup: sup,
- sup1: sup1$1,
- sup2: sup2$1,
- sup3: sup3$1,
- supE: supE,
- supdot: supdot,
- supdsub: supdsub,
- supe: supe,
- supedot: supedot,
- suphsol: suphsol,
- suphsub: suphsub,
- suplarr: suplarr,
- supmult: supmult,
- supnE: supnE,
- supne: supne,
- supplus: supplus,
- supset: supset,
- supseteq: supseteq,
- supseteqq: supseteqq,
- supsetneq: supsetneq,
- supsetneqq: supsetneqq,
- supsim: supsim,
- supsub: supsub,
- supsup: supsup,
- swArr: swArr,
- swarhk: swarhk,
- swarr: swarr,
- swarrow: swarrow,
- swnwar: swnwar,
- szli: szli,
- szlig: szlig$1,
- target: target,
- tau: tau,
- tbrk: tbrk,
- tcaron: tcaron,
- tcedil: tcedil,
- tcy: tcy,
- tdot: tdot,
- telrec: telrec,
- tfr: tfr,
- there4: there4,
- therefore: therefore,
- theta: theta,
- thetasym: thetasym,
- thetav: thetav,
- thickapprox: thickapprox,
- thicksim: thicksim,
- thinsp: thinsp,
- thkap: thkap,
- thksim: thksim,
- thor: thor,
- thorn: thorn$1,
- tilde: tilde,
- time: time,
- times: times$1,
- timesb: timesb,
- timesbar: timesbar,
- timesd: timesd,
- tint: tint,
- toea: toea,
- top: top,
- topbot: topbot,
- topcir: topcir,
- topf: topf,
- topfork: topfork,
- tosa: tosa,
- tprime: tprime,
- trade: trade,
- triangle: triangle,
- triangledown: triangledown,
- triangleleft: triangleleft,
- trianglelefteq: trianglelefteq,
- triangleq: triangleq,
- triangleright: triangleright,
- trianglerighteq: trianglerighteq,
- tridot: tridot,
- trie: trie,
- triminus: triminus,
- triplus: triplus,
- trisb: trisb,
- tritime: tritime,
- trpezium: trpezium,
- tscr: tscr,
- tscy: tscy,
- tshcy: tshcy,
- tstrok: tstrok,
- twixt: twixt,
- twoheadleftarrow: twoheadleftarrow,
- twoheadrightarrow: twoheadrightarrow,
- uArr: uArr,
- uHar: uHar,
- uacut: uacut,
- uacute: uacute$1,
- uarr: uarr,
- ubrcy: ubrcy,
- ubreve: ubreve,
- ucir: ucir,
- ucirc: ucirc$1,
- ucy: ucy,
- udarr: udarr,
- udblac: udblac,
- udhar: udhar,
- ufisht: ufisht,
- ufr: ufr,
- ugrav: ugrav,
- ugrave: ugrave$1,
- uharl: uharl,
- uharr: uharr,
- uhblk: uhblk,
- ulcorn: ulcorn,
- ulcorner: ulcorner,
- ulcrop: ulcrop,
- ultri: ultri,
- umacr: umacr,
- um: um,
- uml: uml$1,
- uogon: uogon,
- uopf: uopf,
- uparrow: uparrow,
- updownarrow: updownarrow,
- upharpoonleft: upharpoonleft,
- upharpoonright: upharpoonright,
- uplus: uplus,
- upsi: upsi,
- upsih: upsih,
- upsilon: upsilon,
- upuparrows: upuparrows,
- urcorn: urcorn,
- urcorner: urcorner,
- urcrop: urcrop,
- uring: uring,
- urtri: urtri,
- uscr: uscr,
- utdot: utdot,
- utilde: utilde,
- utri: utri,
- utrif: utrif,
- uuarr: uuarr,
- uum: uum,
- uuml: uuml$1,
- uwangle: uwangle,
- vArr: vArr,
- vBar: vBar,
- vBarv: vBarv,
- vDash: vDash,
- vangrt: vangrt,
- varepsilon: varepsilon,
- varkappa: varkappa,
- varnothing: varnothing,
- varphi: varphi,
- varpi: varpi,
- varpropto: varpropto,
- varr: varr,
- varrho: varrho,
- varsigma: varsigma,
- varsubsetneq: varsubsetneq,
- varsubsetneqq: varsubsetneqq,
- varsupsetneq: varsupsetneq,
- varsupsetneqq: varsupsetneqq,
- vartheta: vartheta,
- vartriangleleft: vartriangleleft,
- vartriangleright: vartriangleright,
- vcy: vcy,
- vdash: vdash,
- vee: vee,
- veebar: veebar,
- veeeq: veeeq,
- vellip: vellip,
- verbar: verbar,
- vert: vert,
- vfr: vfr,
- vltri: vltri,
- vnsub: vnsub,
- vnsup: vnsup,
- vopf: vopf,
- vprop: vprop,
- vrtri: vrtri,
- vscr: vscr,
- vsubnE: vsubnE,
- vsubne: vsubne,
- vsupnE: vsupnE,
- vsupne: vsupne,
- vzigzag: vzigzag,
- wcirc: wcirc,
- wedbar: wedbar,
- wedge: wedge,
- wedgeq: wedgeq,
- weierp: weierp,
- wfr: wfr,
- wopf: wopf,
- wp: wp,
- wr: wr,
- wreath: wreath,
- wscr: wscr,
- xcap: xcap,
- xcirc: xcirc,
- xcup: xcup,
- xdtri: xdtri,
- xfr: xfr,
- xhArr: xhArr,
- xharr: xharr,
- xi: xi,
- xlArr: xlArr,
- xlarr: xlarr,
- xmap: xmap,
- xnis: xnis,
- xodot: xodot,
- xopf: xopf,
- xoplus: xoplus,
- xotime: xotime,
- xrArr: xrArr,
- xrarr: xrarr,
- xscr: xscr,
- xsqcup: xsqcup,
- xuplus: xuplus,
- xutri: xutri,
- xvee: xvee,
- xwedge: xwedge,
- yacut: yacut,
- yacute: yacute$1,
- yacy: yacy,
- ycirc: ycirc,
- ycy: ycy,
- ye: ye,
- yen: yen$1,
- yfr: yfr,
- yicy: yicy,
- yopf: yopf,
- yscr: yscr,
- yucy: yucy,
- yum: yum,
- yuml: yuml$1,
- zacute: zacute,
- zcaron: zcaron,
- zcy: zcy,
- zdot: zdot,
- zeetrf: zeetrf,
- zeta: zeta,
- zfr: zfr,
- zhcy: zhcy,
- zigrarr: zigrarr,
- zopf: zopf,
- zscr: zscr,
- zwj: zwj,
- zwnj: zwnj,
- default: index$4
-});
+module.exports = VFile
-var characterEntities$1 = ( characterEntities && index$4 ) || characterEntities;
+var own = {}.hasOwnProperty
+var proto = VFile.prototype
-var decodeEntity_1 = decodeEntity;
+proto.toString = toString
-var own$4 = {}.hasOwnProperty;
+// 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']
-function decodeEntity(characters) {
- return own$4.call(characterEntities$1, characters)
- ? characterEntities$1[characters]
- : false
-}
+// Construct a new file.
+function VFile(options) {
+ var prop
+ var index
+ var length
-var legacy = ( characterEntitiesLegacy && index$2 ) || characterEntitiesLegacy;
+ if (!options) {
+ options = {}
+ } else if (typeof options === 'string' || buffer(options)) {
+ options = {contents: options}
+ } else if ('message' in options && 'messages' in options) {
+ return options
+ }
-var invalid = ( characterReferenceInvalid && index$3 ) || characterReferenceInvalid;
+ if (!(this instanceof VFile)) {
+ return new VFile(options)
+ }
-var parseEntities_1 = parseEntities;
+ this.data = {}
+ this.messages = []
+ this.history = []
+ this.cwd = process.cwd()
-var own$5 = {}.hasOwnProperty;
-var fromCharCode = String.fromCharCode;
-var noop$1 = Function.prototype;
+ // Set path related properties in the correct order.
+ index = -1
+ length = order.length
-/* Default settings. */
-var defaults = {
- warning: null,
- reference: null,
- text: null,
- warningContext: null,
- referenceContext: null,
- textContext: null,
- position: {},
- additional: null,
- attribute: false,
- nonTerminated: true
-};
+ while (++index < length) {
+ prop = order[index]
-/* Reference types. */
-var NAMED = 'named';
-var HEXADECIMAL = 'hexadecimal';
-var DECIMAL = 'decimal';
+ if (own.call(options, prop)) {
+ this[prop] = options[prop]
+ }
+ }
-/* Map of bases. */
-var BASE = {};
+ // Set non-path related properties.
+ for (prop in options) {
+ if (order.indexOf(prop) === -1) {
+ this[prop] = options[prop]
+ }
+ }
+}
-BASE[HEXADECIMAL] = 16;
-BASE[DECIMAL] = 10;
+// 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')
-/* 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 = {};
+ if (path !== this.path) {
+ this.history.push(path)
+ }
+ }
+})
-TESTS[NAMED] = isAlphanumerical;
-TESTS[DECIMAL] = isDecimal;
-TESTS[HEXADECIMAL] = isHexadecimal;
+// 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)
+ }
+})
-/* 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;
+// 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)
+ }
+})
-var MESSAGES = {};
+// 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 || ''
-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';
+ assertPart(ext, 'extname')
+ assertPath(this.path, 'extname')
-/* Wrap to ensure clean parameters are given to `parse`. */
-function parseEntities(value, options) {
- var settings = {};
- var option;
- var key;
+ if (ext) {
+ if (ext.charAt(0) !== '.') {
+ throw new Error('`extname` must start with `.`')
+ }
- if (!options) {
- options = {};
+ if (ext.indexOf('.', 1) !== -1) {
+ throw new Error('`extname` cannot contain multiple dots')
+ }
+ }
+
+ this.path = replace(this.path, ext)
}
+})
- for (key in defaults) {
- option = options[key];
- settings[key] =
- option === null || option === undefined ? defaults[key] : option;
+// 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 || ''))
}
+})
- if (settings.position.indent || settings.position.start) {
- settings.indent = settings.position.indent || [];
- settings.position = settings.position.start;
+// 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 + '`'
+ )
}
+}
- return parse$7(value, settings)
+// Assert that `part` is not empty.
+function assertNonEmpty(part, name) {
+ if (!part) {
+ throw new Error('`' + name + '` cannot be empty')
+ }
}
-/* Parse entities. */
-function parse$7(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;
+// Assert `path` exists.
+function assertPath(path, name) {
+ if (!path) {
+ throw new Error('Setting `' + name + '` requires `path` to be set too')
+ }
+}
- /* Cache the current point. */
- prev = now();
- /* Wrap `handleWarning`. */
- warning = handleWarning ? parseError : noop$1;
+/***/ }),
+/* 207 */
+/***/ (function(module, exports) {
- /* Ensure the algorithm walks over the first character
- * and the end (inclusive). */
- index--;
- length++;
+/*!
+ * Determine if an object is a Buffer
+ *
+ * @author Feross Aboukhadijeh <https://feross.org>
+ * @license MIT
+ */
- while (++index < length) {
- /* If the previous character was a newline. */
- if (character === '\n') {
- column = indent[lines] || 1;
- }
+module.exports = function isBuffer (obj) {
+ return obj != null && obj.constructor != null &&
+ typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)
+}
- character = at(index);
- /* Handle anything other than an ampersand,
- * including newlines and EOF. */
- if (character !== '&') {
- if (character === '\n') {
- line++;
- lines++;
- column = 0;
- }
+/***/ }),
+/* 208 */
+/***/ (function(module, exports, __webpack_require__) {
- if (character) {
- queue += character;
- column++;
- } else {
- flush();
- }
- } else {
- following = at(index + 1);
+"use strict";
- /* 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++;
+var toString = Object.prototype.toString;
- continue
- }
+module.exports = function (x) {
+ var prototype;
+ return toString.call(x) === '[object Object]' && (prototype = Object.getPrototypeOf(x), prototype === null || prototype === Object.getPrototypeOf({}));
+};
- start = index + 1;
- begin = start;
- end = start;
- /* Numerical entity. */
- if (following !== '#') {
- type = NAMED;
- } else {
- end = ++begin;
+/***/ }),
+/* 209 */
+/***/ (function(module, exports, __webpack_require__) {
- /* The behaviour further depends on the
- * character after the U+0023 NUMBER SIGN. */
- following = at(end);
+"use strict";
- if (following === 'x' || following === 'X') {
- /* ASCII hex digits. */
- type = HEXADECIMAL;
- end = ++begin;
- } else {
- /* ASCII digits. */
- type = DECIMAL;
- }
- }
- entityCharacters = '';
- entity = '';
- characters = '';
- test = TESTS[type];
- end--;
+var unherit = __webpack_require__(75)
+var xtend = __webpack_require__(7)
+var Parser = __webpack_require__(210)
- while (++end < length) {
- following = at(end);
+module.exports = parse
+parse.Parser = Parser
- if (!test(following)) {
- break
- }
+function parse(options) {
+ var settings = this.data('settings')
+ var Local = unherit(Parser)
- characters += following;
+ Local.prototype.options = xtend(Local.prototype.options, settings, options)
- /* 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$5.call(legacy, characters)) {
- entityCharacters = characters;
- entity = legacy[characters];
- }
- }
+ this.Parser = Local
+}
- terminated = at(end) === ';';
- if (terminated) {
- end++;
+/***/ }),
+/* 210 */
+/***/ (function(module, exports, __webpack_require__) {
- namedEntity = type === NAMED ? decodeEntity_1(characters) : false;
+"use strict";
- if (namedEntity) {
- entityCharacters = characters;
- entity = namedEntity;
- }
- }
- diff = 1 + end - start;
+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)
- 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;
- }
+module.exports = Parser
- /* If the reference is not terminated,
- * warn. */
- if (!terminated) {
- reason = entityCharacters ? NAMED_NOT_TERMINATED : NAMED_EMPTY;
+function Parser(doc, file) {
+ this.file = file
+ this.offset = {}
+ this.options = xtend(this.options)
+ this.setOptions({})
- if (!settings.attribute) {
- warning(reason, diff);
- } else {
- following = at(end);
+ this.inList = false
+ this.inBlock = false
+ this.inLink = false
+ this.atStart = true
- if (following === '=') {
- warning(reason, diff);
- entity = null;
- } else if (isAlphanumerical(following)) {
- entity = null;
- } else {
- warning(reason, diff);
- }
- }
- }
- }
+ this.toOffset = vfileLocation(file).toOffset
+ this.unescape = unescape(this, 'escape')
+ this.decode = decode(this)
+}
- reference = entity;
- } else {
- if (!terminated) {
- /* All non-terminated numeric entities are
- * not rendered, and trigger a warning. */
- warning(NUMERIC_NOT_TERMINATED, diff);
- }
+var proto = Parser.prototype
- /* When terminated and number, parse as
- * either hexadecimal or decimal. */
- reference = parseInt(characters, BASE[type]);
+// Expose core.
+proto.setOptions = __webpack_require__(217)
+proto.parse = __webpack_require__(219)
- /* 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 = '';
+// Expose `defaults`.
+proto.options = __webpack_require__(82)
- /* Trigger a warning when the parsed
- * number should not be used. */
- if (disallowed(reference)) {
- warning(NUMERIC_DISALLOWED, diff);
- }
+// Enter and exit helpers.
+proto.exitStart = toggle('atStart', true)
+proto.enterList = toggle('inList', false)
+proto.enterLink = toggle('inLink', false)
+proto.enterBlock = toggle('inBlock', false)
- /* Stringify the number. */
- if (reference > 0xffff) {
- reference -= 0x10000;
- output += fromCharCode((reference >>> (10 & 0x3ff)) | 0xd800);
- reference = 0xdc00 | (reference & 0x3ff);
- }
+// 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}]
+]
- reference = output + fromCharCode(reference);
- }
- }
+// 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}]
+]
- /* 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();
+// 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}]
+]
- prev = now();
- index = end - 1;
- column += end - start + 1;
- result.push(reference);
- next = now();
- next.offset++;
+// 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)
+}
- if (handleReference) {
- handleReference.call(
- referenceContext,
- reference,
- {start: prev, end: next},
- value.slice(start - 1, end)
- );
- }
+// Expose precedence.
+proto.blockMethods = keys(proto.blockTokenizers)
+proto.inlineMethods = keys(proto.inlineTokenizers)
- prev = next;
- }
- }
- }
+// Tokenizers.
+proto.tokenizeBlock = tokenizer('block')
+proto.tokenizeInline = tokenizer('inline')
+proto.tokenizeFactory = tokenizer
- /* Return the reduced nodes, and any possible warnings. */
- return result.join('')
+// Get all keys in `value`.
+function keys(value) {
+ var result = []
+ var key
- /* Get current position. */
- function now() {
- return {
- line: line,
- column: column,
- offset: index + (pos.offset || 0)
- }
+ for (key in value) {
+ result.push(key)
}
- /* “Throw” a parse-error: a warning. */
- function parseError(code, offset) {
- var position = now();
+ return result
+}
- position.column += offset;
- position.offset += offset;
- handleWarning.call(warningContext, MESSAGES[code], position, code);
- }
+/***/ }),
+/* 211 */
+/***/ (function(module, exports, __webpack_require__) {
- /* Get character at position. */
- function at(position) {
- return value.charAt(position)
- }
+"use strict";
- /* 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()});
+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)
}
- queue = '';
+ index = value.indexOf(backslash, prev + 1)
}
+
+ queue.push(value.slice(prev))
+
+ return queue.join('')
}
}
-/* 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
- )
-}
+/***/ }),
+/* 212 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var xtend = __webpack_require__(7)
+var entities = __webpack_require__(30)
-var decode$1 = factory$3;
+module.exports = factory
// Factory to create an entity decoder.
-function factory$3(ctx) {
- decoder.raw = decodeRaw;
+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 = [];
+ var offsets = ctx.offset
+ var line = position.line
+ var result = []
while (++line) {
if (!(line in offsets)) {
break
}
- result.push((offsets[line] || 0) + 1);
+ result.push((offsets[line] || 0) + 1)
}
return {start: position, indent: result}
@@ -22941,21 +27958,21 @@ function factory$3(ctx) {
// Decode `value` (at `position`) into text-nodes.
function decoder(value, position, handler) {
- parseEntities_1(value, {
+ 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 parseEntities_1(
+ return entities(
value,
- immutable(options, {position: normalize(position), warning: handleWarning})
+ xtend(options, {position: normalize(position), warning: handleWarning})
)
}
@@ -22963,32 +27980,72 @@ function factory$3(ctx) {
// See <https://github.com/wooorm/parse-entities> for the warnings.
function handleWarning(reason, position, code) {
if (code !== 3) {
- ctx.file.message(reason, position);
+ ctx.file.message(reason, position)
}
}
}
-var tokenizer = factory$4;
+
+/***/ }),
+/* 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$4(type) {
+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;
+ 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) {
@@ -22996,23 +28053,23 @@ function factory$4(type) {
}
// Expose on `eat`.
- eat.now = now;
- eat.file = self.file;
+ eat.now = now
+ eat.file = self.file
// Sync initial offset.
- updatePosition('');
+ 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;
+ index = -1
+ length = methods.length
+ matched = false
while (++index < length) {
- name = methods[index];
- method = tokenizers[name];
+ name = methods[index]
+ method = tokenizers[name]
if (
method &&
@@ -23021,11 +28078,11 @@ function factory$4(type) {
(!method.notInBlock || !self.inBlock) &&
(!method.notInLink || !self.inLink)
) {
- valueLength = value.length;
+ valueLength = value.length
- method.apply(self, [eat, value]);
+ method.apply(self, [eat, value])
- matched = valueLength !== value.length;
+ matched = valueLength !== value.length
if (matched) {
break
@@ -23035,36 +28092,36 @@ function factory$4(type) {
/* istanbul ignore if */
if (!matched) {
- self.file.fail(new Error('Infinite loop'), eat.now());
+ self.file.fail(new Error('Infinite loop'), eat.now())
}
}
- self.eof = 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');
+ var lastIndex = -1
+ var index = subvalue.indexOf('\n')
while (index !== -1) {
- line++;
- lastIndex = index;
- index = subvalue.indexOf('\n', index + 1);
+ line++
+ lastIndex = index
+ index = subvalue.indexOf('\n', index + 1)
}
if (lastIndex === -1) {
- column += subvalue.length;
+ column += subvalue.length
} else {
- column = subvalue.length - lastIndex;
+ column = subvalue.length - lastIndex
}
if (line in offset) {
if (lastIndex !== -1) {
- column += offset[line];
+ column += offset[line]
} else if (column <= offset[line]) {
- column = offset[line] + 1;
+ column = offset[line] + 1
}
}
}
@@ -23072,18 +28129,18 @@ function factory$4(type) {
// Get offset. Called before the first character is eaten to retrieve the
// range’s offsets.
function getOffset() {
- var indentation = [];
- var pos = line + 1;
+ 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;
+ var last = line + 1
while (pos < last) {
- indentation.push((offset[pos] || 0) + 1);
+ indentation.push((offset[pos] || 0) + 1)
- pos++;
+ pos++
}
return indentation
@@ -23092,17 +28149,17 @@ function factory$4(type) {
// Get the current position.
function now() {
- var pos = {line: line, column: column};
+ var pos = {line: line, column: column}
- pos.offset = self.toOffset(pos);
+ pos.offset = self.toOffset(pos)
return pos
}
// Store position information for a node.
function Position(start) {
- this.start = start;
- this.end = now();
+ this.start = start
+ this.end = now()
}
// Throw when a value is incorrectly eaten. This shouldn’t happen but will
@@ -23116,25 +28173,25 @@ function factory$4(type) {
'Incorrectly eaten value: please report this warning on https://git.io/vg5Ft'
),
now()
- );
+ )
}
}
// Mark position and patch `node.position`.
function position() {
- var before = now();
+ 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;
+ 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);
+ 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
@@ -23142,20 +28199,20 @@ function factory$4(type) {
// tracked. Luckily, that space is (should be?) empty, so we can
// safely check for it now.
if (prev && indent && prev.indent) {
- combined = prev.indent;
+ combined = prev.indent
if (n < l) {
while (++n < l) {
- combined.push((offset[n] || 0) + 1);
+ combined.push((offset[n] || 0) + 1)
}
- combined.push(before.column);
+ combined.push(before.column)
}
- indent = combined.concat(indent);
+ indent = combined.concat(indent)
}
- node.position.indent = indent || [];
+ node.position.indent = indent || []
return node
}
@@ -23164,9 +28221,9 @@ function factory$4(type) {
// 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;
+ var children = parent ? parent.children : tokens
+ var prev = children[children.length - 1]
+ var fn
if (
prev &&
@@ -23175,16 +28232,16 @@ function factory$4(type) {
mergeable(prev) &&
mergeable(node)
) {
- fn = node.type === 'text' ? mergeText : mergeBlockquote;
- node = fn.call(self, prev, node);
+ fn = node.type === 'text' ? mergeText : mergeBlockquote
+ node = fn.call(self, prev, node)
}
if (node !== prev) {
- children.push(node);
+ children.push(node)
}
if (self.atStart && tokens.length !== 0) {
- self.exitStart();
+ self.exitStart()
}
return node
@@ -23193,21 +28250,21 @@ function factory$4(type) {
// Remove `subvalue` from `value`. `subvalue` must be at the start of
// `value`.
function eat(subvalue) {
- var indent = getOffset();
- var pos = position();
- var current = now();
+ var indent = getOffset()
+ var pos = position()
+ var current = now()
- validateEat(subvalue);
+ validateEat(subvalue)
- apply.reset = reset;
- reset.test = test;
- apply.test = test;
+ apply.reset = reset
+ reset.test = test
+ apply.test = test
- value = value.substring(subvalue.length);
+ value = value.substring(subvalue.length)
- updatePosition(subvalue);
+ updatePosition(subvalue)
- indent = indent();
+ indent = indent()
return apply
@@ -23222,22 +28279,22 @@ function factory$4(type) {
// 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);
+ var node = apply.apply(null, arguments)
- line = current.line;
- column = current.column;
- value = subvalue + value;
+ 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({});
+ var result = pos({})
- line = current.line;
- column = current.column;
- value = subvalue + value;
+ line = current.line
+ column = current.column
+ value = subvalue + value
return result.position
}
@@ -23247,15 +28304,15 @@ function factory$4(type) {
// Check whether a node is mergeable with adjacent nodes.
function mergeable(node) {
- var start;
- var end;
+ var start
+ var end
if (node.type !== 'text' || !node.position) {
return true
}
- start = node.position.start;
- end = node.position.end;
+ start = node.position.start
+ end = node.position.end
// Only merge nodes which occupy the same size as their `value`.
return (
@@ -23265,7 +28322,7 @@ function mergeable(node) {
// Merge two text nodes: `node` into `prev`.
function mergeText(prev, node) {
- prev.value += node.value;
+ prev.value += node.value
return prev
}
@@ -23276,68 +28333,73 @@ function mergeBlockquote(prev, node) {
return node
}
- prev.children = prev.children.concat(node.children);
+ prev.children = prev.children.concat(node.children)
return prev
}
-var markdownEscapes = escapes;
-var defaults$1 = [
- '\\',
- '`',
- '*',
- '{',
- '}',
- '[',
- ']',
- '(',
- ')',
- '#',
- '+',
- '-',
- '.',
- '!',
- '_',
- '>'
-];
+/***/ }),
+/* 217 */
+/***/ (function(module, exports, __webpack_require__) {
-var gfm = defaults$1.concat(['~', '|']);
+"use strict";
-var commonmark = gfm.concat([
- '\n',
- '"',
- '$',
- '%',
- '&',
- "'",
- ',',
- '/',
- ':',
- ';',
- '<',
- '=',
- '?',
- '@',
- '^'
-]);
-escapes.default = defaults$1;
-escapes.gfm = gfm;
-escapes.commonmark = commonmark;
+var xtend = __webpack_require__(7)
+var escapes = __webpack_require__(81)
+var defaults = __webpack_require__(82)
-/* Get markdown escapes. */
-function escapes(options) {
- var settings = options || {};
+module.exports = setOptions
- if (settings.commonmark) {
- return commonmark
+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
}
- return settings.gfm ? gfm : defaults$1
+ self.options = options
+ self.escape = escapes(options)
+
+ return self
}
-var blockElements = [
+
+/***/ }),
+/* 218 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+module.exports = [
'address',
'article',
'aside',
@@ -23404,69 +28466,171 @@ var blockElements = [
'tr',
'track',
'ul'
-];
+]
-var defaults$2 = {
- position: true,
- gfm: true,
- commonmark: false,
- footnotes: false,
- pedantic: false,
- blocks: blockElements
-};
-var setOptions_1 = setOptions;
+/***/ }),
+/* 219 */
+/***/ (function(module, exports, __webpack_require__) {
-function setOptions(options) {
- var self = this;
- var current = self.options;
- var key;
- var value;
+"use strict";
- if (options == null) {
- options = {};
- } else if (typeof options === 'object') {
- options = immutable(options);
- } else {
- throw new Error('Invalid value `' + options + '` for setting `options`')
+
+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++
}
- for (key in defaults$2) {
- value = options[key];
+ node = {
+ type: 'root',
+ children: self.tokenizeBlock(value, content),
+ position: {start: start, end: self.eof || xtend(start)}
+ }
- if (value == null) {
- value = current[key];
+ 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 (
- (key !== 'blocks' && typeof value !== 'boolean') ||
- (key === 'blocks' && typeof value !== 'object')
- ) {
- throw new Error(
- 'Invalid value `' + value + '` for setting `options.' + key + '`'
- )
+ if (node.children && result !== SKIP) {
+ return all(node.children, parents.concat(node)) === EXIT ? EXIT : result
}
- options[key] = value;
+ return result
}
- self.options = options;
- self.escape = markdownEscapes(options);
+ // 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
- return self
+ 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. */
-var unistUtilIs = is;
+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);
+ var hasParent = parent !== null && parent !== undefined
+ var hasIndex = index !== null && index !== undefined
+ var check = convert(test)
if (
hasIndex &&
@@ -23496,7 +28660,7 @@ function convert(test) {
}
if (test === null || test === undefined) {
- return ok$1
+ return ok
}
if (typeof test === 'object') {
@@ -23511,12 +28675,12 @@ function convert(test) {
}
function convertAll(tests) {
- var results = [];
- var length = tests.length;
- var index = -1;
+ var results = []
+ var length = tests.length
+ var index = -1
while (++index < length) {
- results[index] = convert(tests[index]);
+ results[index] = convert(tests[index])
}
return results
@@ -23528,7 +28692,7 @@ function matchesFactory(test) {
return matches
function matches(node) {
- var key;
+ var key
for (key in test) {
if (node[key] !== test[key]) {
@@ -23541,13 +28705,13 @@ function matchesFactory(test) {
}
function anyFactory(tests) {
- var checks = convertAll(tests);
- var length = checks.length;
+ var checks = convertAll(tests)
+ var length = checks.length
return matches
function matches() {
- var index = -1;
+ var index = -1
while (++index < length) {
if (checks[index].apply(this, arguments)) {
@@ -23570,178 +28734,32 @@ function typeFactory(test) {
}
/* Utility to return true. */
-function ok$1() {
+function ok() {
return true
}
-var unistUtilVisitParents = visitParents;
-
+/***/ }),
+/* 223 */
+/***/ (function(module, exports, __webpack_require__) {
-var CONTINUE = true;
-var SKIP = 'skip';
-var EXIT = false;
+"use strict";
-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;
+var whitespace = __webpack_require__(8)
- if (!test || unistUtilIs(test, node, index, parents[parents.length - 1] || null)) {
- result = visitor(node, parents);
+module.exports = newline
- 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;
- }
- }
-}
-
-var unistUtilVisit = visit;
-
-
-
-var CONTINUE$1 = unistUtilVisitParents.CONTINUE;
-var SKIP$1 = unistUtilVisitParents.SKIP;
-var EXIT$1 = unistUtilVisitParents.EXIT;
-
-visit.CONTINUE = CONTINUE$1;
-visit.SKIP = SKIP$1;
-visit.EXIT = EXIT$1;
-
-function visit(tree, test, visitor, reverse) {
- if (typeof test === 'function' && typeof visitor !== 'function') {
- reverse = visitor;
- visitor = test;
- test = null;
- }
-
- unistUtilVisitParents(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)
- }
-}
-
-var unistUtilRemovePosition = removePosition;
-
-/* Remove `position`s from `tree`. */
-function removePosition(node, force) {
- unistUtilVisit(node, force ? hard : soft);
- return node
-}
-
-function hard(node) {
- delete node.position;
-}
-
-function soft(node) {
- node.position = undefined;
-}
-
-var parse_1$3 = parse$8;
-
-var lineFeed = '\n';
-var lineBreaksExpression = /\r\n|\r/g;
-
-// Parse the bound file.
-function parse$8() {
- var self = this;
- var value = String(self.file);
- var start = {line: 1, column: 1, offset: 0};
- var content = immutable(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 || immutable(start)}
- };
-
- if (!self.options.position) {
- unistUtilRemovePosition(node, true);
- }
-
- return node
-}
-
-var isWhitespaceCharacter = whitespace;
-
-var fromCode = String.fromCharCode;
-var re$1 = /\s/;
-
-/* Check if the given character code, or the character
- * code at the first character, is a whitespace character. */
-function whitespace(character) {
- return re$1.test(
- typeof character === 'number' ? fromCode(character) : character.charAt(0)
- )
-}
-
-var newline_1 = newline;
-
-var lineFeed$1 = '\n';
+var lineFeed = '\n'
function newline(eat, value, silent) {
- var character = value.charAt(0);
- var length;
- var subvalue;
- var queue;
- var index;
+ var character = value.charAt(0)
+ var length
+ var subvalue
+ var queue
+ var index
- if (character !== lineFeed$1) {
+ if (character !== lineFeed) {
return
}
@@ -23750,96 +28768,91 @@ function newline(eat, value, silent) {
return true
}
- index = 1;
- length = value.length;
- subvalue = character;
- queue = '';
+ index = 1
+ length = value.length
+ subvalue = character
+ queue = ''
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
- if (!isWhitespaceCharacter(character)) {
+ if (!whitespace(character)) {
break
}
- queue += character;
+ queue += character
- if (character === lineFeed$1) {
- subvalue += queue;
- queue = '';
+ if (character === lineFeed) {
+ subvalue += queue
+ queue = ''
}
- index++;
+ index++
}
- eat(subvalue);
+ eat(subvalue)
}
-var trimTrailingLines_1 = trimTrailingLines;
-var line = '\n';
+/***/ }),
+/* 224 */
+/***/ (function(module, exports, __webpack_require__) {
-/* Remove final newline characters from `value`. */
-function trimTrailingLines(value) {
- var val = String(value);
- var index = val.length;
+"use strict";
- while (val.charAt(--index) === line) {
- /* Empty */
- }
- return val.slice(0, index + 1)
-}
+var repeat = __webpack_require__(10)
+var trim = __webpack_require__(40)
-var codeIndented = indentedCode;
+module.exports = indentedCode
-var lineFeed$2 = '\n';
-var tab = '\t';
-var space = ' ';
+var lineFeed = '\n'
+var tab = '\t'
+var space = ' '
-var tabSize = 4;
-var codeIndent = repeatString(space, tabSize);
+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;
+ 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);
+ character = value.charAt(index)
if (indent) {
- indent = false;
+ indent = false
- subvalue += subvalueQueue;
- content += contentQueue;
- subvalueQueue = '';
- contentQueue = '';
+ subvalue += subvalueQueue
+ content += contentQueue
+ subvalueQueue = ''
+ contentQueue = ''
- if (character === lineFeed$2) {
- subvalueQueue = character;
- contentQueue = character;
+ if (character === lineFeed) {
+ subvalueQueue = character
+ contentQueue = character
} else {
- subvalue += character;
- content += character;
+ subvalue += character
+ content += character
while (++index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
- if (!character || character === lineFeed$2) {
- contentQueue = character;
- subvalueQueue = character;
+ if (!character || character === lineFeed) {
+ contentQueue = character
+ subvalueQueue = character
break
}
- subvalue += character;
- content += character;
+ subvalue += character
+ content += character
}
}
} else if (
@@ -23848,26 +28861,26 @@ function indentedCode(eat, value, silent) {
value.charAt(index + 2) === character &&
value.charAt(index + 3) === character
) {
- subvalueQueue += codeIndent;
- index += 3;
- indent = true;
+ subvalueQueue += codeIndent
+ index += 3
+ indent = true
} else if (character === tab) {
- subvalueQueue += character;
- indent = true;
+ subvalueQueue += character
+ indent = true
} else {
- blankQueue = '';
+ blankQueue = ''
while (character === tab || character === space) {
- blankQueue += character;
- character = value.charAt(++index);
+ blankQueue += character
+ character = value.charAt(++index)
}
- if (character !== lineFeed$2) {
+ if (character !== lineFeed) {
break
}
- subvalueQueue += blankQueue + character;
- contentQueue += character;
+ subvalueQueue += blankQueue + character
+ contentQueue += character
}
}
@@ -23880,41 +28893,51 @@ function indentedCode(eat, value, silent) {
type: 'code',
lang: null,
meta: null,
- value: trimTrailingLines_1(content)
+ value: trim(content)
})
}
}
-var codeFenced = fencedCode;
-var lineFeed$3 = '\n';
-var tab$1 = '\t';
-var space$1 = ' ';
-var tilde$1 = '~';
-var graveAccent = '`';
+/***/ }),
+/* 225 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var trim = __webpack_require__(40)
+
+module.exports = fencedCode
-var minFenceCount = 3;
-var tabSize$1 = 4;
+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;
+ 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
@@ -23922,40 +28945,40 @@ function fencedCode(eat, value, silent) {
// Eat initial spacing.
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
- if (character !== space$1 && character !== tab$1) {
+ if (character !== space && character !== tab) {
break
}
- subvalue += character;
- index++;
+ subvalue += character
+ index++
}
- indent = index;
+ indent = index
// Eat the fence.
- character = value.charAt(index);
+ character = value.charAt(index)
- if (character !== tilde$1 && character !== graveAccent) {
+ if (character !== tilde && character !== graveAccent) {
return
}
- index++;
- marker = character;
- fenceCount = 1;
- subvalue += character;
+ index++
+ marker = character
+ fenceCount = 1
+ subvalue += character
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
if (character !== marker) {
break
}
- subvalue += character;
- fenceCount++;
- index++;
+ subvalue += character
+ fenceCount++
+ index++
}
if (fenceCount < minFenceCount) {
@@ -23964,44 +28987,44 @@ function fencedCode(eat, value, silent) {
// Eat spacing before flag.
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
- if (character !== space$1 && character !== tab$1) {
+ if (character !== space && character !== tab) {
break
}
- subvalue += character;
- index++;
+ subvalue += character
+ index++
}
// Eat flag.
- flag = '';
- queue = '';
+ flag = ''
+ queue = ''
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
if (
- character === lineFeed$3 ||
- character === tilde$1 ||
+ character === lineFeed ||
+ character === tilde ||
character === graveAccent
) {
break
}
- if (character === space$1 || character === tab$1) {
- queue += character;
+ if (character === space || character === tab) {
+ queue += character
} else {
- flag += queue + character;
- queue = '';
+ flag += queue + character
+ queue = ''
}
- index++;
+ index++
}
- character = value.charAt(index);
+ character = value.charAt(index)
- if (character && character !== lineFeed$3) {
+ if (character && character !== lineFeed) {
return
}
@@ -24009,122 +29032,122 @@ function fencedCode(eat, value, silent) {
return true
}
- now = eat.now();
- now.column += subvalue.length;
- now.offset += subvalue.length;
+ now = eat.now()
+ now.column += subvalue.length
+ now.offset += subvalue.length
- subvalue += flag;
- flag = self.decode.raw(self.unescape(flag), now);
+ subvalue += flag
+ flag = self.decode.raw(self.unescape(flag), now)
if (queue) {
- subvalue += queue;
+ subvalue += queue
}
- queue = '';
- closing = '';
- exdentedClosing = '';
- content = '';
- exdentedContent = '';
+ queue = ''
+ closing = ''
+ exdentedClosing = ''
+ content = ''
+ exdentedContent = ''
// Eat content.
while (index < length) {
- character = value.charAt(index);
- content += closing;
- exdentedContent += exdentedClosing;
- closing = '';
- exdentedClosing = '';
-
- if (character !== lineFeed$3) {
- content += character;
- exdentedClosing += character;
- index++;
+ 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;
+ closing += character
+ exdentedClosing += character
} else {
- subvalue += character;
+ subvalue += character
}
- queue = '';
- index++;
+ queue = ''
+ index++
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
- if (character !== space$1) {
+ if (character !== space) {
break
}
- queue += character;
- index++;
+ queue += character
+ index++
}
- closing += queue;
- exdentedClosing += queue.slice(indent);
+ closing += queue
+ exdentedClosing += queue.slice(indent)
- if (queue.length >= tabSize$1) {
+ if (queue.length >= tabSize) {
continue
}
- queue = '';
+ queue = ''
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
if (character !== marker) {
break
}
- queue += character;
- index++;
+ queue += character
+ index++
}
- closing += queue;
- exdentedClosing += queue;
+ closing += queue
+ exdentedClosing += queue
if (queue.length < fenceCount) {
continue
}
- queue = '';
+ queue = ''
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
- if (character !== space$1 && character !== tab$1) {
+ if (character !== space && character !== tab) {
break
}
- closing += character;
- exdentedClosing += character;
- index++;
+ closing += character
+ exdentedClosing += character
+ index++
}
- if (!character || character === lineFeed$3) {
+ if (!character || character === lineFeed) {
break
}
}
- subvalue += content + closing;
+ subvalue += content + closing
// Get lang and meta from the flag.
- index = -1;
- length = flag.length;
+ index = -1
+ length = flag.length
while (++index < length) {
- character = flag.charAt(index);
+ character = flag.charAt(index)
- if (character === space$1 || character === tab$1) {
+ if (character === space || character === tab) {
if (!lang) {
- lang = flag.slice(0, index);
+ lang = flag.slice(0, index)
}
} else if (lang) {
- meta = flag.slice(index);
+ meta = flag.slice(index)
break
}
}
@@ -24133,100 +29156,58 @@ function fencedCode(eat, value, silent) {
type: 'code',
lang: lang || flag || null,
meta: meta || null,
- value: trimTrailingLines_1(exdentedContent)
+ value: trim(exdentedContent)
})
}
-var trim_1 = createCommonjsModule(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*$/, '');
-};
-});
-
-var trim_2 = trim_1.left;
-var trim_3 = trim_1.right;
-
-var interrupt_1 = 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
- }
+/***/ }),
+/* 226 */
+/***/ (function(module, exports, __webpack_require__) {
- if (
- config.commonmark !== undefined &&
- config.commonmark !== ctx.options.commonmark
- ) {
- continue
- }
+"use strict";
- if (tokenizers[interruptor[0]].apply(ctx, params)) {
- return true
- }
- }
- return false
-}
+var trim = __webpack_require__(14)
+var interrupt = __webpack_require__(41)
-var blockquote_1 = blockquote;
+module.exports = blockquote
-var lineFeed$4 = '\n';
-var tab$2 = '\t';
-var space$2 = ' ';
-var greaterThan = '>';
+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;
+ 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);
+ character = value.charAt(index)
- if (character !== space$2 && character !== tab$2) {
+ if (character !== space && character !== tab) {
break
}
- index++;
+ index++
}
if (value.charAt(index) !== greaterThan) {
@@ -24237,125 +29218,133 @@ function blockquote(eat, value, silent) {
return true
}
- index = 0;
+ index = 0
while (index < length) {
- nextIndex = value.indexOf(lineFeed$4, index);
- startIndex = index;
- prefixed = false;
+ nextIndex = value.indexOf(lineFeed, index)
+ startIndex = index
+ prefixed = false
if (nextIndex === -1) {
- nextIndex = length;
+ nextIndex = length
}
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
- if (character !== space$2 && character !== tab$2) {
+ if (character !== space && character !== tab) {
break
}
- index++;
+ index++
}
if (value.charAt(index) === greaterThan) {
- index++;
- prefixed = true;
+ index++
+ prefixed = true
- if (value.charAt(index) === space$2) {
- index++;
+ if (value.charAt(index) === space) {
+ index++
}
} else {
- index = startIndex;
+ index = startIndex
}
- content = value.slice(index, nextIndex);
+ content = value.slice(index, nextIndex)
- if (!prefixed && !trim_1(content)) {
- index = startIndex;
+ if (!prefixed && !trim(content)) {
+ index = startIndex
break
}
if (!prefixed) {
- rest = value.slice(index);
+ rest = value.slice(index)
// Check if the following code contains a possible block.
- if (interrupt_1(interruptors, tokenizers, self, [eat, rest, true])) {
+ if (interrupt(interruptors, tokenizers, self, [eat, rest, true])) {
break
}
}
- line = startIndex === index ? content : value.slice(startIndex, nextIndex);
+ line = startIndex === index ? content : value.slice(startIndex, nextIndex)
- indents.push(index - startIndex);
- values.push(line);
- contents.push(content);
+ indents.push(index - startIndex)
+ values.push(line)
+ contents.push(content)
- index = nextIndex + 1;
+ index = nextIndex + 1
}
- index = -1;
- length = indents.length;
- add = eat(values.join(lineFeed$4));
+ index = -1
+ length = indents.length
+ add = eat(values.join(lineFeed))
while (++index < length) {
- offsets[currentLine] = (offsets[currentLine] || 0) + indents[index];
- currentLine++;
+ offsets[currentLine] = (offsets[currentLine] || 0) + indents[index]
+ currentLine++
}
- exit = self.enterBlock();
- contents = self.tokenizeBlock(contents.join(lineFeed$4), now);
- exit();
+ exit = self.enterBlock()
+ contents = self.tokenizeBlock(contents.join(lineFeed), now)
+ exit()
return add({type: 'blockquote', children: contents})
}
-var headingAtx = atxHeading;
-var lineFeed$5 = '\n';
-var tab$3 = '\t';
-var space$3 = ' ';
-var numberSign = '#';
+/***/ }),
+/* 227 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+module.exports = atxHeading
-var maxFenceCount = 6;
+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;
+ 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);
+ character = value.charAt(index)
- if (character !== space$3 && character !== tab$3) {
- index--;
+ if (character !== space && character !== tab) {
+ index--
break
}
- subvalue += character;
+ subvalue += character
}
// Eat hashes.
- depth = 0;
+ depth = 0
while (++index <= length) {
- character = value.charAt(index);
+ character = value.charAt(index)
if (character !== numberSign) {
- index--;
+ index--
break
}
- subvalue += character;
- depth++;
+ subvalue += character
+ depth++
}
if (depth > maxFenceCount) {
@@ -24366,24 +29355,24 @@ function atxHeading(eat, value, silent) {
return
}
- length = value.length + 1;
+ length = value.length + 1
// Eat intermediate white-space.
- queue = '';
+ queue = ''
while (++index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
- if (character !== space$3 && character !== tab$3) {
- index--;
+ if (character !== space && character !== tab) {
+ index--
break
}
- queue += character;
+ queue += character
}
// Exit when not in pedantic mode without spacing.
- if (!pedantic && queue.length === 0 && character && character !== lineFeed$5) {
+ if (!pedantic && queue.length === 0 && character && character !== lineFeed) {
return
}
@@ -24392,50 +29381,50 @@ function atxHeading(eat, value, silent) {
}
// Eat content.
- subvalue += queue;
- queue = '';
- content = '';
+ subvalue += queue
+ queue = ''
+ content = ''
while (++index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
- if (!character || character === lineFeed$5) {
+ if (!character || character === lineFeed) {
break
}
- if (character !== space$3 && character !== tab$3 && character !== numberSign) {
- content += queue + character;
- queue = '';
+ if (character !== space && character !== tab && character !== numberSign) {
+ content += queue + character
+ queue = ''
continue
}
- while (character === space$3 || character === tab$3) {
- queue += character;
- character = value.charAt(++index);
+ 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;
+ content += character
continue
}
while (character === numberSign) {
- queue += character;
- character = value.charAt(++index);
+ queue += character
+ character = value.charAt(++index)
}
- while (character === space$3 || character === tab$3) {
- queue += character;
- character = value.charAt(++index);
+ while (character === space || character === tab) {
+ queue += character
+ character = value.charAt(++index)
}
- index--;
+ index--
}
- now.column += subvalue.length;
- now.offset += subvalue.length;
- subvalue += content + queue;
+ now.column += subvalue.length
+ now.offset += subvalue.length
+ subvalue += content + queue
return eat(subvalue)({
type: 'heading',
@@ -24444,63 +29433,71 @@ function atxHeading(eat, value, silent) {
})
}
-var thematicBreak_1 = thematicBreak;
-var tab$4 = '\t';
-var lineFeed$6 = '\n';
-var space$4 = ' ';
-var asterisk = '*';
-var dash$1 = '-';
-var underscore = '_';
+/***/ }),
+/* 228 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
-var maxCount = 3;
+
+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;
+ 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);
+ character = value.charAt(index)
- if (character !== tab$4 && character !== space$4) {
+ if (character !== tab && character !== space) {
break
}
- subvalue += character;
+ subvalue += character
}
if (
character !== asterisk &&
- character !== dash$1 &&
+ character !== dash &&
character !== underscore
) {
return
}
- marker = character;
- subvalue += character;
- markerCount = 1;
- queue = '';
+ marker = character
+ subvalue += character
+ markerCount = 1
+ queue = ''
while (++index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
if (character === marker) {
- markerCount++;
- subvalue += queue + marker;
- queue = '';
- } else if (character === space$4) {
- queue += character;
+ markerCount++
+ subvalue += queue + marker
+ queue = ''
+ } else if (character === space) {
+ queue += character
} else if (
markerCount >= maxCount &&
- (!character || character === lineFeed$6)
+ (!character || character === lineFeed)
) {
- subvalue += queue;
+ subvalue += queue
if (silent) {
return true
@@ -24513,230 +29510,134 @@ function thematicBreak(eat, value, silent) {
}
}
-var getIndentation = indentation;
-var tab$5 = '\t';
-var space$5 = ' ';
+/***/ }),
+/* 229 */
+/***/ (function(module, exports, __webpack_require__) {
-var spaceSize = 1;
-var tabSize$2 = 4;
+"use strict";
-// 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$5 || character === space$5) {
- size = character === tab$5 ? tabSize$2 : spaceSize;
-
- indent += size;
-
- if (size > 1) {
- indent = Math.floor(indent / size) * size;
- }
-
- stops[indent] = index;
- character = value.charAt(++index);
- }
-
- return {indent: indent, stops: stops}
-}
-
-var removeIndentation = indentation$1;
-
-var tab$6 = '\t';
-var lineFeed$7 = '\n';
-var space$6 = ' ';
-var exclamationMark = '!';
-
-// Remove the minimum indent from every line in `value`. Supports both tab,
-// spaced, and mixed indentation (as well as possible).
-function indentation$1(value, maximum) {
- var values = value.split(lineFeed$7);
- var position = values.length + 1;
- var minIndent = Infinity;
- var matrix = [];
- var index;
- var indentation;
- var stops;
- var padding;
-
- values.unshift(repeatString(space$6, maximum) + exclamationMark);
-
- while (position--) {
- indentation = getIndentation(values[position]);
-
- matrix[position] = indentation.stops;
-
- if (trim_1(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_1(values[position]).length !== 0 &&
- minIndent &&
- index !== minIndent
- ) {
- padding = tab$6;
- } else {
- padding = '';
- }
-
- values[position] =
- padding + values[position].slice(index in stops ? stops[index] + 1 : 0);
- }
- }
-
- values.shift();
-
- return values.join(lineFeed$7)
-}
/* eslint-disable max-params */
-
-
-
-
-
-
-
-var list_1 = list;
-
-var asterisk$1 = '*';
-var underscore$1 = '_';
-var plusSign = '+';
-var dash$2 = '-';
-var dot$1 = '.';
-var space$7 = ' ';
-var lineFeed$8 = '\n';
-var tab$7 = '\t';
-var rightParenthesis = ')';
-var lowercaseX = 'x';
-
-var tabSize$3 = 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;
+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;
+ 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);
+ character = value.charAt(index)
- if (character === tab$7) {
- size += tabSize$3 - (size % tabSize$3);
- } else if (character === space$7) {
- size++;
+ if (character === tab) {
+ size += tabSize - (size % tabSize)
+ } else if (character === space) {
+ size++
} else {
break
}
- index++;
+ index++
}
- if (size >= tabSize$3) {
+ if (size >= tabSize) {
return
}
- character = value.charAt(index);
+ character = value.charAt(index)
- if (character === asterisk$1 || character === plusSign || character === dash$2) {
- marker = character;
- ordered = false;
+ if (character === asterisk || character === plusSign || character === dash) {
+ marker = character
+ ordered = false
} else {
- ordered = true;
- queue = '';
+ ordered = true
+ queue = ''
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
- if (!isDecimal(character)) {
+ if (!decimal(character)) {
break
}
- queue += character;
- index++;
+ queue += character
+ index++
}
- character = value.charAt(index);
+ character = value.charAt(index)
if (
!queue ||
- !(character === dot$1 || (commonmark && character === rightParenthesis))
+ !(character === dot || (commonmark && character === rightParenthesis))
) {
return
}
- start = parseInt(queue, 10);
- marker = character;
+ start = parseInt(queue, 10)
+ marker = character
}
- character = value.charAt(++index);
+ character = value.charAt(++index)
if (
- character !== space$7 &&
- character !== tab$7 &&
- (pedantic || (character !== lineFeed$8 && character !== ''))
+ character !== space &&
+ character !== tab &&
+ (pedantic || (character !== lineFeed && character !== ''))
) {
return
}
@@ -24745,108 +29646,108 @@ function list(eat, value, silent) {
return true
}
- index = 0;
- items = [];
- allLines = [];
- emptyLines = [];
+ index = 0
+ items = []
+ allLines = []
+ emptyLines = []
while (index < length) {
- nextIndex = value.indexOf(lineFeed$8, index);
- startIndex = index;
- prefixed = false;
- indented = false;
+ nextIndex = value.indexOf(lineFeed, index)
+ startIndex = index
+ prefixed = false
+ indented = false
if (nextIndex === -1) {
- nextIndex = length;
+ nextIndex = length
}
- end = index + tabSize$3;
- size = 0;
+ end = index + tabSize
+ size = 0
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
- if (character === tab$7) {
- size += tabSize$3 - (size % tabSize$3);
- } else if (character === space$7) {
- size++;
+ if (character === tab) {
+ size += tabSize - (size % tabSize)
+ } else if (character === space) {
+ size++
} else {
break
}
- index++;
+ index++
}
- if (size >= tabSize$3) {
- indented = true;
+ if (size >= tabSize) {
+ indented = true
}
if (item && size >= item.indent) {
- indented = true;
+ indented = true
}
- character = value.charAt(index);
- currentMarker = null;
+ character = value.charAt(index)
+ currentMarker = null
if (!indented) {
if (
- character === asterisk$1 ||
+ character === asterisk ||
character === plusSign ||
- character === dash$2
+ character === dash
) {
- currentMarker = character;
- index++;
- size++;
+ currentMarker = character
+ index++
+ size++
} else {
- queue = '';
+ queue = ''
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
- if (!isDecimal(character)) {
+ if (!decimal(character)) {
break
}
- queue += character;
- index++;
+ queue += character
+ index++
}
- character = value.charAt(index);
- index++;
+ character = value.charAt(index)
+ index++
if (
queue &&
- (character === dot$1 || (commonmark && character === rightParenthesis))
+ (character === dot || (commonmark && character === rightParenthesis))
) {
- currentMarker = character;
- size += queue.length + 1;
+ currentMarker = character
+ size += queue.length + 1
}
}
if (currentMarker) {
- character = value.charAt(index);
+ character = value.charAt(index)
- if (character === tab$7) {
- size += tabSize$3 - (size % tabSize$3);
- index++;
- } else if (character === space$7) {
- end = index + tabSize$3;
+ if (character === tab) {
+ size += tabSize - (size % tabSize)
+ index++
+ } else if (character === space) {
+ end = index + tabSize
while (index < end) {
- if (value.charAt(index) !== space$7) {
+ if (value.charAt(index) !== space) {
break
}
- index++;
- size++;
+ index++
+ size++
}
- if (index === end && value.charAt(index) === space$7) {
- index -= tabSize$3 - 1;
- size -= tabSize$3 - 1;
+ if (index === end && value.charAt(index) === space) {
+ index -= tabSize - 1
+ size -= tabSize - 1
}
- } else if (character !== lineFeed$8 && character !== '') {
- currentMarker = null;
+ } else if (character !== lineFeed && character !== '') {
+ currentMarker = null
}
}
}
@@ -24856,128 +29757,128 @@ function list(eat, value, silent) {
break
}
- prefixed = true;
+ prefixed = true
} else {
- if (!commonmark && !indented && value.charAt(startIndex) === space$7) {
- indented = true;
+ if (!commonmark && !indented && value.charAt(startIndex) === space) {
+ indented = true
} else if (commonmark && item) {
- indented = size >= item.indent || size > tabSize$3;
+ indented = size >= item.indent || size > tabSize
}
- prefixed = false;
- index = startIndex;
+ prefixed = false
+ index = startIndex
}
- line = value.slice(startIndex, nextIndex);
- content = startIndex === index ? line : value.slice(index, nextIndex);
+ line = value.slice(startIndex, nextIndex)
+ content = startIndex === index ? line : value.slice(index, nextIndex)
if (
- currentMarker === asterisk$1 ||
- currentMarker === underscore$1 ||
- currentMarker === dash$2
+ currentMarker === asterisk ||
+ currentMarker === underscore ||
+ currentMarker === dash
) {
if (tokenizers.thematicBreak.call(self, eat, line, true)) {
break
}
}
- prevEmpty = empty;
- empty = !prefixed && !trim_1(content).length;
+ prevEmpty = empty
+ empty = !prefixed && !trim(content).length
if (indented && item) {
- item.value = item.value.concat(emptyLines, line);
- allLines = allLines.concat(emptyLines, line);
- emptyLines = [];
+ 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();
+ spread = true
+ item.value.push('')
+ item.trail = emptyLines.concat()
}
item = {
value: [line],
indent: size,
trail: []
- };
+ }
- items.push(item);
- allLines = allLines.concat(emptyLines, line);
- emptyLines = [];
+ items.push(item)
+ allLines = allLines.concat(emptyLines, line)
+ emptyLines = []
} else if (empty) {
if (prevEmpty && !commonmark) {
break
}
- emptyLines.push(line);
+ emptyLines.push(line)
} else {
if (prevEmpty) {
break
}
- if (interrupt_1(interuptors, tokenizers, self, [eat, line, true])) {
+ if (interrupt(interuptors, tokenizers, self, [eat, line, true])) {
break
}
- item.value = item.value.concat(emptyLines, line);
- allLines = allLines.concat(emptyLines, line);
- emptyLines = [];
+ item.value = item.value.concat(emptyLines, line)
+ allLines = allLines.concat(emptyLines, line)
+ emptyLines = []
}
- index = nextIndex + 1;
+ index = nextIndex + 1
}
- node = eat(allLines.join(lineFeed$8)).reset({
+ 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;
+ enterTop = self.enterList()
+ exitBlockquote = self.enterBlock()
+ index = -1
+ length = items.length
while (++index < length) {
- item = items[index].value.join(lineFeed$8);
- now = eat.now();
+ item = items[index].value.join(lineFeed)
+ now = eat.now()
- eat(item)(listItem(self, item, now), node);
+ eat(item)(listItem(self, item, now), node)
- item = items[index].trail.join(lineFeed$8);
+ item = items[index].trail.join(lineFeed)
if (index !== length - 1) {
- item += lineFeed$8;
+ item += lineFeed
}
- eat(item);
+ eat(item)
}
- enterTop();
- exitBlockquote();
+ 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;
+ var offsets = ctx.offset
+ var fn = ctx.options.pedantic ? pedanticListItem : normalListItem
+ var checked = null
+ var task
+ var indent
- value = fn.apply(null, arguments);
+ value = fn.apply(null, arguments)
if (ctx.options.gfm) {
- task = value.match(taskItemExpression);
+ task = value.match(taskItemExpression)
if (task) {
- indent = task[0].length;
- checked = task[1].toLowerCase() === lowercaseX;
- offsets[position.line] += indent;
- value = value.slice(indent);
+ indent = task[0].length
+ checked = task[1].toLowerCase() === lowercaseX
+ offsets[position.line] += indent
+ value = value.slice(indent)
}
}
@@ -24991,22 +29892,22 @@ function listItem(ctx, value, position) {
// Create a list-item using overly simple mechanics.
function pedanticListItem(ctx, value, position) {
- var offsets = ctx.offset;
- var line = position.line;
+ var offsets = ctx.offset
+ var line = position.line
// Remove the list-item’s bullet.
- value = value.replace(pedanticBulletExpression, replacer);
+ value = value.replace(pedanticBulletExpression, replacer)
// The initial line was also matched by the below, so we reset the `line`.
- line = position.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++;
+ offsets[line] = (offsets[line] || 0) + $0.length
+ line++
return ''
}
@@ -25014,148 +29915,240 @@ function pedanticListItem(ctx, value, position) {
// 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;
+ 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);
+ value = value.replace(bulletExpression, replacer)
- lines = value.split(lineFeed$8);
+ lines = value.split(lineFeed)
- trimmedLines = removeIndentation(value, getIndentation(max).indent).split(lineFeed$8);
+ 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;
+ trimmedLines[0] = rest
- offsets[line] = (offsets[line] || 0) + bullet.length;
- line++;
+ offsets[line] = (offsets[line] || 0) + bullet.length
+ line++
- index = 0;
- length = lines.length;
+ index = 0
+ length = lines.length
while (++index < length) {
offsets[line] =
- (offsets[line] || 0) + lines[index].length - trimmedLines[index].length;
- line++;
+ (offsets[line] || 0) + lines[index].length - trimmedLines[index].length
+ line++
}
- return trimmedLines.join(lineFeed$8)
+ return trimmedLines.join(lineFeed)
function replacer($0, $1, $2, $3, $4) {
- bullet = $1 + $2 + $3;
- rest = $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$7 + $2;
+ $2 = space + $2
}
- max = $1 + repeatString(space$7, $2.length) + $3;
+ max = $1 + repeat(space, $2.length) + $3
return max + rest
}
}
-var headingSetext = setextHeading;
-var lineFeed$9 = '\n';
-var tab$8 = '\t';
-var space$8 = ' ';
-var equalsTo = '=';
-var dash$3 = '-';
+/***/ }),
+/* 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";
-var maxIndent = 3;
-var equalsToDepth = 1;
-var dashDepth = 2;
+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;
+ 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);
+ character = value.charAt(index)
- if (character !== space$8 || index >= maxIndent) {
- index--;
+ if (character !== space || index >= maxIndent) {
+ index--
break
}
- subvalue += character;
+ subvalue += character
}
// Eat content.
- content = '';
- queue = '';
+ content = ''
+ queue = ''
while (++index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
- if (character === lineFeed$9) {
- index--;
+ if (character === lineFeed) {
+ index--
break
}
- if (character === space$8 || character === tab$8) {
- queue += character;
+ if (character === space || character === tab) {
+ queue += character
} else {
- content += queue + character;
- queue = '';
+ content += queue + character
+ queue = ''
}
}
- now.column += subvalue.length;
- now.offset += subvalue.length;
- subvalue += content + 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);
+ character = value.charAt(++index)
+ marker = value.charAt(++index)
- if (character !== lineFeed$9 || (marker !== equalsTo && marker !== dash$3)) {
+ if (character !== lineFeed || (marker !== equalsTo && marker !== dash)) {
return
}
- subvalue += character;
+ subvalue += character
// Eat Setext-line.
- queue = marker;
- depth = marker === equalsTo ? equalsToDepth : dashDepth;
+ queue = marker
+ depth = marker === equalsTo ? equalsToDepth : dashDepth
while (++index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
if (character !== marker) {
- if (character !== lineFeed$9) {
+ if (character !== lineFeed) {
return
}
- index--;
+ index--
break
}
- queue += character;
+ queue += character
}
if (silent) {
@@ -25169,82 +30162,52 @@ function setextHeading(eat, value, silent) {
})
}
-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 = '<![A-Za-z]+\\s+[^>]*>';
-var cdata = '<!\\[CDATA\\[[\\s\\S]*?\\]\\]>';
-var openCloseTag = new RegExp('^(?:' + openTag + '|' + closeTag + ')');
+/***/ }),
+/* 232 */
+/***/ (function(module, exports, __webpack_require__) {
-var tag = new RegExp(
- '^(?:' +
- openTag +
- '|' +
- closeTag +
- '|' +
- comment +
- '|' +
- processing +
- '|' +
- declaration +
- '|' +
- cdata +
- ')'
-);
+"use strict";
-var html = {
- openCloseTag: openCloseTag,
- tag: tag
-};
-var openCloseTag$1 = html.openCloseTag;
+var openCloseTag = __webpack_require__(84).openCloseTag
-var htmlBlock = blockHtml;
+module.exports = blockHtml
-var tab$9 = '\t';
-var space$9 = ' ';
-var lineFeed$10 = '\n';
-var lessThan = '<';
+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 commentCloseExpression = /-->/;
-var instructionOpenExpression = /^<\?/;
-var instructionCloseExpression = /\?>/;
-var directiveOpenExpression = /^<![A-Za-z]/;
-var directiveCloseExpression = />/;
-var cdataOpenExpression = /^<!\[CDATA\[/;
-var cdataCloseExpression = /\]\]>/;
-var elementCloseExpression = /^$/;
-var otherElementOpenExpression = new RegExp(openCloseTag$1.source + '\\s*$');
+var rawOpenExpression = /^<(script|pre|style)(?=(\s|>|$))/i
+var rawCloseExpression = /<\/(script|pre|style)>/i
+var commentOpenExpression = /^<!--/
+var commentCloseExpression = /-->/
+var instructionOpenExpression = /^<\?/
+var instructionCloseExpression = /\?>/
+var directiveOpenExpression = /^<![A-Za-z]/
+var directiveCloseExpression = />/
+var cdataOpenExpression = /^<!\[CDATA\[/
+var cdataCloseExpression = /\]\]>/
+var elementCloseExpression = /^$/
+var otherElementOpenExpression = new RegExp(openCloseTag.source + '\\s*$')
function blockHtml(eat, value, silent) {
- var self = this;
- var blocks = self.options.blocks.join('|');
+ var self = this
+ var blocks = self.options.blocks.join('|')
var elementOpenExpression = new RegExp(
'^</?(' + blocks + ')(?=(\\s|/?>|$))',
'i'
- );
- var length = value.length;
- var index = 0;
- var next;
- var line;
- var offset;
- var character;
- var count;
- var sequence;
- var subvalue;
+ )
+ 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],
@@ -25254,32 +30217,32 @@ function blockHtml(eat, value, silent) {
[cdataOpenExpression, cdataCloseExpression, true],
[elementOpenExpression, elementCloseExpression, true],
[otherElementOpenExpression, elementCloseExpression, false]
- ];
+ ]
// Eat initial spacing.
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
- if (character !== tab$9 && character !== space$9) {
+ if (character !== tab && character !== space) {
break
}
- index++;
+ index++
}
if (value.charAt(index) !== lessThan) {
return
}
- next = value.indexOf(lineFeed$10, index + 1);
- next = next === -1 ? length : next;
- line = value.slice(index, next);
- offset = -1;
- count = sequences.length;
+ 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];
+ sequence = sequences[offset]
break
}
}
@@ -25292,128 +30255,124 @@ function blockHtml(eat, value, silent) {
return sequence[2]
}
- index = next;
+ index = next
if (!sequence[1].test(line)) {
while (index < length) {
- next = value.indexOf(lineFeed$10, index + 1);
- next = next === -1 ? length : next;
- line = value.slice(index + 1, next);
+ 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;
+ index = next
}
break
}
- index = next;
+ index = next
}
}
- subvalue = value.slice(0, index);
+ subvalue = value.slice(0, index)
return eat(subvalue)({type: 'html', value: subvalue})
}
-var collapseWhiteSpace = collapse;
-/* collapse(' \t\nbar \nbaz\t'); // ' bar baz ' */
-function collapse(value) {
- return String(value).replace(/\s+/g, ' ')
-}
+/***/ }),
+/* 233 */
+/***/ (function(module, exports, __webpack_require__) {
-var normalize_1 = normalize$2;
+"use strict";
-// Normalize an identifier. Collapses multiple white space characters into a
-// single space, and removes casing.
-function normalize$2(value) {
- return collapseWhiteSpace(value).toLowerCase()
-}
-var footnoteDefinition_1 = footnoteDefinition;
-footnoteDefinition.notInList = true;
-footnoteDefinition.notInBlock = true;
+var whitespace = __webpack_require__(8)
+var normalize = __webpack_require__(42)
-var backslash$1 = '\\';
-var lineFeed$11 = '\n';
-var tab$10 = '\t';
-var space$10 = ' ';
-var leftSquareBracket = '[';
-var rightSquareBracket = ']';
-var caret$1 = '^';
-var colon$1 = ':';
+module.exports = footnoteDefinition
+footnoteDefinition.notInList = true
+footnoteDefinition.notInBlock = true
-var EXPRESSION_INITIAL_TAB = /^( {4}|\t)?/gm;
+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;
+ 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;
+ index = 0
+ length = value.length
+ subvalue = ''
+ now = eat.now()
+ currentLine = now.line
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
- if (!isWhitespaceCharacter(character)) {
+ if (!whitespace(character)) {
break
}
- subvalue += character;
- index++;
+ subvalue += character
+ index++
}
if (
value.charAt(index) !== leftSquareBracket ||
- value.charAt(index + 1) !== caret$1
+ value.charAt(index + 1) !== caret
) {
return
}
- subvalue += leftSquareBracket + caret$1;
- index = subvalue.length;
- queue = '';
+ subvalue += leftSquareBracket + caret
+ index = subvalue.length
+ queue = ''
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
if (character === rightSquareBracket) {
break
- } else if (character === backslash$1) {
- queue += character;
- index++;
- character = value.charAt(index);
+ } else if (character === backslash) {
+ queue += character
+ index++
+ character = value.charAt(index)
}
- queue += character;
- index++;
+ queue += character
+ index++
}
if (
!queue ||
value.charAt(index) !== rightSquareBracket ||
- value.charAt(index + 1) !== colon$1
+ value.charAt(index + 1) !== colon
) {
return
}
@@ -25422,342 +30381,368 @@ function footnoteDefinition(eat, value, silent) {
return true
}
- identifier = queue;
- subvalue += queue + rightSquareBracket + colon$1;
- index = subvalue.length;
+ identifier = queue
+ subvalue += queue + rightSquareBracket + colon
+ index = subvalue.length
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
- if (character !== tab$10 && character !== space$10) {
+ if (character !== tab && character !== space) {
break
}
- subvalue += character;
- index++;
+ subvalue += character
+ index++
}
- now.column += subvalue.length;
- now.offset += subvalue.length;
- queue = '';
- content = '';
- subqueue = '';
+ now.column += subvalue.length
+ now.offset += subvalue.length
+ queue = ''
+ content = ''
+ subqueue = ''
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
- if (character === lineFeed$11) {
- subqueue = character;
- index++;
+ if (character === lineFeed) {
+ subqueue = character
+ index++
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
- if (character !== lineFeed$11) {
+ if (character !== lineFeed) {
break
}
- subqueue += character;
- index++;
+ subqueue += character
+ index++
}
- queue += subqueue;
- subqueue = '';
+ queue += subqueue
+ subqueue = ''
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
- if (character !== space$10) {
+ if (character !== space) {
break
}
- subqueue += character;
- index++;
+ subqueue += character
+ index++
}
if (subqueue.length === 0) {
break
}
- queue += subqueue;
+ queue += subqueue
}
if (queue) {
- content += queue;
- queue = '';
+ content += queue
+ queue = ''
}
- content += character;
- index++;
+ content += character
+ index++
}
- subvalue += content;
+ subvalue += content
content = content.replace(EXPRESSION_INITIAL_TAB, function(line) {
- offsets[currentLine] = (offsets[currentLine] || 0) + line.length;
- currentLine++;
+ offsets[currentLine] = (offsets[currentLine] || 0) + line.length
+ currentLine++
return ''
- });
+ })
- add = eat(subvalue);
+ add = eat(subvalue)
- exit = self.enterBlock();
- content = self.tokenizeBlock(content, now);
- exit();
+ exit = self.enterBlock()
+ content = self.tokenizeBlock(content, now)
+ exit()
return add({
type: 'footnoteDefinition',
- identifier: normalize_1(identifier),
+ identifier: normalize(identifier),
label: identifier,
children: content
})
}
-var definition_1 = definition;
-definition.notInList = true;
-definition.notInBlock = true;
-
-var quotationMark = '"';
-var apostrophe = "'";
-var backslash$2 = '\\';
-var lineFeed$12 = '\n';
-var tab$11 = '\t';
-var space$11 = ' ';
-var leftSquareBracket$1 = '[';
-var rightSquareBracket$1 = ']';
-var leftParenthesis = '(';
-var rightParenthesis$1 = ')';
-var colon$2 = ':';
-var lessThan$1 = '<';
-var greaterThan$1 = '>';
+
+/***/ }),
+/* 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;
+ 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);
+ character = value.charAt(index)
- if (character !== space$11 && character !== tab$11) {
+ if (character !== space && character !== tab) {
break
}
- subvalue += character;
- index++;
+ subvalue += character
+ index++
}
- character = value.charAt(index);
+ character = value.charAt(index)
- if (character !== leftSquareBracket$1) {
+ if (character !== leftSquareBracket) {
return
}
- index++;
- subvalue += character;
- queue = '';
+ index++
+ subvalue += character
+ queue = ''
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
- if (character === rightSquareBracket$1) {
+ if (character === rightSquareBracket) {
break
- } else if (character === backslash$2) {
- queue += character;
- index++;
- character = value.charAt(index);
+ } else if (character === backslash) {
+ queue += character
+ index++
+ character = value.charAt(index)
}
- queue += character;
- index++;
+ queue += character
+ index++
}
if (
!queue ||
- value.charAt(index) !== rightSquareBracket$1 ||
- value.charAt(index + 1) !== colon$2
+ value.charAt(index) !== rightSquareBracket ||
+ value.charAt(index + 1) !== colon
) {
return
}
- identifier = queue;
- subvalue += queue + rightSquareBracket$1 + colon$2;
- index = subvalue.length;
- queue = '';
+ identifier = queue
+ subvalue += queue + rightSquareBracket + colon
+ index = subvalue.length
+ queue = ''
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
- if (character !== tab$11 && character !== space$11 && character !== lineFeed$12) {
+ if (character !== tab && character !== space && character !== lineFeed) {
break
}
- subvalue += character;
- index++;
+ subvalue += character
+ index++
}
- character = value.charAt(index);
- queue = '';
- beforeURL = subvalue;
+ character = value.charAt(index)
+ queue = ''
+ beforeURL = subvalue
- if (character === lessThan$1) {
- index++;
+ if (character === lessThan) {
+ index++
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
if (!isEnclosedURLCharacter(character)) {
break
}
- queue += character;
- index++;
+ queue += character
+ index++
}
- character = value.charAt(index);
+ character = value.charAt(index)
if (character === isEnclosedURLCharacter.delimiter) {
- subvalue += lessThan$1 + queue + character;
- index++;
+ subvalue += lessThan + queue + character
+ index++
} else {
if (commonmark) {
return
}
- index -= queue.length + 1;
- queue = '';
+ index -= queue.length + 1
+ queue = ''
}
}
if (!queue) {
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
if (!isUnclosedURLCharacter(character)) {
break
}
- queue += character;
- index++;
+ queue += character
+ index++
}
- subvalue += queue;
+ subvalue += queue
}
if (!queue) {
return
}
- url = queue;
- queue = '';
+ url = queue
+ queue = ''
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
- if (character !== tab$11 && character !== space$11 && character !== lineFeed$12) {
+ if (character !== tab && character !== space && character !== lineFeed) {
break
}
- queue += character;
- index++;
+ queue += character
+ index++
}
- character = value.charAt(index);
- test = null;
+ character = value.charAt(index)
+ test = null
if (character === quotationMark) {
- test = quotationMark;
+ test = quotationMark
} else if (character === apostrophe) {
- test = apostrophe;
+ test = apostrophe
} else if (character === leftParenthesis) {
- test = rightParenthesis$1;
+ test = rightParenthesis
}
if (!test) {
- queue = '';
- index = subvalue.length;
+ queue = ''
+ index = subvalue.length
} else if (queue) {
- subvalue += queue + character;
- index = subvalue.length;
- queue = '';
+ subvalue += queue + character
+ index = subvalue.length
+ queue = ''
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
if (character === test) {
break
}
- if (character === lineFeed$12) {
- index++;
- character = value.charAt(index);
+ if (character === lineFeed) {
+ index++
+ character = value.charAt(index)
- if (character === lineFeed$12 || character === test) {
+ if (character === lineFeed || character === test) {
return
}
- queue += lineFeed$12;
+ queue += lineFeed
}
- queue += character;
- index++;
+ queue += character
+ index++
}
- character = value.charAt(index);
+ character = value.charAt(index)
if (character !== test) {
return
}
- beforeTitle = subvalue;
- subvalue += queue + character;
- index++;
- title = queue;
- queue = '';
+ beforeTitle = subvalue
+ subvalue += queue + character
+ index++
+ title = queue
+ queue = ''
} else {
return
}
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
- if (character !== tab$11 && character !== space$11) {
+ if (character !== tab && character !== space) {
break
}
- subvalue += character;
- index++;
+ subvalue += character
+ index++
}
- character = value.charAt(index);
+ character = value.charAt(index)
- if (!character || character === lineFeed$12) {
+ if (!character || character === lineFeed) {
if (silent) {
return true
}
- beforeURL = eat(beforeURL).test().end;
- url = self.decode.raw(self.unescape(url), beforeURL, {nonTerminated: false});
+ 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);
+ beforeTitle = eat(beforeTitle).test().end
+ title = self.decode.raw(self.unescape(title), beforeTitle)
}
return eat(subvalue)({
type: 'definition',
- identifier: normalize_1(identifier),
+ identifier: normalize(identifier),
label: identifier,
title: title || null,
url: url
@@ -25768,67 +30753,77 @@ function definition(eat, value, silent) {
// Check if `character` can be inside an enclosed URI.
function isEnclosedURLCharacter(character) {
return (
- character !== greaterThan$1 &&
- character !== leftSquareBracket$1 &&
- character !== rightSquareBracket$1
+ character !== greaterThan &&
+ character !== leftSquareBracket &&
+ character !== rightSquareBracket
)
}
-isEnclosedURLCharacter.delimiter = greaterThan$1;
+isEnclosedURLCharacter.delimiter = greaterThan
// Check if `character` can be inside an unclosed URI.
function isUnclosedURLCharacter(character) {
return (
- character !== leftSquareBracket$1 &&
- character !== rightSquareBracket$1 &&
- !isWhitespaceCharacter(character)
+ character !== leftSquareBracket &&
+ character !== rightSquareBracket &&
+ !whitespace(character)
)
}
-var table_1 = table$1;
-
-var tab$12 = '\t';
-var lineFeed$13 = '\n';
-var space$12 = ' ';
-var dash$4 = '-';
-var colon$3 = ':';
-var backslash$3 = '\\';
-var graveAccent$1 = '`';
-var verticalBar = '|';
-
-var minColumns = 1;
-var minRows = 2;
-
-var left = 'left';
-var center = 'center';
-var right = 'right';
-function table$1(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;
+/***/ }),
+/* 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) {
@@ -25839,17 +30834,17 @@ function table$1(eat, value, silent) {
// 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 = [];
+ index = 0
+ lineCount = 0
+ length = value.length + 1
+ lines = []
while (index < length) {
- lineIndex = value.indexOf(lineFeed$13, index);
- pipeIndex = value.indexOf(verticalBar, index + 1);
+ lineIndex = value.indexOf(lineFeed, index)
+ pipeIndex = value.indexOf(verticalBar, index + 1)
if (lineIndex === -1) {
- lineIndex = value.length;
+ lineIndex = value.length
}
if (pipeIndex === -1 || pipeIndex > lineIndex) {
@@ -25860,56 +30855,56 @@ function table$1(eat, value, silent) {
break
}
- lines.push(value.slice(index, lineIndex));
- lineCount++;
- index = lineIndex + 1;
+ lines.push(value.slice(index, lineIndex))
+ lineCount++
+ index = lineIndex + 1
}
// Parse the alignment row.
- subvalue = lines.join(lineFeed$13);
- alignments = lines.splice(1, 1)[0] || [];
- index = 0;
- length = alignments.length;
- lineCount--;
- alignment = false;
- align = [];
+ 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);
+ character = alignments.charAt(index)
if (character === verticalBar) {
- hasDash = null;
+ hasDash = null
if (alignment === false) {
if (first === false) {
return
}
} else {
- align.push(alignment);
- alignment = false;
+ align.push(alignment)
+ alignment = false
}
- first = false;
- } else if (character === dash$4) {
- hasDash = true;
- alignment = alignment || null;
- } else if (character === colon$3) {
+ first = false
+ } else if (character === dash) {
+ hasDash = true
+ alignment = alignment || null
+ } else if (character === colon) {
if (alignment === left) {
- alignment = center;
+ alignment = center
} else if (hasDash && alignment === null) {
- alignment = right;
+ alignment = right
} else {
- alignment = left;
+ alignment = left
}
- } else if (!isWhitespaceCharacter(character)) {
+ } else if (!whitespace(character)) {
return
}
- index++;
+ index++
}
if (alignment !== false) {
- align.push(alignment);
+ align.push(alignment)
}
// Exit when without enough columns.
@@ -25923,190 +30918,203 @@ function table$1(eat, value, silent) {
}
// Parse the rows.
- position = -1;
- rows = [];
+ position = -1
+ rows = []
- table = eat(subvalue).reset({type: 'table', align: align, children: rows});
+ table = eat(subvalue).reset({type: 'table', align: align, children: rows})
while (++position < lineCount) {
- line = lines[position];
- row = {type: 'tableRow', children: []};
+ line = lines[position]
+ row = {type: 'tableRow', children: []}
// Eat a newline character when this is not the first row.
if (position) {
- eat(lineFeed$13);
+ eat(lineFeed)
}
// Eat the row.
- eat(line).reset(row, table);
+ eat(line).reset(row, table)
- length = line.length + 1;
- index = 0;
- queue = '';
- cell = '';
- preamble = true;
- count = null;
- opening = null;
+ length = line.length + 1
+ index = 0
+ queue = ''
+ cell = ''
+ preamble = true
+ count = null
+ opening = null
while (index < length) {
- character = line.charAt(index);
+ character = line.charAt(index)
- if (character === tab$12 || character === space$12) {
+ if (character === tab || character === space) {
if (cell) {
- queue += character;
+ queue += character
} else {
- eat(character);
+ eat(character)
}
- index++;
+ index++
continue
}
if (character === '' || character === verticalBar) {
if (preamble) {
- eat(character);
+ eat(character)
} else {
if (character && opening) {
- queue += character;
- index++;
+ queue += character
+ index++
continue
}
if ((cell || character) && !preamble) {
- subvalue = cell;
+ subvalue = cell
if (queue.length > 1) {
if (character) {
- subvalue += queue.slice(0, queue.length - 1);
- queue = queue.charAt(queue.length - 1);
+ subvalue += queue.slice(0, queue.length - 1)
+ queue = queue.charAt(queue.length - 1)
} else {
- subvalue += queue;
- queue = '';
+ subvalue += queue
+ queue = ''
}
}
- now = eat.now();
+ now = eat.now()
eat(subvalue)(
{type: 'tableCell', children: self.tokenizeInline(cell, now)},
row
- );
+ )
}
- eat(queue + character);
+ eat(queue + character)
- queue = '';
- cell = '';
+ queue = ''
+ cell = ''
}
} else {
if (queue) {
- cell += queue;
- queue = '';
+ cell += queue
+ queue = ''
}
- cell += character;
+ cell += character
- if (character === backslash$3 && index !== length - 2) {
- cell += line.charAt(index + 1);
- index++;
+ if (character === backslash && index !== length - 2) {
+ cell += line.charAt(index + 1)
+ index++
}
- if (character === graveAccent$1) {
- count = 1;
+ if (character === graveAccent) {
+ count = 1
while (line.charAt(index + 1) === character) {
- cell += character;
- index++;
- count++;
+ cell += character
+ index++
+ count++
}
if (!opening) {
- opening = count;
+ opening = count
} else if (count >= opening) {
- opening = 0;
+ opening = 0
}
}
}
- preamble = false;
- index++;
+ preamble = false
+ index++
}
// Eat the alignment row.
if (!position) {
- eat(lineFeed$13 + alignments);
+ eat(lineFeed + alignments)
}
}
return table
}
-var paragraph_1 = paragraph;
-var tab$13 = '\t';
-var lineFeed$14 = '\n';
-var space$13 = ' ';
+/***/ }),
+/* 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)
-var tabSize$4 = 4;
+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$14);
- var length = value.length;
- var position;
- var subvalue;
- var character;
- var size;
- var now;
+ 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;
+ index = length
break
}
// Stop if the next character is NEWLINE.
- if (value.charAt(index + 1) === lineFeed$14) {
+ 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;
+ size = 0
+ position = index + 1
while (position < length) {
- character = value.charAt(position);
+ character = value.charAt(position)
- if (character === tab$13) {
- size = tabSize$4;
+ if (character === tab) {
+ size = tabSize
break
- } else if (character === space$13) {
- size++;
+ } else if (character === space) {
+ size++
} else {
break
}
- position++;
+ position++
}
- if (size >= tabSize$4 && character !== lineFeed$14) {
- index = value.indexOf(lineFeed$14, index + 1);
+ if (size >= tabSize && character !== lineFeed) {
+ index = value.indexOf(lineFeed, index + 1)
continue
}
}
- subvalue = value.slice(index + 1);
+ subvalue = value.slice(index + 1)
// Check if the following code contains a possible block.
- if (interrupt_1(interruptors, tokenizers, self, [eat, subvalue, true])) {
+ if (interrupt(interruptors, tokenizers, self, [eat, subvalue, true])) {
break
}
@@ -26116,24 +31124,24 @@ function paragraph(eat, value, silent) {
tokenizers.list.call(self, eat, subvalue, true) &&
(self.inList ||
commonmark ||
- (gfm && !isDecimal(trim_1.left(subvalue).charAt(0))))
+ (gfm && !decimal(trim.left(subvalue).charAt(0))))
) {
break
}
- position = index;
- index = value.indexOf(lineFeed$14, index + 1);
+ position = index
+ index = value.indexOf(lineFeed, index + 1)
- if (index !== -1 && trim_1(value.slice(position, index)) === '') {
- index = position;
+ if (index !== -1 && trim(value.slice(position, index)) === '') {
+ index = position
break
}
}
- subvalue = value.slice(0, index);
+ subvalue = value.slice(0, index)
- if (trim_1(subvalue) === '') {
- eat(subvalue);
+ if (trim(subvalue) === '') {
+ eat(subvalue)
return null
}
@@ -26143,8 +31151,8 @@ function paragraph(eat, value, silent) {
return true
}
- now = eat.now();
- subvalue = trimTrailingLines_1(subvalue);
+ now = eat.now()
+ subvalue = trimTrailingLines(subvalue)
return eat(subvalue)({
type: 'paragraph',
@@ -26152,25 +31160,29 @@ function paragraph(eat, value, silent) {
})
}
-var _escape = locate;
-function locate(value, fromIndex) {
- return value.indexOf('\\', fromIndex)
-}
+/***/ }),
+/* 238 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
-var _escape$2 = escape;
-escape.locator = _escape;
+var locate = __webpack_require__(239)
-var lineFeed$15 = '\n';
-var backslash$4 = '\\';
+module.exports = escape
+escape.locator = locate
+
+var lineFeed = '\n'
+var backslash = '\\'
function escape(eat, value, silent) {
- var self = this;
- var character;
- var node;
+ var self = this
+ var character
+ var node
- if (value.charAt(0) === backslash$4) {
- character = value.charAt(1);
+ if (value.charAt(0) === backslash) {
+ character = value.charAt(1)
if (self.escape.indexOf(character) !== -1) {
/* istanbul ignore if - never used (yet) */
@@ -26178,107 +31190,127 @@ function escape(eat, value, silent) {
return true
}
- if (character === lineFeed$15) {
- node = {type: 'break'};
+ if (character === lineFeed) {
+ node = {type: 'break'}
} else {
- node = {type: 'text', value: character};
+ node = {type: 'text', value: character}
}
- return eat(backslash$4 + character)(node)
+ return eat(backslash + character)(node)
}
}
}
-var tag$1 = locate$2;
-function locate$2(value, fromIndex) {
- return value.indexOf('<', fromIndex)
+/***/ }),
+/* 239 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+module.exports = locate
+
+function locate(value, fromIndex) {
+ return value.indexOf('\\', fromIndex)
}
-var autoLink_1 = autoLink;
-autoLink.locator = tag$1;
-autoLink.notInLink = true;
-var lessThan$2 = '<';
-var greaterThan$2 = '>';
-var atSign = '@';
-var slash = '/';
-var mailto = 'mailto:';
-var mailtoLength = mailto.length;
+/***/ }),
+/* 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$2) {
+ 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$2;
+ index++
+ subvalue = lessThan
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
if (
- isWhitespaceCharacter(character) ||
- character === greaterThan$2 ||
+ whitespace(character) ||
+ character === greaterThan ||
character === atSign ||
(character === ':' && value.charAt(index + 1) === slash)
) {
break
}
- queue += character;
- index++;
+ queue += character
+ index++
}
if (!queue) {
return
}
- link += queue;
- queue = '';
+ link += queue
+ queue = ''
- character = value.charAt(index);
- link += character;
- index++;
+ character = value.charAt(index)
+ link += character
+ index++
if (character === atSign) {
- hasAtCharacter = true;
+ hasAtCharacter = true
} else {
if (character !== ':' || value.charAt(index + 1) !== slash) {
return
}
- link += slash;
- index++;
+ link += slash
+ index++
}
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
- if (isWhitespaceCharacter(character) || character === greaterThan$2) {
+ if (whitespace(character) || character === greaterThan) {
break
}
- queue += character;
- index++;
+ queue += character
+ index++
}
- character = value.charAt(index);
+ character = value.charAt(index)
- if (!queue || character !== greaterThan$2) {
+ if (!queue || character !== greaterThan) {
return
}
@@ -26287,121 +31319,108 @@ function autoLink(eat, value, silent) {
return true
}
- link += queue;
- content = link;
- subvalue += link + character;
- now = eat.now();
- now.column++;
- now.offset++;
+ 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;
+ content = content.substr(mailtoLength)
+ now.column += mailtoLength
+ now.offset += mailtoLength
} else {
- link = mailto + link;
+ link = mailto + link
}
}
// Temporarily remove all tokenizers except text in autolinks.
- tokenizers = self.inlineTokenizers;
- self.inlineTokenizers = {text: tokenizers.text};
+ tokenizers = self.inlineTokenizers
+ self.inlineTokenizers = {text: tokenizers.text}
- exit = self.enterLink();
+ exit = self.enterLink()
- content = self.tokenizeInline(content, now);
+ content = self.tokenizeInline(content, now)
- self.inlineTokenizers = tokenizers;
- exit();
+ self.inlineTokenizers = tokenizers
+ exit()
return eat(subvalue)({
type: 'link',
title: null,
- url: parseEntities_1(link, {nonTerminated: false}),
+ url: decode(link, {nonTerminated: false}),
children: content
})
}
-var url = locate$4;
-
-var protocols = ['https://', 'http://', 'mailto:'];
-function locate$4(value, fromIndex) {
- var length = protocols.length;
- var index = -1;
- var min = -1;
- var position;
-
- if (!this.options.gfm) {
- return -1
- }
+/***/ }),
+/* 241 */
+/***/ (function(module, exports, __webpack_require__) {
- while (++index < length) {
- position = value.indexOf(protocols[index], fromIndex);
+"use strict";
- if (position !== -1 && (position < min || min === -1)) {
- min = position;
- }
- }
- return min
-}
+var decode = __webpack_require__(30)
+var whitespace = __webpack_require__(8)
+var locate = __webpack_require__(242)
-var url_1 = url$2;
-url$2.locator = url;
-url$2.notInLink = true;
+module.exports = url
+url.locator = locate
+url.notInLink = true
-var quotationMark$1 = '"';
-var apostrophe$1 = "'";
-var leftParenthesis$1 = '(';
-var rightParenthesis$2 = ')';
-var comma$1 = ',';
-var dot$2 = '.';
-var colon$4 = ':';
-var semicolon = ';';
-var lessThan$3 = '<';
-var atSign$1 = '@';
-var leftSquareBracket$2 = '[';
-var rightSquareBracket$2 = ']';
+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$1 = 'mailto:';
+var http = 'http://'
+var https = 'https://'
+var mailto = 'mailto:'
-var protocols$1 = [http, https, mailto$1];
+var protocols = [http, https, mailto]
-var protocolsLength = protocols$1.length;
+var protocolsLength = protocols.length
-function url$2(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;
+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;
+ subvalue = ''
+ index = -1
while (++index < protocolsLength) {
- protocol = protocols$1[index];
- match = value.slice(0, protocol.length);
+ protocol = protocols[index]
+ match = value.slice(0, protocol.length)
if (match.toLowerCase() === protocol) {
- subvalue = match;
+ subvalue = match
break
}
}
@@ -26410,66 +31429,66 @@ function url$2(eat, value, silent) {
return
}
- index = subvalue.length;
- length = value.length;
- queue = '';
- parenCount = 0;
+ index = subvalue.length
+ length = value.length
+ queue = ''
+ parenCount = 0
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
- if (isWhitespaceCharacter(character) || character === lessThan$3) {
+ if (whitespace(character) || character === lessThan) {
break
}
if (
- character === dot$2 ||
- character === comma$1 ||
- character === colon$4 ||
+ character === dot ||
+ character === comma ||
+ character === colon ||
character === semicolon ||
- character === quotationMark$1 ||
- character === apostrophe$1 ||
- character === rightParenthesis$2 ||
- character === rightSquareBracket$2
+ character === quotationMark ||
+ character === apostrophe ||
+ character === rightParenthesis ||
+ character === rightSquareBracket
) {
- nextCharacter = value.charAt(index + 1);
+ nextCharacter = value.charAt(index + 1)
- if (!nextCharacter || isWhitespaceCharacter(nextCharacter)) {
+ if (!nextCharacter || whitespace(nextCharacter)) {
break
}
}
- if (character === leftParenthesis$1 || character === leftSquareBracket$2) {
- parenCount++;
+ if (character === leftParenthesis || character === leftSquareBracket) {
+ parenCount++
}
- if (character === rightParenthesis$2 || character === rightSquareBracket$2) {
- parenCount--;
+ if (character === rightParenthesis || character === rightSquareBracket) {
+ parenCount--
if (parenCount < 0) {
break
}
}
- queue += character;
- index++;
+ queue += character
+ index++
}
if (!queue) {
return
}
- subvalue += queue;
- content = subvalue;
+ subvalue += queue
+ content = subvalue
- if (protocol === mailto$1) {
- position = queue.indexOf(atSign$1);
+ if (protocol === mailto) {
+ position = queue.indexOf(atSign)
if (position === -1 || position === length - 1) {
return
}
- content = content.substr(mailto$1.length);
+ content = content.substr(mailto.length)
}
/* istanbul ignore if - never used (yet) */
@@ -26477,60 +31496,103 @@ function url$2(eat, value, silent) {
return true
}
- exit = self.enterLink();
+ exit = self.enterLink()
// Temporarily remove all tokenizers except text in url.
- tokenizers = self.inlineTokenizers;
- self.inlineTokenizers = {text: tokenizers.text};
+ tokenizers = self.inlineTokenizers
+ self.inlineTokenizers = {text: tokenizers.text}
- content = self.tokenizeInline(content, eat.now());
+ content = self.tokenizeInline(content, eat.now())
- self.inlineTokenizers = tokenizers;
- exit();
+ self.inlineTokenizers = tokenizers
+ exit()
return eat(subvalue)({
type: 'link',
title: null,
- url: parseEntities_1(subvalue, {nonTerminated: false}),
+ url: decode(subvalue, {nonTerminated: false}),
children: content
})
}
-var tag$3 = html.tag;
-var htmlInline = inlineHTML;
-inlineHTML.locator = tag$1;
+/***/ }),
+/* 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
+ }
-var lessThan$4 = '<';
-var questionMark = '?';
-var exclamationMark$1 = '!';
-var slash$1 = '/';
+ while (++index < length) {
+ position = value.indexOf(protocols[index], fromIndex)
-var htmlLinkOpenExpression = /^<a /i;
-var htmlLinkCloseExpression = /^<\/a>/i;
+ 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 = /^<a /i
+var htmlLinkCloseExpression = /^<\/a>/i
function inlineHTML(eat, value, silent) {
- var self = this;
- var length = value.length;
- var character;
- var subvalue;
+ var self = this
+ var length = value.length
+ var character
+ var subvalue
- if (value.charAt(0) !== lessThan$4 || length < 3) {
+ if (value.charAt(0) !== lessThan || length < 3) {
return
}
- character = value.charAt(1);
+ character = value.charAt(1)
if (
- !isAlphabetical(character) &&
+ !alphabetical(character) &&
character !== questionMark &&
- character !== exclamationMark$1 &&
- character !== slash$1
+ character !== exclamationMark &&
+ character !== slash
) {
return
}
- subvalue = value.match(tag$3);
+ subvalue = value.match(tag)
if (!subvalue) {
return
@@ -26541,84 +31603,80 @@ function inlineHTML(eat, value, silent) {
return true
}
- subvalue = subvalue[0];
+ subvalue = subvalue[0]
if (!self.inLink && htmlLinkOpenExpression.test(subvalue)) {
- self.inLink = true;
+ self.inLink = true
} else if (self.inLink && htmlLinkCloseExpression.test(subvalue)) {
- self.inLink = false;
+ self.inLink = false
}
return eat(subvalue)({type: 'html', value: subvalue})
}
-var link = locate$6;
-
-function locate$6(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
-}
-
-var link_1 = link$2;
-link$2.locator = link;
-var lineFeed$16 = '\n';
-var exclamationMark$2 = '!';
-var quotationMark$2 = '"';
-var apostrophe$2 = "'";
-var leftParenthesis$2 = '(';
-var rightParenthesis$3 = ')';
-var lessThan$5 = '<';
-var greaterThan$3 = '>';
-var leftSquareBracket$3 = '[';
-var backslash$5 = '\\';
-var rightSquareBracket$3 = ']';
-var graveAccent$2 = '`';
-
-function link$2(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;
+/***/ }),
+/* 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$2) {
- isImage = true;
- subvalue = character;
- character = value.charAt(++index);
+ if (character === exclamationMark) {
+ isImage = true
+ subvalue = character
+ character = value.charAt(++index)
}
// Eat the opening.
- if (character !== leftSquareBracket$3) {
+ if (character !== leftSquareBracket) {
return
}
@@ -26627,78 +31685,78 @@ function link$2(eat, value, silent) {
return
}
- subvalue += character;
- queue = '';
- index++;
+ subvalue += character
+ queue = ''
+ index++
// Eat the content.
- length = value.length;
- now = eat.now();
- depth = 0;
+ length = value.length
+ now = eat.now()
+ depth = 0
- now.column += index;
- now.offset += index;
+ now.column += index
+ now.offset += index
while (index < length) {
- character = value.charAt(index);
- subqueue = character;
+ character = value.charAt(index)
+ subqueue = character
- if (character === graveAccent$2) {
+ if (character === graveAccent) {
// Inline-code in link content.
- count = 1;
+ count = 1
- while (value.charAt(index + 1) === graveAccent$2) {
- subqueue += character;
- index++;
- count++;
+ while (value.charAt(index + 1) === graveAccent) {
+ subqueue += character
+ index++
+ count++
}
if (!opening) {
- opening = count;
+ opening = count
} else if (count >= opening) {
- opening = 0;
+ opening = 0
}
- } else if (character === backslash$5) {
+ } else if (character === backslash) {
// Allow brackets to be escaped.
- index++;
- subqueue += value.charAt(index);
- } else if ((!opening || gfm) && character === leftSquareBracket$3) {
+ 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$3) {
+ depth++
+ } else if ((!opening || gfm) && character === rightSquareBracket) {
if (depth) {
- depth--;
+ depth--
} else {
// Allow white-space between content and url in GFM mode.
if (!pedantic) {
while (index < length) {
- character = value.charAt(index + 1);
+ character = value.charAt(index + 1)
- if (!isWhitespaceCharacter(character)) {
+ if (!whitespace(character)) {
break
}
- subqueue += character;
- index++;
+ subqueue += character
+ index++
}
}
- if (value.charAt(index + 1) !== leftParenthesis$2) {
+ if (value.charAt(index + 1) !== leftParenthesis) {
return
}
- subqueue += leftParenthesis$2;
- closed = true;
- index++;
+ subqueue += leftParenthesis
+ closed = true
+ index++
break
}
}
- queue += subqueue;
- subqueue = '';
- index++;
+ queue += subqueue
+ subqueue = ''
+ index++
}
// Eat the content closing.
@@ -26706,208 +31764,208 @@ function link$2(eat, value, silent) {
return
}
- content = queue;
- subvalue += queue + subqueue;
- index++;
+ content = queue
+ subvalue += queue + subqueue
+ index++
// Eat white-space.
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
- if (!isWhitespaceCharacter(character)) {
+ if (!whitespace(character)) {
break
}
- subvalue += character;
- index++;
+ subvalue += character
+ index++
}
// Eat the URL.
- character = value.charAt(index);
- queue = '';
- beforeURL = subvalue;
+ character = value.charAt(index)
+ queue = ''
+ beforeURL = subvalue
- if (character === lessThan$5) {
- index++;
- beforeURL += lessThan$5;
+ if (character === lessThan) {
+ index++
+ beforeURL += lessThan
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
- if (character === greaterThan$3) {
+ if (character === greaterThan) {
break
}
- if (commonmark && character === lineFeed$16) {
+ if (commonmark && character === lineFeed) {
return
}
- queue += character;
- index++;
+ queue += character
+ index++
}
- if (value.charAt(index) !== greaterThan$3) {
+ if (value.charAt(index) !== greaterThan) {
return
}
- subvalue += lessThan$5 + queue + greaterThan$3;
- url = queue;
- index++;
+ subvalue += lessThan + queue + greaterThan
+ url = queue
+ index++
} else {
- character = null;
- subqueue = '';
+ character = null
+ subqueue = ''
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
if (
subqueue &&
- (character === quotationMark$2 ||
- character === apostrophe$2 ||
- (commonmark && character === leftParenthesis$2))
+ (character === quotationMark ||
+ character === apostrophe ||
+ (commonmark && character === leftParenthesis))
) {
break
}
- if (isWhitespaceCharacter(character)) {
+ if (whitespace(character)) {
if (!pedantic) {
break
}
- subqueue += character;
+ subqueue += character
} else {
- if (character === leftParenthesis$2) {
- depth++;
- } else if (character === rightParenthesis$3) {
+ if (character === leftParenthesis) {
+ depth++
+ } else if (character === rightParenthesis) {
if (depth === 0) {
break
}
- depth--;
+ depth--
}
- queue += subqueue;
- subqueue = '';
+ queue += subqueue
+ subqueue = ''
- if (character === backslash$5) {
- queue += backslash$5;
- character = value.charAt(++index);
+ if (character === backslash) {
+ queue += backslash
+ character = value.charAt(++index)
}
- queue += character;
+ queue += character
}
- index++;
+ index++
}
- subvalue += queue;
- url = queue;
- index = subvalue.length;
+ subvalue += queue
+ url = queue
+ index = subvalue.length
}
// Eat white-space.
- queue = '';
+ queue = ''
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
- if (!isWhitespaceCharacter(character)) {
+ if (!whitespace(character)) {
break
}
- queue += character;
- index++;
+ queue += character
+ index++
}
- character = value.charAt(index);
- subvalue += queue;
+ character = value.charAt(index)
+ subvalue += queue
// Eat the title.
if (
queue &&
- (character === quotationMark$2 ||
- character === apostrophe$2 ||
- (commonmark && character === leftParenthesis$2))
+ (character === quotationMark ||
+ character === apostrophe ||
+ (commonmark && character === leftParenthesis))
) {
- index++;
- subvalue += character;
- queue = '';
- marker = character === leftParenthesis$2 ? rightParenthesis$3 : character;
- beforeTitle = subvalue;
+ 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);
+ character = value.charAt(index)
if (character === marker) {
break
}
- if (character === backslash$5) {
- queue += backslash$5;
- character = value.charAt(++index);
+ if (character === backslash) {
+ queue += backslash
+ character = value.charAt(++index)
}
- index++;
- queue += character;
+ index++
+ queue += character
}
- character = value.charAt(index);
+ character = value.charAt(index)
if (character !== marker) {
return
}
- title = queue;
- subvalue += queue + character;
- index++;
+ title = queue
+ subvalue += queue + character
+ index++
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
- if (!isWhitespaceCharacter(character)) {
+ if (!whitespace(character)) {
break
}
- subvalue += character;
- index++;
+ subvalue += character
+ index++
}
} else {
- subqueue = '';
+ subqueue = ''
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
if (character === marker) {
if (hasMarker) {
- queue += marker + subqueue;
- subqueue = '';
+ queue += marker + subqueue
+ subqueue = ''
}
- hasMarker = true;
+ hasMarker = true
} else if (!hasMarker) {
- queue += character;
- } else if (character === rightParenthesis$3) {
- subvalue += queue + marker + subqueue;
- title = queue;
+ queue += character
+ } else if (character === rightParenthesis) {
+ subvalue += queue + marker + subqueue
+ title = queue
break
- } else if (isWhitespaceCharacter(character)) {
- subqueue += character;
+ } else if (whitespace(character)) {
+ subqueue += character
} else {
- queue += marker + subqueue + character;
- subqueue = '';
- hasMarker = false;
+ queue += marker + subqueue + character
+ subqueue = ''
+ hasMarker = false
}
- index++;
+ index++
}
}
}
- if (value.charAt(index) !== rightParenthesis$3) {
+ if (value.charAt(index) !== rightParenthesis) {
return
}
@@ -26916,193 +31974,205 @@ function link$2(eat, value, silent) {
return true
}
- subvalue += rightParenthesis$3;
+ 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);
+ 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;
+ node.alt = self.decode.raw(self.unescape(content), now) || null
} else {
- exit = self.enterLink();
- node.children = self.tokenizeInline(content, now);
- exit();
+ exit = self.enterLink()
+ node.children = self.tokenizeInline(content, now)
+ exit()
}
return eat(subvalue)(node)
}
-var reference_1 = reference;
-reference.locator = link;
-var link$3 = 'link';
-var image$1 = 'image';
-var footnote = 'footnote';
-var shortcut = 'shortcut';
-var collapsed = 'collapsed';
-var full = 'full';
-var space$14 = ' ';
-var exclamationMark$3 = '!';
-var leftSquareBracket$4 = '[';
-var backslash$6 = '\\';
-var rightSquareBracket$4 = ']';
-var caret$2 = '^';
+/***/ }),
+/* 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$3;
- var referenceType = shortcut;
- var content;
- var identifier;
- var now;
- var node;
- var exit;
- var queue;
- var bracketed;
- var depth;
+ 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$3) {
- type = image$1;
- intro = character;
- character = value.charAt(++index);
+ if (character === exclamationMark) {
+ type = image
+ intro = character
+ character = value.charAt(++index)
}
- if (character !== leftSquareBracket$4) {
+ if (character !== leftSquareBracket) {
return
}
- index++;
- intro += character;
- queue = '';
+ index++
+ intro += character
+ queue = ''
// Check whether we’re eating a footnote.
- if (self.options.footnotes && value.charAt(index) === caret$2) {
+ 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$1) {
+ if (type === image) {
return
}
- intro += caret$2;
- index++;
- type = footnote;
+ intro += caret
+ index++
+ type = footnote
}
// Eat the text.
- depth = 0;
+ depth = 0
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
- if (character === leftSquareBracket$4) {
- bracketed = true;
- depth++;
- } else if (character === rightSquareBracket$4) {
+ if (character === leftSquareBracket) {
+ bracketed = true
+ depth++
+ } else if (character === rightSquareBracket) {
if (!depth) {
break
}
- depth--;
+ depth--
}
- if (character === backslash$6) {
- queue += backslash$6;
- character = value.charAt(++index);
+ if (character === backslash) {
+ queue += backslash
+ character = value.charAt(++index)
}
- queue += character;
- index++;
+ queue += character
+ index++
}
- subvalue = queue;
- content = queue;
- character = value.charAt(index);
+ subvalue = queue
+ content = queue
+ character = value.charAt(index)
- if (character !== rightSquareBracket$4) {
+ if (character !== rightSquareBracket) {
return
}
- index++;
- subvalue += character;
- queue = '';
+ 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);
+ character = value.charAt(index)
- if (!isWhitespaceCharacter(character)) {
+ if (!whitespace(character)) {
break
}
- queue += character;
- index++;
+ queue += character
+ index++
}
}
- character = value.charAt(index);
+ character = value.charAt(index)
// Inline footnotes cannot have an identifier.
- if (type !== footnote && character === leftSquareBracket$4) {
- identifier = '';
- queue += character;
- index++;
+ if (type !== footnote && character === leftSquareBracket) {
+ identifier = ''
+ queue += character
+ index++
while (index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
- if (character === leftSquareBracket$4 || character === rightSquareBracket$4) {
+ if (character === leftSquareBracket || character === rightSquareBracket) {
break
}
- if (character === backslash$6) {
- identifier += backslash$6;
- character = value.charAt(++index);
+ if (character === backslash) {
+ identifier += backslash
+ character = value.charAt(++index)
}
- identifier += character;
- index++;
+ identifier += character
+ index++
}
- character = value.charAt(index);
+ character = value.charAt(index)
- if (character === rightSquareBracket$4) {
- referenceType = identifier ? full : collapsed;
- queue += identifier + character;
- index++;
+ if (character === rightSquareBracket) {
+ referenceType = identifier ? full : collapsed
+ queue += identifier + character
+ index++
} else {
- identifier = '';
+ identifier = ''
}
- subvalue += queue;
- queue = '';
+ subvalue += queue
+ queue = ''
} else {
if (!content) {
return
}
- identifier = content;
+ identifier = content
}
// Brackets cannot be inside the identifier.
@@ -27110,9 +32180,9 @@ function reference(eat, value, silent) {
return
}
- subvalue = intro + subvalue;
+ subvalue = intro + subvalue
- if (type === link$3 && self.inLink) {
+ if (type === link && self.inLink) {
return null
}
@@ -27121,107 +32191,102 @@ function reference(eat, value, silent) {
return true
}
- if (type === footnote && content.indexOf(space$14) !== -1) {
+ 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;
+ now = eat.now()
+ now.column += intro.length
+ now.offset += intro.length
+ identifier = referenceType === full ? identifier : content
node = {
type: type + 'Reference',
- identifier: normalize_1(identifier),
+ identifier: normalize(identifier),
label: identifier
- };
+ }
- if (type === link$3 || type === image$1) {
- node.referenceType = referenceType;
+ if (type === link || type === image) {
+ node.referenceType = referenceType
}
- if (type === link$3) {
- exit = self.enterLink();
- node.children = self.tokenizeInline(content, now);
- exit();
- } else if (type === image$1) {
- node.alt = self.decode.raw(self.unescape(content), now) || null;
+ 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)
}
-var strong = locate$8;
-function locate$8(value, fromIndex) {
- var asterisk = value.indexOf('**', fromIndex);
- var underscore = value.indexOf('__', fromIndex);
+/***/ }),
+/* 246 */
+/***/ (function(module, exports, __webpack_require__) {
- if (underscore === -1) {
- return asterisk
- }
+"use strict";
- if (asterisk === -1) {
- return underscore
- }
- return underscore < asterisk ? underscore : asterisk
-}
+var trim = __webpack_require__(14)
+var whitespace = __webpack_require__(8)
+var locate = __webpack_require__(247)
-var strong_1 = strong$2;
-strong$2.locator = strong;
+module.exports = strong
+strong.locator = locate
-var backslash$7 = '\\';
-var asterisk$2 = '*';
-var underscore$2 = '_';
+var backslash = '\\'
+var asterisk = '*'
+var underscore = '_'
-function strong$2(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;
+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$2 && character !== underscore$2) ||
+ (character !== asterisk && character !== underscore) ||
value.charAt(++index) !== character
) {
return
}
- pedantic = self.options.pedantic;
- marker = character;
- subvalue = marker + marker;
- length = value.length;
- index++;
- queue = '';
- character = '';
+ pedantic = self.options.pedantic
+ marker = character
+ subvalue = marker + marker
+ length = value.length
+ index++
+ queue = ''
+ character = ''
- if (pedantic && isWhitespaceCharacter(value.charAt(index))) {
+ if (pedantic && whitespace(value.charAt(index))) {
return
}
while (index < length) {
- prev = character;
- character = value.charAt(index);
+ prev = character
+ character = value.charAt(index)
if (
character === marker &&
value.charAt(index + 1) === marker &&
- (!pedantic || !isWhitespaceCharacter(prev))
+ (!pedantic || !whitespace(prev))
) {
- character = value.charAt(index + 2);
+ character = value.charAt(index + 2)
if (character !== marker) {
- if (!trim_1(queue)) {
+ if (!trim(queue)) {
return
}
@@ -27230,9 +32295,9 @@ function strong$2(eat, value, silent) {
return true
}
- now = eat.now();
- now.column += 2;
- now.offset += 2;
+ now = eat.now()
+ now.column += 2
+ now.offset += 2
return eat(subvalue + queue + subvalue)({
type: 'strong',
@@ -27241,34 +32306,29 @@ function strong$2(eat, value, silent) {
}
}
- if (!pedantic && character === backslash$7) {
- queue += character;
- character = value.charAt(++index);
+ if (!pedantic && character === backslash) {
+ queue += character
+ character = value.charAt(++index)
}
- queue += character;
- index++;
+ queue += character
+ index++
}
}
-var isWordCharacter = wordCharacter;
-var fromCode$1 = String.fromCharCode;
-var re$2 = /\w/;
+/***/ }),
+/* 247 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
-/* Check if the given character code, or the character
- * code at the first character, is a word character. */
-function wordCharacter(character) {
- return re$2.test(
- typeof character === 'number' ? fromCode$1(character) : character.charAt(0)
- )
-}
-var emphasis = locate$10;
+module.exports = locate
-function locate$10(value, fromIndex) {
- var asterisk = value.indexOf('*', fromIndex);
- var underscore = value.indexOf('_', fromIndex);
+function locate(value, fromIndex) {
+ var asterisk = value.indexOf('**', fromIndex)
+ var underscore = value.indexOf('__', fromIndex)
if (underscore === -1) {
return asterisk
@@ -27281,55 +32341,68 @@ function locate$10(value, fromIndex) {
return underscore < asterisk ? underscore : asterisk
}
-var emphasis_1 = emphasis$2;
-emphasis$2.locator = emphasis;
-var asterisk$3 = '*';
-var underscore$3 = '_';
-var backslash$8 = '\\';
+/***/ }),
+/* 248 */
+/***/ (function(module, exports, __webpack_require__) {
-function emphasis$2(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;
+"use strict";
+
+
+var trim = __webpack_require__(14)
+var word = __webpack_require__(249)
+var whitespace = __webpack_require__(8)
+var locate = __webpack_require__(250)
- if (character !== asterisk$3 && character !== underscore$3) {
+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 = '';
+ pedantic = self.options.pedantic
+ subvalue = character
+ marker = character
+ length = value.length
+ index++
+ queue = ''
+ character = ''
- if (pedantic && isWhitespaceCharacter(value.charAt(index))) {
+ if (pedantic && whitespace(value.charAt(index))) {
return
}
while (index < length) {
- prev = character;
- character = value.charAt(index);
+ prev = character
+ character = value.charAt(index)
- if (character === marker && (!pedantic || !isWhitespaceCharacter(prev))) {
- character = value.charAt(++index);
+ if (character === marker && (!pedantic || !whitespace(prev))) {
+ character = value.charAt(++index)
if (character !== marker) {
- if (!trim_1(queue) || prev === marker) {
+ if (!trim(queue) || prev === marker) {
return
}
- if (!pedantic && marker === underscore$3 && isWordCharacter(character)) {
- queue += marker;
+ if (!pedantic && marker === underscore && word(character)) {
+ queue += marker
continue
}
@@ -27338,9 +32411,9 @@ function emphasis$2(eat, value, silent) {
return true
}
- now = eat.now();
- now.column++;
- now.offset++;
+ now = eat.now()
+ now.column++
+ now.offset++
return eat(subvalue + queue + marker)({
type: 'emphasis',
@@ -27348,63 +32421,114 @@ function emphasis$2(eat, value, silent) {
})
}
- queue += marker;
+ queue += marker
}
- if (!pedantic && character === backslash$8) {
- queue += character;
- character = value.charAt(++index);
+ if (!pedantic && character === backslash) {
+ queue += character
+ character = value.charAt(++index)
}
- queue += character;
- index++;
+ queue += character
+ index++
}
}
-var _delete = locate$12;
-function locate$12(value, fromIndex) {
- return value.indexOf('~~', fromIndex)
+/***/ }),
+/* 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
}
-var _delete$2 = strikethrough;
-strikethrough.locator = _delete;
-var tilde$2 = '~';
-var fence = '~~';
+/***/ }),
+/* 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;
+ 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$2 ||
- value.charAt(1) !== tilde$2 ||
- isWhitespaceCharacter(value.charAt(2))
+ 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;
+ index = 1
+ length = value.length
+ now = eat.now()
+ now.column += 2
+ now.offset += 2
while (++index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
if (
- character === tilde$2 &&
- previous === tilde$2 &&
- (!preceding || !isWhitespaceCharacter(preceding))
+ character === tilde &&
+ previous === tilde &&
+ (!preceding || !whitespace(preceding))
) {
/* istanbul ignore if - never used (yet) */
if (silent) {
@@ -27417,80 +32541,99 @@ function strikethrough(eat, value, silent) {
})
}
- subvalue += previous;
- preceding = previous;
- previous = character;
+ subvalue += previous
+ preceding = previous
+ previous = character
}
}
-var codeInline = locate$14;
-function locate$14(value, fromIndex) {
- return value.indexOf('`', fromIndex)
+/***/ }),
+/* 252 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+module.exports = locate
+
+function locate(value, fromIndex) {
+ return value.indexOf('~~', fromIndex)
}
-var codeInline$2 = inlineCode;
-inlineCode.locator = codeInline;
-var graveAccent$3 = '`';
+/***/ }),
+/* 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;
+ 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$3) {
+ if (value.charAt(index) !== graveAccent) {
break
}
- queue += graveAccent$3;
- index++;
+ queue += graveAccent
+ index++
}
if (!queue) {
return
}
- subvalue = queue;
- openingCount = index;
- queue = '';
- next = value.charAt(index);
- count = 0;
+ subvalue = queue
+ openingCount = index
+ queue = ''
+ next = value.charAt(index)
+ count = 0
while (index < length) {
- character = next;
- next = value.charAt(index + 1);
+ character = next
+ next = value.charAt(index + 1)
- if (character === graveAccent$3) {
- count++;
- tickQueue += character;
+ if (character === graveAccent) {
+ count++
+ tickQueue += character
} else {
- count = 0;
- queue += character;
+ count = 0
+ queue += character
}
- if (count && next !== graveAccent$3) {
+ if (count && next !== graveAccent) {
if (count === openingCount) {
- subvalue += queue + tickQueue;
- found = true;
+ subvalue += queue + tickQueue
+ found = true
break
}
- queue += tickQueue;
- tickQueue = '';
+ queue += tickQueue
+ tickQueue = ''
}
- index++;
+ index++
}
if (!found) {
@@ -27498,7 +32641,7 @@ function inlineCode(eat, value, silent) {
return
}
- queue = '';
+ queue = ''
}
/* istanbul ignore if - never used (yet) */
@@ -27506,66 +32649,74 @@ function inlineCode(eat, value, silent) {
return true
}
- contentQueue = '';
- subqueue = '';
- length = queue.length;
- index = -1;
+ contentQueue = ''
+ subqueue = ''
+ length = queue.length
+ index = -1
while (++index < length) {
- character = queue.charAt(index);
+ character = queue.charAt(index)
- if (isWhitespaceCharacter(character)) {
- subqueue += character;
+ if (whitespace(character)) {
+ subqueue += character
continue
}
if (subqueue) {
if (contentQueue) {
- contentQueue += subqueue;
+ contentQueue += subqueue
}
- subqueue = '';
+ subqueue = ''
}
- contentQueue += character;
+ contentQueue += character
}
return eat(subvalue)({type: 'inlineCode', value: contentQueue})
}
-var _break = locate$16;
-function locate$16(value, fromIndex) {
- var index = value.indexOf('\n', fromIndex);
+/***/ }),
+/* 254 */
+/***/ (function(module, exports, __webpack_require__) {
- while (index > fromIndex) {
- if (value.charAt(index - 1) !== ' ') {
- break
- }
+"use strict";
- index--;
- }
- return index
+module.exports = locate
+
+function locate(value, fromIndex) {
+ return value.indexOf('`', fromIndex)
}
-var _break$2 = hardBreak;
-hardBreak.locator = _break;
-var space$15 = ' ';
-var lineFeed$17 = '\n';
-var minBreakLength = 2;
+/***/ }),
+/* 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;
+ var length = value.length
+ var index = -1
+ var queue = ''
+ var character
while (++index < length) {
- character = value.charAt(index);
+ character = value.charAt(index)
- if (character === lineFeed$17) {
+ if (character === lineFeed) {
if (index < minBreakLength) {
return
}
@@ -27575,235 +32726,213 @@ function hardBreak(eat, value, silent) {
return true
}
- queue += character;
+ queue += character
return eat(queue)({type: 'break'})
}
- if (character !== space$15) {
+ if (character !== space) {
return
}
- queue += character;
+ queue += character
}
}
-var text_1 = text;
+
+/***/ }),
+/* 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;
+ 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;
+ methods = self.inlineMethods
+ length = methods.length
+ tokenizers = self.inlineTokenizers
+ index = -1
+ min = value.length
while (++index < length) {
- name = methods[index];
+ name = methods[index]
if (name === 'text' || !tokenizers[name]) {
continue
}
- tokenizer = tokenizers[name].locator;
+ tokenizer = tokenizers[name].locator
if (!tokenizer) {
- eat.file.fail('Missing locator: `' + name + '`');
+ eat.file.fail('Missing locator: `' + name + '`')
}
- position = tokenizer.call(self, value, 1);
+ position = tokenizer.call(self, value, 1)
if (position !== -1 && position < min) {
- min = position;
+ min = position
}
}
- subvalue = value.slice(0, min);
- now = eat.now();
+ subvalue = value.slice(0, min)
+ now = eat.now()
- self.decode(subvalue, now, handler);
+ self.decode(subvalue, now, handler)
function handler(content, position, source) {
- eat(source || content)({type: 'text', value: content});
+ eat(source || content)({type: 'text', value: content})
}
}
-var parser = Parser;
-
-function Parser(doc, file) {
- this.file = file;
- this.offset = {};
- this.options = immutable(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$1(this);
-}
-
-var proto$5 = Parser.prototype;
-// Expose core.
-proto$5.setOptions = setOptions_1;
-proto$5.parse = parse_1$3;
+/***/ }),
+/* 258 */
+/***/ (function(module, exports, __webpack_require__) {
-// Expose `defaults`.
-proto$5.options = defaults$2;
+"use strict";
-// Enter and exit helpers.
-proto$5.exitStart = stateToggle('atStart', true);
-proto$5.enterList = stateToggle('inList', false);
-proto$5.enterLink = stateToggle('inLink', false);
-proto$5.enterBlock = stateToggle('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$5.interruptParagraph = [
- ['thematicBreak'],
- ['atxHeading'],
- ['fencedCode'],
- ['blockquote'],
- ['html'],
- ['setextHeading', {commonmark: false}],
- ['definition', {commonmark: false}],
- ['footnote', {commonmark: false}]
-];
+var unherit = __webpack_require__(75)
+var xtend = __webpack_require__(7)
+var Compiler = __webpack_require__(259)
-// Nodes that can interupt a list:
-//
-// ```markdown
-// - One
-// ___
-// ```
-//
-// In the above example, the thematic break “interupts” the list.
-proto$5.interruptList = [
- ['atxHeading', {pedantic: false}],
- ['fencedCode', {pedantic: false}],
- ['thematicBreak', {pedantic: false}],
- ['definition', {commonmark: false}],
- ['footnote', {commonmark: false}]
-];
+module.exports = stringify
+stringify.Compiler = Compiler
-// Nodes that can interupt a blockquote:
-//
-// ```markdown
-// > A paragraph.
-// ___
-// ```
-//
-// In the above example, the thematic break “interupts” the blockquote.
-proto$5.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}]
-];
+function stringify(options) {
+ var Local = unherit(Compiler)
+ Local.prototype.options = xtend(
+ Local.prototype.options,
+ this.data('settings'),
+ options
+ )
+ this.Compiler = Local
+}
-// Handlers.
-proto$5.blockTokenizers = {
- newline: newline_1,
- indentedCode: codeIndented,
- fencedCode: codeFenced,
- blockquote: blockquote_1,
- atxHeading: headingAtx,
- thematicBreak: thematicBreak_1,
- list: list_1,
- setextHeading: headingSetext,
- html: htmlBlock,
- footnote: footnoteDefinition_1,
- definition: definition_1,
- table: table_1,
- paragraph: paragraph_1
-};
-proto$5.inlineTokenizers = {
- escape: _escape$2,
- autoLink: autoLink_1,
- url: url_1,
- html: htmlInline,
- link: link_1,
- reference: reference_1,
- strong: strong_1,
- emphasis: emphasis_1,
- deletion: _delete$2,
- code: codeInline$2,
- break: _break$2,
- text: text_1
-};
+/***/ }),
+/* 259 */
+/***/ (function(module, exports, __webpack_require__) {
-// Expose precedence.
-proto$5.blockMethods = keys$1(proto$5.blockTokenizers);
-proto$5.inlineMethods = keys$1(proto$5.inlineTokenizers);
+"use strict";
-// Tokenizers.
-proto$5.tokenizeBlock = tokenizer('block');
-proto$5.tokenizeInline = tokenizer('inline');
-proto$5.tokenizeFactory = tokenizer;
-// Get all keys in `value`.
-function keys$1(value) {
- var result = [];
- var key;
+var xtend = __webpack_require__(7)
+var toggle = __webpack_require__(76)
- for (key in value) {
- result.push(key);
- }
+module.exports = Compiler
- return result
+// 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 remarkParse = parse$9;
-parse$9.Parser = parser;
-
-function parse$9(options) {
- var settings = this.data('settings');
- var Local = unherit_1(parser);
-
- Local.prototype.options = immutable(Local.prototype.options, settings, options);
+var proto = Compiler.prototype
- this.Parser = Local;
-}
+// Enter and exit helpers. */
+proto.enterLink = toggle('inLink', false)
+proto.enterTable = toggle('inTable', false)
+proto.enterLinkReference = __webpack_require__(260)
-var identity_1 = identity$1;
+// Configuration.
+proto.options = __webpack_require__(88)
+proto.setOptions = __webpack_require__(261)
-function identity$1(value) {
- return value
-}
+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)
-var enterLinkReference = enter;
+// 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).
@@ -27813,869 +32942,240 @@ var enterLinkReference = enter;
//
// Implies `enterLink`.
function enter(compiler, node) {
- var encode = compiler.encode;
- var escape = compiler.escape;
- var exitLink = compiler.enterLink();
+ var encode = compiler.encode
+ var escape = compiler.escape
+ var exitLink = compiler.enterLink()
if (node.referenceType !== 'shortcut' && node.referenceType !== 'collapsed') {
return exitLink
}
- compiler.escape = identity_1;
- compiler.encode = identity_1;
+ compiler.escape = identity
+ compiler.encode = identity
return exit
function exit() {
- compiler.encode = encode;
- compiler.escape = escape;
- exitLink();
+ compiler.encode = encode
+ compiler.escape = escape
+ exitLink()
}
}
-var defaults$5 = {
- 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
+/***/ }),
+/* 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}
}
-const nbsp$2 = " ";
-const iexcl$2 = "¡";
-const cent$2 = "¢";
-const pound$2 = "£";
-const curren$2 = "¤";
-const yen$2 = "¥";
-const brvbar$2 = "¦";
-const sect$2 = "§";
-const uml$2 = "¨";
-const copy$4 = "©";
-const ordf$2 = "ª";
-const laquo$2 = "«";
-const not$2 = "¬";
-const shy$2 = "­";
-const reg$2 = "®";
-const macr$2 = "¯";
-const deg$2 = "°";
-const plusmn$2 = "±";
-const sup2$2 = "²";
-const sup3$2 = "³";
-const acute$2 = "´";
-const micro$2 = "µ";
-const para$2 = "¶";
-const middot$2 = "·";
-const cedil$2 = "¸";
-const sup1$2 = "¹";
-const ordm$2 = "º";
-const raquo$2 = "»";
-const frac14$2 = "¼";
-const frac12$2 = "½";
-const frac34$2 = "¾";
-const iquest$2 = "¿";
-const Agrave$2 = "À";
-const Aacute$2 = "Á";
-const Acirc$2 = "Â";
-const Atilde$2 = "Ã";
-const Auml$2 = "Ä";
-const Aring$2 = "Å";
-const AElig$2 = "Æ";
-const Ccedil$2 = "Ç";
-const Egrave$2 = "È";
-const Eacute$2 = "É";
-const Ecirc$2 = "Ê";
-const Euml$2 = "Ë";
-const Igrave$2 = "Ì";
-const Iacute$2 = "Í";
-const Icirc$2 = "Î";
-const Iuml$2 = "Ï";
-const ETH$2 = "Ð";
-const Ntilde$2 = "Ñ";
-const Ograve$2 = "Ò";
-const Oacute$2 = "Ó";
-const Ocirc$2 = "Ô";
-const Otilde$2 = "Õ";
-const Ouml$2 = "Ö";
-const times$2 = "×";
-const Oslash$2 = "Ø";
-const Ugrave$2 = "Ù";
-const Uacute$2 = "Ú";
-const Ucirc$2 = "Û";
-const Uuml$2 = "Ü";
-const Yacute$2 = "Ý";
-const THORN$2 = "Þ";
-const szlig$2 = "ß";
-const agrave$2 = "à";
-const aacute$2 = "á";
-const acirc$2 = "â";
-const atilde$2 = "ã";
-const auml$2 = "ä";
-const aring$2 = "å";
-const aelig$2 = "æ";
-const ccedil$2 = "ç";
-const egrave$2 = "è";
-const eacute$2 = "é";
-const ecirc$2 = "ê";
-const euml$2 = "ë";
-const igrave$2 = "ì";
-const iacute$2 = "í";
-const icirc$2 = "î";
-const iuml$2 = "ï";
-const eth$2 = "ð";
-const ntilde$2 = "ñ";
-const ograve$2 = "ò";
-const oacute$2 = "ó";
-const ocirc$2 = "ô";
-const otilde$2 = "õ";
-const ouml$2 = "ö";
-const divide$2 = "÷";
-const oslash$2 = "ø";
-const ugrave$2 = "ù";
-const uacute$2 = "ú";
-const ucirc$2 = "û";
-const uuml$2 = "ü";
-const yacute$2 = "ý";
-const thorn$2 = "þ";
-const yuml$2 = "ÿ";
-const fnof$1 = "ƒ";
-const Alpha$1 = "Α";
-const Beta$1 = "Β";
-const Gamma$1 = "Γ";
-const Delta$1 = "Δ";
-const Epsilon$1 = "Ε";
-const Zeta$1 = "Ζ";
-const Eta$1 = "Η";
-const Theta$1 = "Θ";
-const Iota$1 = "Ι";
-const Kappa$1 = "Κ";
-const Lambda$1 = "Λ";
-const Mu$1 = "Μ";
-const Nu$1 = "Ν";
-const Xi$1 = "Ξ";
-const Omicron$1 = "Ο";
-const Pi$1 = "Π";
-const Rho$1 = "Ρ";
-const Sigma$1 = "Σ";
-const Tau$1 = "Τ";
-const Upsilon$1 = "Υ";
-const Phi$1 = "Φ";
-const Chi$1 = "Χ";
-const Psi$1 = "Ψ";
-const Omega$1 = "Ω";
-const alpha$1 = "α";
-const beta$1 = "β";
-const gamma$1 = "γ";
-const delta$1 = "δ";
-const epsilon$1 = "ε";
-const zeta$1 = "ζ";
-const eta$1 = "η";
-const theta$1 = "θ";
-const iota$1 = "ι";
-const kappa$1 = "κ";
-const lambda$1 = "λ";
-const mu$1 = "μ";
-const nu$1 = "ν";
-const xi$1 = "ξ";
-const omicron$1 = "ο";
-const pi$1 = "π";
-const rho$1 = "ρ";
-const sigmaf$1 = "ς";
-const sigma$1 = "σ";
-const tau$1 = "τ";
-const upsilon$1 = "υ";
-const phi$1 = "φ";
-const chi$1 = "χ";
-const psi$1 = "ψ";
-const omega$1 = "ω";
-const thetasym$1 = "ϑ";
-const upsih$1 = "ϒ";
-const piv$1 = "ϖ";
-const bull$1 = "•";
-const hellip$1 = "…";
-const prime$1 = "′";
-const Prime$1 = "″";
-const oline$1 = "‾";
-const frasl$1 = "⁄";
-const weierp$1 = "℘";
-const image$2 = "ℑ";
-const real$1 = "ℜ";
-const trade$1 = "™";
-const alefsym$1 = "ℵ";
-const larr$1 = "←";
-const uarr$1 = "↑";
-const rarr$1 = "→";
-const darr$1 = "↓";
-const harr$1 = "↔";
-const crarr$1 = "↵";
-const lArr$1 = "⇐";
-const uArr$1 = "⇑";
-const rArr$1 = "⇒";
-const dArr$1 = "⇓";
-const hArr$1 = "⇔";
-const forall$1 = "∀";
-const part$1 = "∂";
-const exist$1 = "∃";
-const empty$1 = "∅";
-const nabla$1 = "∇";
-const isin$1 = "∈";
-const notin$1 = "∉";
-const ni$1 = "∋";
-const prod$1 = "∏";
-const sum$1 = "∑";
-const minus$1 = "−";
-const lowast$1 = "∗";
-const radic$1 = "√";
-const prop$1 = "∝";
-const infin$1 = "∞";
-const ang$1 = "∠";
-const and$1 = "∧";
-const or$1 = "∨";
-const cap$1 = "∩";
-const cup$1 = "∪";
-const int$1 = "∫";
-const there4$1 = "∴";
-const sim$1 = "∼";
-const cong$1 = "≅";
-const asymp$1 = "≈";
-const ne$1 = "≠";
-const equiv$1 = "≡";
-const le$1 = "≤";
-const ge$1 = "≥";
-const sub$1 = "⊂";
-const sup$1 = "⊃";
-const nsub$1 = "⊄";
-const sube$1 = "⊆";
-const supe$1 = "⊇";
-const oplus$1 = "⊕";
-const otimes$1 = "⊗";
-const perp$1 = "⊥";
-const sdot$1 = "⋅";
-const lceil$1 = "⌈";
-const rceil$1 = "⌉";
-const lfloor$1 = "⌊";
-const rfloor$1 = "⌋";
-const lang$1 = "〈";
-const rang$1 = "〉";
-const loz$1 = "◊";
-const spades$1 = "♠";
-const clubs$1 = "♣";
-const hearts$1 = "♥";
-const diams$1 = "♦";
-const quot$2 = "\"";
-const amp$2 = "&";
-const lt$2 = "<";
-const gt$2 = ">";
-const OElig$1 = "Œ";
-const oelig$1 = "œ";
-const Scaron$1 = "Š";
-const scaron$1 = "š";
-const Yuml$1 = "Ÿ";
-const circ$1 = "ˆ";
-const tilde$3 = "˜";
-const ensp$1 = " ";
-const emsp$1 = " ";
-const thinsp$1 = " ";
-const zwnj$1 = "‌";
-const zwj$1 = "‍";
-const lrm$1 = "‎";
-const rlm$1 = "‏";
-const ndash$1 = "–";
-const mdash$1 = "—";
-const lsquo$1 = "‘";
-const rsquo$1 = "’";
-const sbquo$1 = "‚";
-const ldquo$1 = "“";
-const rdquo$1 = "”";
-const bdquo$1 = "„";
-const dagger$1 = "†";
-const Dagger$1 = "‡";
-const permil$1 = "‰";
-const lsaquo$1 = "‹";
-const rsaquo$1 = "›";
-const euro$1 = "€";
-var index$5 = {
- nbsp: nbsp$2,
- iexcl: iexcl$2,
- cent: cent$2,
- pound: pound$2,
- curren: curren$2,
- yen: yen$2,
- brvbar: brvbar$2,
- sect: sect$2,
- uml: uml$2,
- copy: copy$4,
- ordf: ordf$2,
- laquo: laquo$2,
- not: not$2,
- shy: shy$2,
- reg: reg$2,
- macr: macr$2,
- deg: deg$2,
- plusmn: plusmn$2,
- sup2: sup2$2,
- sup3: sup3$2,
- acute: acute$2,
- micro: micro$2,
- para: para$2,
- middot: middot$2,
- cedil: cedil$2,
- sup1: sup1$2,
- ordm: ordm$2,
- raquo: raquo$2,
- frac14: frac14$2,
- frac12: frac12$2,
- frac34: frac34$2,
- iquest: iquest$2,
- Agrave: Agrave$2,
- Aacute: Aacute$2,
- Acirc: Acirc$2,
- Atilde: Atilde$2,
- Auml: Auml$2,
- Aring: Aring$2,
- AElig: AElig$2,
- Ccedil: Ccedil$2,
- Egrave: Egrave$2,
- Eacute: Eacute$2,
- Ecirc: Ecirc$2,
- Euml: Euml$2,
- Igrave: Igrave$2,
- Iacute: Iacute$2,
- Icirc: Icirc$2,
- Iuml: Iuml$2,
- ETH: ETH$2,
- Ntilde: Ntilde$2,
- Ograve: Ograve$2,
- Oacute: Oacute$2,
- Ocirc: Ocirc$2,
- Otilde: Otilde$2,
- Ouml: Ouml$2,
- times: times$2,
- Oslash: Oslash$2,
- Ugrave: Ugrave$2,
- Uacute: Uacute$2,
- Ucirc: Ucirc$2,
- Uuml: Uuml$2,
- Yacute: Yacute$2,
- THORN: THORN$2,
- szlig: szlig$2,
- agrave: agrave$2,
- aacute: aacute$2,
- acirc: acirc$2,
- atilde: atilde$2,
- auml: auml$2,
- aring: aring$2,
- aelig: aelig$2,
- ccedil: ccedil$2,
- egrave: egrave$2,
- eacute: eacute$2,
- ecirc: ecirc$2,
- euml: euml$2,
- igrave: igrave$2,
- iacute: iacute$2,
- icirc: icirc$2,
- iuml: iuml$2,
- eth: eth$2,
- ntilde: ntilde$2,
- ograve: ograve$2,
- oacute: oacute$2,
- ocirc: ocirc$2,
- otilde: otilde$2,
- ouml: ouml$2,
- divide: divide$2,
- oslash: oslash$2,
- ugrave: ugrave$2,
- uacute: uacute$2,
- ucirc: ucirc$2,
- uuml: uuml$2,
- yacute: yacute$2,
- thorn: thorn$2,
- yuml: yuml$2,
- fnof: fnof$1,
- Alpha: Alpha$1,
- Beta: Beta$1,
- Gamma: Gamma$1,
- Delta: Delta$1,
- Epsilon: Epsilon$1,
- Zeta: Zeta$1,
- Eta: Eta$1,
- Theta: Theta$1,
- Iota: Iota$1,
- Kappa: Kappa$1,
- Lambda: Lambda$1,
- Mu: Mu$1,
- Nu: Nu$1,
- Xi: Xi$1,
- Omicron: Omicron$1,
- Pi: Pi$1,
- Rho: Rho$1,
- Sigma: Sigma$1,
- Tau: Tau$1,
- Upsilon: Upsilon$1,
- Phi: Phi$1,
- Chi: Chi$1,
- Psi: Psi$1,
- Omega: Omega$1,
- alpha: alpha$1,
- beta: beta$1,
- gamma: gamma$1,
- delta: delta$1,
- epsilon: epsilon$1,
- zeta: zeta$1,
- eta: eta$1,
- theta: theta$1,
- iota: iota$1,
- kappa: kappa$1,
- lambda: lambda$1,
- mu: mu$1,
- nu: nu$1,
- xi: xi$1,
- omicron: omicron$1,
- pi: pi$1,
- rho: rho$1,
- sigmaf: sigmaf$1,
- sigma: sigma$1,
- tau: tau$1,
- upsilon: upsilon$1,
- phi: phi$1,
- chi: chi$1,
- psi: psi$1,
- omega: omega$1,
- thetasym: thetasym$1,
- upsih: upsih$1,
- piv: piv$1,
- bull: bull$1,
- hellip: hellip$1,
- prime: prime$1,
- Prime: Prime$1,
- oline: oline$1,
- frasl: frasl$1,
- weierp: weierp$1,
- image: image$2,
- real: real$1,
- trade: trade$1,
- alefsym: alefsym$1,
- larr: larr$1,
- uarr: uarr$1,
- rarr: rarr$1,
- darr: darr$1,
- harr: harr$1,
- crarr: crarr$1,
- lArr: lArr$1,
- uArr: uArr$1,
- rArr: rArr$1,
- dArr: dArr$1,
- hArr: hArr$1,
- forall: forall$1,
- part: part$1,
- exist: exist$1,
- empty: empty$1,
- nabla: nabla$1,
- isin: isin$1,
- notin: notin$1,
- ni: ni$1,
- prod: prod$1,
- sum: sum$1,
- minus: minus$1,
- lowast: lowast$1,
- radic: radic$1,
- prop: prop$1,
- infin: infin$1,
- ang: ang$1,
- and: and$1,
- or: or$1,
- cap: cap$1,
- cup: cup$1,
- int: int$1,
- there4: there4$1,
- sim: sim$1,
- cong: cong$1,
- asymp: asymp$1,
- ne: ne$1,
- equiv: equiv$1,
- le: le$1,
- ge: ge$1,
- sub: sub$1,
- sup: sup$1,
- nsub: nsub$1,
- sube: sube$1,
- supe: supe$1,
- oplus: oplus$1,
- otimes: otimes$1,
- perp: perp$1,
- sdot: sdot$1,
- lceil: lceil$1,
- rceil: rceil$1,
- lfloor: lfloor$1,
- rfloor: rfloor$1,
- lang: lang$1,
- rang: rang$1,
- loz: loz$1,
- spades: spades$1,
- clubs: clubs$1,
- hearts: hearts$1,
- diams: diams$1,
- quot: quot$2,
- amp: amp$2,
- lt: lt$2,
- gt: gt$2,
- OElig: OElig$1,
- oelig: oelig$1,
- Scaron: Scaron$1,
- scaron: scaron$1,
- Yuml: Yuml$1,
- circ: circ$1,
- tilde: tilde$3,
- ensp: ensp$1,
- emsp: emsp$1,
- thinsp: thinsp$1,
- zwnj: zwnj$1,
- zwj: zwj$1,
- lrm: lrm$1,
- rlm: rlm$1,
- ndash: ndash$1,
- mdash: mdash$1,
- lsquo: lsquo$1,
- rsquo: rsquo$1,
- sbquo: sbquo$1,
- ldquo: ldquo$1,
- rdquo: rdquo$1,
- bdquo: bdquo$1,
- dagger: dagger$1,
- Dagger: Dagger$1,
- permil: permil$1,
- lsaquo: lsaquo$1,
- rsaquo: rsaquo$1,
- euro: euro$1
-};
+// Expose `validate`.
+var validate = {
+ boolean: validateBoolean,
+ string: validateString,
+ number: validateNumber,
+ function: validateFunction
+}
-var characterEntitiesHtml4 = Object.freeze({
- nbsp: nbsp$2,
- iexcl: iexcl$2,
- cent: cent$2,
- pound: pound$2,
- curren: curren$2,
- yen: yen$2,
- brvbar: brvbar$2,
- sect: sect$2,
- uml: uml$2,
- copy: copy$4,
- ordf: ordf$2,
- laquo: laquo$2,
- not: not$2,
- shy: shy$2,
- reg: reg$2,
- macr: macr$2,
- deg: deg$2,
- plusmn: plusmn$2,
- sup2: sup2$2,
- sup3: sup3$2,
- acute: acute$2,
- micro: micro$2,
- para: para$2,
- middot: middot$2,
- cedil: cedil$2,
- sup1: sup1$2,
- ordm: ordm$2,
- raquo: raquo$2,
- frac14: frac14$2,
- frac12: frac12$2,
- frac34: frac34$2,
- iquest: iquest$2,
- Agrave: Agrave$2,
- Aacute: Aacute$2,
- Acirc: Acirc$2,
- Atilde: Atilde$2,
- Auml: Auml$2,
- Aring: Aring$2,
- AElig: AElig$2,
- Ccedil: Ccedil$2,
- Egrave: Egrave$2,
- Eacute: Eacute$2,
- Ecirc: Ecirc$2,
- Euml: Euml$2,
- Igrave: Igrave$2,
- Iacute: Iacute$2,
- Icirc: Icirc$2,
- Iuml: Iuml$2,
- ETH: ETH$2,
- Ntilde: Ntilde$2,
- Ograve: Ograve$2,
- Oacute: Oacute$2,
- Ocirc: Ocirc$2,
- Otilde: Otilde$2,
- Ouml: Ouml$2,
- times: times$2,
- Oslash: Oslash$2,
- Ugrave: Ugrave$2,
- Uacute: Uacute$2,
- Ucirc: Ucirc$2,
- Uuml: Uuml$2,
- Yacute: Yacute$2,
- THORN: THORN$2,
- szlig: szlig$2,
- agrave: agrave$2,
- aacute: aacute$2,
- acirc: acirc$2,
- atilde: atilde$2,
- auml: auml$2,
- aring: aring$2,
- aelig: aelig$2,
- ccedil: ccedil$2,
- egrave: egrave$2,
- eacute: eacute$2,
- ecirc: ecirc$2,
- euml: euml$2,
- igrave: igrave$2,
- iacute: iacute$2,
- icirc: icirc$2,
- iuml: iuml$2,
- eth: eth$2,
- ntilde: ntilde$2,
- ograve: ograve$2,
- oacute: oacute$2,
- ocirc: ocirc$2,
- otilde: otilde$2,
- ouml: ouml$2,
- divide: divide$2,
- oslash: oslash$2,
- ugrave: ugrave$2,
- uacute: uacute$2,
- ucirc: ucirc$2,
- uuml: uuml$2,
- yacute: yacute$2,
- thorn: thorn$2,
- yuml: yuml$2,
- fnof: fnof$1,
- Alpha: Alpha$1,
- Beta: Beta$1,
- Gamma: Gamma$1,
- Delta: Delta$1,
- Epsilon: Epsilon$1,
- Zeta: Zeta$1,
- Eta: Eta$1,
- Theta: Theta$1,
- Iota: Iota$1,
- Kappa: Kappa$1,
- Lambda: Lambda$1,
- Mu: Mu$1,
- Nu: Nu$1,
- Xi: Xi$1,
- Omicron: Omicron$1,
- Pi: Pi$1,
- Rho: Rho$1,
- Sigma: Sigma$1,
- Tau: Tau$1,
- Upsilon: Upsilon$1,
- Phi: Phi$1,
- Chi: Chi$1,
- Psi: Psi$1,
- Omega: Omega$1,
- alpha: alpha$1,
- beta: beta$1,
- gamma: gamma$1,
- delta: delta$1,
- epsilon: epsilon$1,
- zeta: zeta$1,
- eta: eta$1,
- theta: theta$1,
- iota: iota$1,
- kappa: kappa$1,
- lambda: lambda$1,
- mu: mu$1,
- nu: nu$1,
- xi: xi$1,
- omicron: omicron$1,
- pi: pi$1,
- rho: rho$1,
- sigmaf: sigmaf$1,
- sigma: sigma$1,
- tau: tau$1,
- upsilon: upsilon$1,
- phi: phi$1,
- chi: chi$1,
- psi: psi$1,
- omega: omega$1,
- thetasym: thetasym$1,
- upsih: upsih$1,
- piv: piv$1,
- bull: bull$1,
- hellip: hellip$1,
- prime: prime$1,
- Prime: Prime$1,
- oline: oline$1,
- frasl: frasl$1,
- weierp: weierp$1,
- image: image$2,
- real: real$1,
- trade: trade$1,
- alefsym: alefsym$1,
- larr: larr$1,
- uarr: uarr$1,
- rarr: rarr$1,
- darr: darr$1,
- harr: harr$1,
- crarr: crarr$1,
- lArr: lArr$1,
- uArr: uArr$1,
- rArr: rArr$1,
- dArr: dArr$1,
- hArr: hArr$1,
- forall: forall$1,
- part: part$1,
- exist: exist$1,
- empty: empty$1,
- nabla: nabla$1,
- isin: isin$1,
- notin: notin$1,
- ni: ni$1,
- prod: prod$1,
- sum: sum$1,
- minus: minus$1,
- lowast: lowast$1,
- radic: radic$1,
- prop: prop$1,
- infin: infin$1,
- ang: ang$1,
- and: and$1,
- or: or$1,
- cap: cap$1,
- cup: cup$1,
- int: int$1,
- there4: there4$1,
- sim: sim$1,
- cong: cong$1,
- asymp: asymp$1,
- ne: ne$1,
- equiv: equiv$1,
- le: le$1,
- ge: ge$1,
- sub: sub$1,
- sup: sup$1,
- nsub: nsub$1,
- sube: sube$1,
- supe: supe$1,
- oplus: oplus$1,
- otimes: otimes$1,
- perp: perp$1,
- sdot: sdot$1,
- lceil: lceil$1,
- rceil: rceil$1,
- lfloor: lfloor$1,
- rfloor: rfloor$1,
- lang: lang$1,
- rang: rang$1,
- loz: loz$1,
- spades: spades$1,
- clubs: clubs$1,
- hearts: hearts$1,
- diams: diams$1,
- quot: quot$2,
- amp: amp$2,
- lt: lt$2,
- gt: gt$2,
- OElig: OElig$1,
- oelig: oelig$1,
- Scaron: Scaron$1,
- scaron: scaron$1,
- Yuml: Yuml$1,
- circ: circ$1,
- tilde: tilde$3,
- ensp: ensp$1,
- emsp: emsp$1,
- thinsp: thinsp$1,
- zwnj: zwnj$1,
- zwj: zwj$1,
- lrm: lrm$1,
- rlm: rlm$1,
- ndash: ndash$1,
- mdash: mdash$1,
- lsquo: lsquo$1,
- rsquo: rsquo$1,
- sbquo: sbquo$1,
- ldquo: ldquo$1,
- rdquo: rdquo$1,
- bdquo: bdquo$1,
- dagger: dagger$1,
- Dagger: Dagger$1,
- permil: permil$1,
- lsaquo: lsaquo$1,
- rsaquo: rsaquo$1,
- euro: euro$1,
- default: index$5
-});
+// Set options. Does not overwrite previously set options.
+function setOptions(options) {
+ var self = this
+ var current = self.options
+ var ruleRepetition
+ var key
-var dangerous = [
- "cent",
- "copy",
- "divide",
- "gt",
- "lt",
- "not",
- "para",
- "times"
-]
-;
+ if (options == null) {
+ options = {}
+ } else if (typeof options === 'object') {
+ options = xtend(options)
+ } else {
+ throw new Error('Invalid value `' + options + '` for setting `options`')
+ }
-var dangerous$1 = Object.freeze({
- default: dangerous
-});
+ 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__) {
-var entities = ( characterEntitiesHtml4 && index$5 ) || characterEntitiesHtml4;
+"use strict";
-var dangerous$2 = ( dangerous$1 && dangerous ) || dangerous$1;
+
+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. */
-var stringifyEntities = encode;
-encode.escape = escape$1;
+module.exports = encode
+encode.escape = escape
-var own$6 = {}.hasOwnProperty;
+var own = {}.hasOwnProperty
/* List of enforced escapes. */
-var escapes$2 = ['"', "'", '<', '>', '&', '`'];
+var escapes = ['"', "'", '<', '>', '&', '`']
/* Map of characters to names. */
-var characters = construct();
+var characters = construct()
/* Default escapes. */
-var defaultEscapes = toExpression(escapes$2);
+var defaultEscapes = toExpression(escapes)
/* Surrogate pairs. */
-var surrogatePair = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+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;
+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;
+ 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$1(char, val.charAt(pos + 1), settings)
- });
+ return one(char, val.charAt(pos + 1), settings)
+ })
if (subset || escapeOnly) {
return value
@@ -28697,12 +33197,12 @@ function encode(value, options) {
}
function replaceBmp(char, pos, val) {
- return one$1(char, val.charAt(pos + 1), settings)
+ return one(char, val.charAt(pos + 1), settings)
}
}
/* Shortcut to escape special characters in HTML. */
-function escape$1(value) {
+function escape(value) {
return encode(value, {
escapeOnly: true,
useNamedReferences: true
@@ -28710,18 +33210,18 @@ function escape$1(value) {
}
/* Encode `char` according to `options`. */
-function one$1(char, next, options) {
- var shortest = options.useShortestReferences;
- var omit = options.omitOptionalSemicolons;
- var named;
- var numeric;
+function one(char, next, options) {
+ var shortest = options.useShortestReferences
+ var omit = options.omitOptionalSemicolons
+ var named
+ var numeric
- if ((shortest || options.useNamedReferences) && own$6.call(characters, char)) {
- named = toNamed(characters[char], next, omit, options.attribute);
+ 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);
+ numeric = toHexReference(char.charCodeAt(0), next, omit)
}
if (named && (!shortest || named.length < numeric.length)) {
@@ -28733,13 +33233,13 @@ function one$1(char, next, options) {
/* Transform `code` into an entity. */
function toNamed(name, next, omit, attribute) {
- var value = '&' + name;
+ var value = '&' + name
if (
omit &&
- own$6.call(legacy, name) &&
- dangerous$2.indexOf(name) === -1 &&
- (!attribute || (next && next !== '=' && !isAlphanumerical(next)))
+ own.call(legacy, name) &&
+ dangerous.indexOf(name) === -1 &&
+ (!attribute || (next && next !== '=' && !alphanumerical(next)))
) {
return value
}
@@ -28749,8 +33249,8 @@ function toNamed(name, next, omit, attribute) {
/* Transform `code` into a hexadecimal character reference. */
function toHexReference(code, next, omit) {
- var value = '&#x' + code.toString(16).toUpperCase();
- return omit && next && !isHexadecimal(next) ? value : value + ';'
+ var value = '&#x' + code.toString(16).toUpperCase()
+ return omit && next && !hexadecimal(next) ? value : value + ';'
}
/* Create an expression for `characters`. */
@@ -28760,205 +33260,203 @@ function toExpression(characters) {
/* Construct the map. */
function construct() {
- var chars = {};
- var name;
+ var chars = {}
+ var name
for (name in entities) {
- chars[entities[name]] = name;
+ chars[entities[name]] = name
}
return chars
}
-var isAlphanumeric = function (str) {
- if (typeof str !== 'string') {
- throw new TypeError('Expected a string');
- }
- return !/[^0-9a-z\xDF-\xFF]/.test(str.toLowerCase());
-};
+/***/ }),
+/* 263 */
+/***/ (function(module) {
-var entityPrefixLength = length;
+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":"€"};
-var ampersand = '&';
+/***/ }),
+/* 264 */
+/***/ (function(module) {
-// 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;
+module.exports = ["cent","copy","divide","gt","lt","not","para","times"];
- /* 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
- }
+/***/ }),
+/* 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)
- prefix = value.split(ampersand, 2).join(ampersand);
-
- return prefix.length - parseEntities_1(prefix).length
-}
-
-var _escape$4 = factory$5;
-
-var tab$14 = '\t';
-var lineFeed$18 = '\n';
-var space$16 = ' ';
-var numberSign$1 = '#';
-var ampersand$1 = '&';
-var leftParenthesis$3 = '(';
-var rightParenthesis$4 = ')';
-var asterisk$4 = '*';
-var plusSign$1 = '+';
-var dash$5 = '-';
-var dot$3 = '.';
-var colon$5 = ':';
-var lessThan$6 = '<';
-var greaterThan$4 = '>';
-var leftSquareBracket$5 = '[';
-var backslash$9 = '\\';
-var rightSquareBracket$5 = ']';
-var underscore$4 = '_';
-var graveAccent$4 = '`';
-var verticalBar$1 = '|';
-var tilde$4 = '~';
-var exclamationMark$4 = '!';
-
-var entities$1 = {
+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 = {
'<': '&lt;',
':': '&#x3A;',
'&': '&amp;',
'|': '&#x7C;',
'~': '&#x7E;'
-};
+}
-var shortcut$1 = 'shortcut';
-var mailto$2 = 'mailto';
-var https$1 = 'https';
-var http$1 = 'http';
+var shortcut = 'shortcut'
+var mailto = 'mailto'
+var https = 'https'
+var http = 'http'
-var blankExpression = /\n\s*$/;
+var blankExpression = /\n\s*$/
// Factory to escape characters.
-function factory$5(options) {
+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$3, rightParenthesis$4] : [dot$3];
- 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 = markdownEscapes(options);
- var position = -1;
- var queue = [];
- var escaped = queue;
- var afterNewLine;
- var character;
- var wordCharBefore;
- var wordCharAfter;
- var offset;
- var replace;
+ 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$1(prev) && blankExpression.test(prev.value);
+ afterNewLine = text(prev) && blankExpression.test(prev.value)
} else {
afterNewLine =
- !parent || parent.type === 'root' || parent.type === 'paragraph';
+ !parent || parent.type === 'root' || parent.type === 'paragraph'
}
while (++position < length) {
- character = value.charAt(position);
- replace = false;
+ character = value.charAt(position)
+ replace = false
if (character === '\n') {
- afterNewLine = true;
+ afterNewLine = true
} else if (
- character === backslash$9 ||
- character === graveAccent$4 ||
- character === asterisk$4 ||
- (character === exclamationMark$4 &&
- value.charAt(position + 1) === leftSquareBracket$5) ||
- character === leftSquareBracket$5 ||
- character === lessThan$6 ||
- (character === ampersand$1 && entityPrefixLength(value.slice(position)) > 0) ||
- (character === rightSquareBracket$5 && self.inLink) ||
- (gfm && character === tilde$4 && value.charAt(position + 1) === tilde$4) ||
+ 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$1 &&
+ character === verticalBar &&
(self.inTable || alignment(value, position))) ||
- (character === underscore$4 &&
+ (character === underscore &&
// Delegate leading/trailing underscores to the multinode version below.
position > 0 &&
position < length - 1 &&
(pedantic ||
- !isAlphanumeric(value.charAt(position - 1)) ||
- !isAlphanumeric(value.charAt(position + 1)))) ||
- (gfm && !self.inLink && character === colon$5 && protocol(queue.join('')))
+ !alphanumeric(value.charAt(position - 1)) ||
+ !alphanumeric(value.charAt(position + 1)))) ||
+ (gfm && !self.inLink && character === colon && protocol(queue.join('')))
) {
- replace = true;
+ replace = true
} else if (afterNewLine) {
if (
- character === greaterThan$4 ||
- character === numberSign$1 ||
- character === asterisk$4 ||
- character === dash$5 ||
- character === plusSign$1
+ character === greaterThan ||
+ character === numberSign ||
+ character === asterisk ||
+ character === dash ||
+ character === plusSign
) {
- replace = true;
- } else if (isDecimal(character)) {
- offset = position + 1;
+ replace = true
+ } else if (decimal(character)) {
+ offset = position + 1
while (offset < length) {
- if (!isDecimal(value.charAt(offset))) {
+ if (!decimal(value.charAt(offset))) {
break
}
- offset++;
+ offset++
}
if (markers.indexOf(value.charAt(offset)) !== -1) {
- next = value.charAt(offset + 1);
+ next = value.charAt(offset + 1)
- if (!next || next === space$16 || next === tab$14 || next === lineFeed$18) {
- queue.push(value.slice(position, offset));
- position = offset;
- character = value.charAt(position);
- replace = true;
+ if (!next || next === space || next === tab || next === lineFeed) {
+ queue.push(value.slice(position, offset))
+ position = offset
+ character = value.charAt(position)
+ replace = true
}
}
}
}
- if (afterNewLine && !isWhitespaceCharacter(character)) {
- afterNewLine = false;
+ if (afterNewLine && !whitespace(character)) {
+ afterNewLine = false
}
- queue.push(replace ? one(character) : character);
+ queue.push(replace ? one(character) : character)
}
// Multi-node versions.
- if (siblings && text$1(node)) {
+ 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$1) {
- position = -1;
- length = escaped.length;
+ if (prev && prev.referenceType === shortcut) {
+ position = -1
+ length = escaped.length
while (++position < length) {
- character = escaped[position];
+ character = escaped[position]
- if (character === space$16 || character === tab$14) {
+ if (character === space || character === tab) {
continue
}
- if (character === leftParenthesis$3 || character === colon$5) {
- escaped[position] = one(character);
+ if (character === leftParenthesis || character === colon) {
+ escaped[position] = one(character)
}
break
@@ -28967,11 +33465,11 @@ function factory$5(options) {
// If the current node is all spaces / tabs, preceded by a shortcut,
// and followed by a text starting with `(`, escape it.
if (
- text$1(next) &&
+ text(next) &&
position === length &&
- next.value.charAt(0) === leftParenthesis$3
+ next.value.charAt(0) === leftParenthesis
) {
- escaped.push(backslash$9);
+ escaped.push(backslash)
}
}
@@ -28980,67 +33478,67 @@ function factory$5(options) {
if (
gfm &&
!self.inLink &&
- text$1(prev) &&
- value.charAt(0) === colon$5 &&
+ text(prev) &&
+ value.charAt(0) === colon &&
protocol(prev.value.slice(-6))
) {
- escaped[0] = one(colon$5);
+ escaped[0] = one(colon)
}
// Escape ampersand if it would otherwise start an entity.
if (
- text$1(next) &&
- value.charAt(length - 1) === ampersand$1 &&
- entityPrefixLength(ampersand$1 + next.value) !== 0
+ text(next) &&
+ value.charAt(length - 1) === ampersand &&
+ prefix(ampersand + next.value) !== 0
) {
- escaped[escaped.length - 1] = one(ampersand$1);
+ escaped[escaped.length - 1] = one(ampersand)
}
// Escape exclamation marks immediately followed by links.
if (
next &&
next.type === 'link' &&
- value.charAt(length - 1) === exclamationMark$4
+ value.charAt(length - 1) === exclamationMark
) {
- escaped[escaped.length - 1] = one(exclamationMark$4);
+ escaped[escaped.length - 1] = one(exclamationMark)
}
// Escape double tildes in GFM.
if (
gfm &&
- text$1(next) &&
- value.charAt(length - 1) === tilde$4 &&
- next.value.charAt(0) === tilde$4
+ text(next) &&
+ value.charAt(length - 1) === tilde &&
+ next.value.charAt(0) === tilde
) {
- escaped.splice(escaped.length - 1, 0, backslash$9);
+ escaped.splice(escaped.length - 1, 0, backslash)
}
// Escape underscores, but not mid-word (unless in pedantic mode).
- wordCharBefore = text$1(prev) && isAlphanumeric(prev.value.slice(-1));
- wordCharAfter = text$1(next) && isAlphanumeric(next.value.charAt(0));
+ wordCharBefore = text(prev) && alphanumeric(prev.value.slice(-1))
+ wordCharAfter = text(next) && alphanumeric(next.value.charAt(0))
if (length === 1) {
if (
- value === underscore$4 &&
+ value === underscore &&
(pedantic || !wordCharBefore || !wordCharAfter)
) {
- escaped.unshift(backslash$9);
+ escaped.unshift(backslash)
}
} else {
if (
- value.charAt(0) === underscore$4 &&
- (pedantic || !wordCharBefore || !isAlphanumeric(value.charAt(1)))
+ value.charAt(0) === underscore &&
+ (pedantic || !wordCharBefore || !alphanumeric(value.charAt(1)))
) {
- escaped.unshift(backslash$9);
+ escaped.unshift(backslash)
}
if (
- value.charAt(length - 1) === underscore$4 &&
+ value.charAt(length - 1) === underscore &&
(pedantic ||
!wordCharAfter ||
- !isAlphanumeric(value.charAt(length - 2)))
+ !alphanumeric(value.charAt(length - 2)))
) {
- escaped.splice(escaped.length - 1, 0, backslash$9);
+ escaped.splice(escaped.length - 1, 0, backslash)
}
}
}
@@ -29049,28 +33547,28 @@ function factory$5(options) {
function one(character) {
return escapable.indexOf(character) === -1
- ? entities$1[character]
- : backslash$9 + character
+ ? entities[character]
+ : backslash + character
}
}
}
// Check if `index` in `value` is inside an alignment row.
function alignment(value, index) {
- var start = value.lastIndexOf(lineFeed$18, index);
- var end = value.indexOf(lineFeed$18, index);
- var char;
+ var start = value.lastIndexOf(lineFeed, index)
+ var end = value.indexOf(lineFeed, index)
+ var char
- end = end === -1 ? value.length : end;
+ end = end === -1 ? value.length : end
while (++start < end) {
- char = value.charAt(start);
+ char = value.charAt(start)
if (
- char !== colon$5 &&
- char !== dash$5 &&
- char !== space$16 &&
- char !== verticalBar$1
+ char !== colon &&
+ char !== dash &&
+ char !== space &&
+ char !== verticalBar
) {
return false
}
@@ -29080,199 +33578,88 @@ function alignment(value, index) {
}
// Check if `node` is a text node.
-function text$1(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$2 || val.slice(-5) === https$1 || val.slice(-4) === http$1
+ var val = value.slice(-6).toLowerCase()
+ return val === mailto || val.slice(-5) === https || val.slice(-4) === http
}
-var setOptions_1$2 = setOptions$1;
-// 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$1(options) {
- var self = this;
- var current = self.options;
- var ruleRepetition;
- var key;
-
- if (options == null) {
- options = {};
- } else if (typeof options === 'object') {
- options = immutable(options);
- } else {
- throw new Error('Invalid value `' + options + '` for setting `options`')
- }
-
- for (key in defaults$5) {
- validate[typeof defaults$5[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 = _escape$4(options);
-
- self.options = options;
-
- return self
-}
+/***/ }),
+/* 266 */
+/***/ (function(module, exports, __webpack_require__) {
-// 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;
-}
+"use strict";
-// 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];
+module.exports = function (str) {
+ if (typeof str !== 'string') {
+ throw new TypeError('Expected a string');
+ }
- if (value == null) {
- value = def;
- }
+ return !/[^0-9a-z\xDF-\xFF]/.test(str.toLowerCase());
+};
- value = String(value);
- if (!(value in map)) {
- raise(value, 'options.' + name);
- }
+/***/ }),
+/* 267 */
+/***/ (function(module, exports, __webpack_require__) {
- context[name] = value;
-}
+"use strict";
-// 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;
- }
+var compact = __webpack_require__(268)
- if (typeof value !== 'function') {
- raise(value, 'options.' + name);
- }
+module.exports = compile
- context[name] = value;
+// Stringify the given tree.
+function compile() {
+ return this.visit(compact(this.tree, this.options.commonmark))
}
-// 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_1
- }
+/***/ }),
+/* 268 */
+/***/ (function(module, exports, __webpack_require__) {
- if (type === 'true') {
- options.useNamedReferences = true;
- }
+"use strict";
- if (type === 'escape') {
- options.escapeOnly = true;
- options.useNamedReferences = true;
- }
- return wrapped
+var visit = __webpack_require__(1)
- // Encode HTML entities using the bound options.
- function wrapped(value) {
- return stringifyEntities(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 + '`')
-}
-
-var mdastUtilCompact = compact;
+module.exports = compact
/* Make an MDAST tree compact by merging adjacent text nodes. */
function compact(tree, commonmark) {
- unistUtilVisit(tree, visitor);
+ visit(tree, visitor)
return tree
function visitor(child, index, parent) {
- var siblings = parent ? parent.children : [];
- var prev = index && siblings[index - 1];
+ var siblings = parent ? parent.children : []
+ var prev = index && siblings[index - 1]
if (
prev &&
child.type === prev.type &&
- mergeable$1(prev, commonmark) &&
- mergeable$1(child, commonmark)
+ mergeable(prev, commonmark) &&
+ mergeable(child, commonmark)
) {
if (child.value) {
- prev.value += child.value;
+ prev.value += child.value
}
if (child.children) {
- prev.children = prev.children.concat(child.children);
+ prev.children = prev.children.concat(child.children)
}
- siblings.splice(index, 1);
+ siblings.splice(index, 1)
if (prev.position && child.position) {
- prev.position.end = child.position.end;
+ prev.position.end = child.position.end
}
return index
@@ -29280,17 +33667,17 @@ function compact(tree, commonmark) {
}
}
-function mergeable$1(node, commonmark) {
- var start;
- var end;
+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;
+ start = node.position.start
+ end = node.position.end
/* Only merge nodes which occupy the same size as their `value`. */
return (
@@ -29301,18 +33688,19 @@ function mergeable$1(node, commonmark) {
return commonmark && node.type === 'blockquote'
}
-var compile_1 = compile$2;
-// Stringify the given tree.
-function compile$2() {
- return this.visit(mdastUtilCompact(this.tree, this.options.commonmark))
-}
+/***/ }),
+/* 269 */
+/***/ (function(module, exports, __webpack_require__) {
-var one_1 = one$2;
+"use strict";
-function one$2(node, parent) {
- var self = this;
- var visitors = self.visitors;
+
+module.exports = one
+
+function one(node, parent) {
+ var self = this
+ var visitors = self.visitors
// Fail on unknown nodes.
if (typeof visitors[node.type] !== 'function') {
@@ -29321,55 +33709,71 @@ function one$2(node, parent) {
'Missing compiler for node of type `' + node.type + '`: `' + node + '`'
),
node
- );
+ )
}
return visitors[node.type].call(self, node, parent)
}
-var all_1 = all;
+
+/***/ }),
+/* 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;
+ 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);
+ results[index] = self.visit(children[index], parent)
}
return results
}
-var block_1 = block$1;
-var lineFeed$19 = '\n';
+/***/ }),
+/* 271 */
+/***/ (function(module, exports, __webpack_require__) {
-var blank$1 = lineFeed$19 + lineFeed$19;
-var triple = blank$1 + lineFeed$19;
-var comment$1 = blank$1 + '<!---->' + blank$1;
+"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$1(node) {
- var self = this;
- var options = self.options;
- var fences = options.fences;
- var gap = options.commonmark ? comment$1 : triple;
- var values = [];
- var children = node.children;
- var length = children.length;
- var index = -1;
- var prev;
- var child;
+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];
+ prev = child
+ child = children[index]
if (prev) {
// A list preceding another list that are equally ordered, or a
@@ -29385,24 +33789,32 @@ function block$1(node) {
((child.type === 'list' && prev.ordered === child.ordered) ||
(child.type === 'code' && (!child.lang && !fences)))
) {
- values.push(gap);
+ values.push(gap)
} else {
- values.push(blank$1);
+ values.push(blank)
}
}
- values.push(self.visit(child, node));
+ values.push(self.visit(child, node))
}
return values.join('')
}
-var orderedItems_1 = orderedItems;
-var lineFeed$20 = '\n';
-var dot$4 = '.';
+/***/ }),
+/* 272 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
-var blank$2 = lineFeed$20 + lineFeed$20;
+module.exports = orderedItems
+
+var lineFeed = '\n'
+var dot = '.'
+
+var blank = lineFeed + lineFeed
// Visit ordered list items.
//
@@ -29419,60 +33831,84 @@ var blank$2 = lineFeed$20 + lineFeed$20;
// 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;
+ 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$4;
- values[index] = fn.call(self, children[index], node, index, bullet);
+ bullet = (increment ? start + index : start) + dot
+ values[index] = fn.call(self, children[index], node, index, bullet)
}
- return values.join(node.spread ? blank$2 : lineFeed$20)
+ return values.join(node.spread ? blank : lineFeed)
}
-var unorderedItems_1 = unorderedItems;
-var lineFeed$21 = '\n';
+/***/ }),
+/* 273 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
-var blank$3 = lineFeed$21 + lineFeed$21;
+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 = [];
+ 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);
+ values[index] = fn.call(self, children[index], node, index, bullet)
}
- return values.join(node.spread ? blank$3 : lineFeed$21)
+ return values.join(node.spread ? blank : lineFeed)
}
-var root_1 = root;
-var lineFeed$22 = '\n';
+/***/ }),
+/* 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$22
+ return this.block(node) + lineFeed
}
-var text_1$2 = text$2;
+
+/***/ }),
+/* 275 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+module.exports = text
// Stringify text.
// Supports named entities in `settings.encode: true` mode:
@@ -29486,17 +33922,27 @@ var text_1$2 = text$2;
// ```markdown
// AT&#x26;T
// ```
-function text$2(node, parent) {
+function text(node, parent) {
return this.encode(this.escape(node.value, node, parent), node)
}
-var heading_1 = heading;
-var lineFeed$23 = '\n';
-var space$17 = ' ';
-var numberSign$2 = '#';
-var dash$6 = '-';
-var equalsTo$1 = '=';
+/***/ }),
+/* 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.
//
@@ -29520,93 +33966,105 @@ var equalsTo$1 = '=';
// ### 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;
+ 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$23 + repeatString(depth === 1 ? equalsTo$1 : dash$6, content.length)
+ content + lineFeed + repeat(depth === 1 ? equalsTo : dash, content.length)
)
}
- prefix = repeatString(numberSign$2, node.depth);
+ prefix = repeat(numberSign, node.depth)
- return prefix + space$17 + content + (closeAtx ? space$17 + prefix : '')
+ return prefix + space + content + (closeAtx ? space + prefix : '')
}
-var paragraph_1$2 = paragraph$1;
-function paragraph$1(node) {
+/***/ }),
+/* 277 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+module.exports = paragraph
+
+function paragraph(node) {
return this.all(node).join('')
}
-var blockquote_1$2 = blockquote$1;
-var lineFeed$24 = '\n';
-var space$18 = ' ';
-var greaterThan$5 = '>';
+/***/ }),
+/* 278 */
+/***/ (function(module, exports, __webpack_require__) {
-function blockquote$1(node) {
- var values = this.block(node).split(lineFeed$24);
- var result = [];
- var length = values.length;
- var index = -1;
- var value;
+"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$18 : '') + value;
+ value = values[index]
+ result[index] = (value ? space : '') + value
}
- return greaterThan$5 + result.join(lineFeed$24 + greaterThan$5)
+ return greaterThan + result.join(lineFeed + greaterThan)
}
-var list_1$2 = list$1;
-function list$1(node) {
- var fn = node.ordered ? this.visitOrderedItems : this.visitUnorderedItems;
+/***/ }),
+/* 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)
}
-var pad_1 = pad;
-
-var lineFeed$25 = '\n';
-var space$19 = ' ';
-var tabSize$5 = 4;
+/***/ }),
+/* 280 */
+/***/ (function(module, exports, __webpack_require__) {
-// Pad `value` with `level * tabSize` spaces. Respects lines. Ignores empty
-// lines.
-function pad(value, level) {
- var values = value.split(lineFeed$25);
- var index = values.length;
- var padding = repeatString(space$19, level * tabSize$5);
+"use strict";
- while (index--) {
- if (values[index].length !== 0) {
- values[index] = padding + values[index];
- }
- }
- return values.join(lineFeed$25)
-}
+var repeat = __webpack_require__(10)
+var pad = __webpack_require__(90)
-var listItem_1 = listItem$1;
+module.exports = listItem
-var lineFeed$26 = '\n';
-var space$20 = ' ';
-var leftSquareBracket$6 = '[';
-var rightSquareBracket$6 = ']';
-var lowercaseX$1 = 'x';
+var lineFeed = '\n'
+var space = ' '
+var leftSquareBracket = '['
+var rightSquareBracket = ']'
+var lowercaseX = 'x'
-var ceil = Math.ceil;
-var blank$4 = lineFeed$26 + lineFeed$26;
+var ceil = Math.ceil
+var blank = lineFeed + lineFeed
-var tabSize$6 = 4;
+var tabSize = 4
// Stringify a list item.
//
@@ -29621,92 +34079,66 @@ var tabSize$6 = 4;
// ```markdown
// [ ] foo
// ```
-function listItem$1(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;
+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);
+ values[index] = self.visit(children[index], node)
}
- value = values.join(spread ? blank$4 : lineFeed$26);
+ 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$6 +
- (checked ? lowercaseX$1 : space$20) +
- rightSquareBracket$6 +
- space$20 +
- value;
+ leftSquareBracket +
+ (checked ? lowercaseX : space) +
+ rightSquareBracket +
+ space +
+ value
}
- if (style === '1' || (style === 'mixed' && value.indexOf(lineFeed$26) === -1)) {
- indent = marker.length + 1;
- spacing = space$20;
+ if (style === '1' || (style === 'mixed' && value.indexOf(lineFeed) === -1)) {
+ indent = marker.length + 1
+ spacing = space
} else {
- indent = ceil((marker.length + 1) / tabSize$6) * tabSize$6;
- spacing = repeatString(space$20, indent - marker.length);
+ indent = ceil((marker.length + 1) / tabSize) * tabSize
+ spacing = repeat(space, indent - marker.length)
}
return value
- ? marker + spacing + pad_1(value, indent / tabSize$6).slice(indent)
+ ? marker + spacing + pad(value, indent / tabSize).slice(indent)
: marker
}
-/* Expose. */
-var longestStreak_1 = 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;
+/***/ }),
+/* 281 */
+/***/ (function(module, exports, __webpack_require__) {
- if (typeof character !== 'string' || character.length !== 1) {
- throw new Error('Expected character');
- }
+"use strict";
- value = String(value);
- index = value.indexOf(character);
- expected = index;
- while (index !== -1) {
- count++;
+var streak = __webpack_require__(91)
+var repeat = __webpack_require__(10)
- if (index === expected) {
- if (count > maximum) {
- maximum = count;
- }
- } else {
- count = 1;
- }
-
- expected = index + 1;
- index = value.indexOf(character, expected);
- }
+module.exports = inlineCode
- return maximum;
-}
-
-var inlineCode_1 = inlineCode$1;
-
-var space$21 = ' ';
-var graveAccent$5 = '`';
+var space = ' '
+var graveAccent = '`'
// Stringify inline code.
//
@@ -29723,27 +34155,39 @@ var graveAccent$5 = '`';
// `` `foo ``
// `` foo` ``
// ```
-function inlineCode$1(node) {
- var value = node.value;
- var ticks = repeatString(graveAccent$5, longestStreak_1(value, graveAccent$5) + 1);
- var start = ticks;
- var end = ticks;
+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$5) {
- start += space$21;
+ if (value.charAt(0) === graveAccent) {
+ start += space
}
- if (value.charAt(value.length - 1) === graveAccent$5) {
- end = space$21 + end;
+ if (value.charAt(value.length - 1) === graveAccent) {
+ end = space + end
}
return start + value + end
}
-var code_1 = code;
-var lineFeed$27 = '\n';
-var space$22 = ' ';
+/***/ }),
+/* 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:
@@ -29778,18 +34222,18 @@ var space$22 = ' ';
// ````
// `````
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;
+ 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$22 + node.meta;
+ info += space + node.meta
}
- info = self.encode(self.escape(info, node));
+ info = self.encode(self.escape(info, node))
// Without (needed) fences.
if (!info && !options.fences && value) {
@@ -29803,26 +34247,44 @@ function code(node, parent) {
self.file.fail(
'Cannot indent code properly. See https://git.io/fxKR8',
node.position
- );
+ )
}
- return pad_1(value, 1)
+ return pad(value, 1)
}
- fence = repeatString(marker, Math.max(longestStreak_1(value, marker) + 1, 3));
+ fence = repeat(marker, Math.max(streak(value, marker) + 1, 3))
- return fence + info + lineFeed$27 + value + lineFeed$27 + fence
+ return fence + info + lineFeed + value + lineFeed + fence
}
-var html_1 = html$2;
-function html$2(node) {
+/***/ }),
+/* 283 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+module.exports = html
+
+function html(node) {
return node.value
}
-var thematicBreak$1 = thematic;
-var space$23 = ' ';
+/***/ }),
+/* 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`: (`'_'`):
@@ -29843,12 +34305,22 @@ var space$23 = ' ';
// * * *
// ```
function thematic() {
- var options = this.options;
- var rule = repeatString(options.rule, options.ruleRepetition);
- return options.ruleSpaces ? rule.split('').join(space$23) : rule
+ var options = this.options
+ var rule = repeat(options.rule, options.ruleRepetition)
+ return options.ruleSpaces ? rule.split('').join(space) : rule
}
-var strong_1$2 = strong$3;
+
+/***/ }),
+/* 285 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var repeat = __webpack_require__(10)
+
+module.exports = strong
// Stringify a `strong`.
//
@@ -29858,15 +34330,23 @@ var strong_1$2 = strong$3;
// ```markdown
// __foo__
// ```
-function strong$3(node) {
- var marker = repeatString(this.options.strong, 2);
+function strong(node) {
+ var marker = repeat(this.options.strong, 2)
return marker + this.all(node).join('') + marker
}
-var emphasis_1$2 = emphasis$3;
-var underscore$5 = '_';
-var asterisk$5 = '*';
+/***/ }),
+/* 286 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+module.exports = emphasis
+
+var underscore = '_'
+var asterisk = '*'
// Stringify an `emphasis`.
//
@@ -29883,125 +34363,84 @@ var asterisk$5 = '*';
// ```markdown
// *foo_bar*
// ```
-function emphasis$3(node) {
- var marker = this.options.emphasis;
- var content = this.all(node).join('');
+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$5 &&
+ marker === underscore &&
content.indexOf(marker) !== -1
) {
- marker = asterisk$5;
+ marker = asterisk
}
return marker + content + marker
}
-var _break$4 = lineBreak;
-var backslash$10 = '\\';
-var lineFeed$28 = '\n';
-var space$24 = ' ';
+/***/ }),
+/* 287 */
+/***/ (function(module, exports, __webpack_require__) {
-var commonmark$1 = backslash$10 + lineFeed$28;
-var normal = space$24 + space$24 + lineFeed$28;
+"use strict";
-function lineBreak() {
- return this.options.commonmark ? commonmark$1 : normal
-}
-var _delete$4 = strikethrough$1;
+module.exports = lineBreak
-var tilde$5 = '~';
+var backslash = '\\'
+var lineFeed = '\n'
+var space = ' '
-var fence$1 = tilde$5 + tilde$5;
+var commonmark = backslash + lineFeed
+var normal = space + space + lineFeed
-function strikethrough$1(node) {
- return fence$1 + this.all(node).join('') + fence$1
+function lineBreak() {
+ return this.options.commonmark ? commonmark : normal
}
-var ccount_1 = ccount;
-function ccount(value, character) {
- var count = 0;
- var index;
+/***/ }),
+/* 288 */
+/***/ (function(module, exports, __webpack_require__) {
- value = String(value);
+"use strict";
- 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
-}
+module.exports = strikethrough
-var encloseUri = enclose;
+var tilde = '~'
-var leftParenthesis$4 = '(';
-var rightParenthesis$5 = ')';
-var lessThan$7 = '<';
-var greaterThan$6 = '>';
+var fence = tilde + tilde
-var expression = /\s/;
+function strikethrough(node) {
+ return fence + this.all(node).join('') + fence
+}
-// 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) ||
- ccount_1(uri, leftParenthesis$4) !== ccount_1(uri, rightParenthesis$5)
- ) {
- return lessThan$7 + uri + greaterThan$6
- }
- return uri
-}
+/***/ }),
+/* 289 */
+/***/ (function(module, exports, __webpack_require__) {
-var encloseTitle = enclose$1;
+"use strict";
-var quotationMark$3 = '"';
-var apostrophe$3 = "'";
-// 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$1(title) {
- var delimiter =
- title.indexOf(quotationMark$3) === -1 ? quotationMark$3 : apostrophe$3;
- return delimiter + title + delimiter
-}
+var uri = __webpack_require__(43)
+var title = __webpack_require__(44)
-var link_1$2 = link$4;
+module.exports = link
-var space$25 = ' ';
-var leftSquareBracket$7 = '[';
-var rightSquareBracket$7 = ']';
-var leftParenthesis$5 = '(';
-var rightParenthesis$6 = ')';
+var space = ' '
+var leftSquareBracket = '['
+var rightSquareBracket = ']'
+var leftParenthesis = '('
+var rightParenthesis = ')'
// Expression for a protocol:
// See <http://en.wikipedia.org/wiki/URI_scheme#Generic_syntax>.
-var protocol$1 = /^[a-z][a-z+.-]+:\/?/i;
+var protocol = /^[a-z][a-z+.-]+:\/?/i
// Stringify a link.
//
@@ -30022,41 +34461,115 @@ var protocol$1 = /^[a-z][a-z+.-]+:\/?/i;
//
// Supports named entities in the `url` and `title` when in `settings.encode`
// mode.
-function link$4(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('');
+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();
+ exit()
- if (node.title == null && protocol$1.test(content) && escaped === value) {
+ if (node.title == null && protocol.test(content) && escaped === value) {
// Backslash escapes do not work in autolinks, so we do not escape.
- return encloseUri(self.encode(node.url), true)
+ return uri(self.encode(node.url), true)
}
- content = encloseUri(content);
+ content = uri(content)
if (node.title) {
- content += space$25 + encloseTitle(self.encode(self.escape(node.title, node), node));
+ content += space + title(self.encode(self.escape(node.title, node), node))
}
return (
- leftSquareBracket$7 +
+ leftSquareBracket +
value +
- rightSquareBracket$7 +
- leftParenthesis$5 +
+ rightSquareBracket +
+ leftParenthesis +
content +
- rightParenthesis$6
+ rightParenthesis
)
}
-var copyIdentifierEncoding = copy$5;
-var ampersand$2 = '&';
+/***/ }),
+/* 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 punctuationExppresion = /[-!"#$%&'()*+,./:;<=>?@[\\\]^`{|}~_]/;
+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
@@ -30065,128 +34578,100 @@ var punctuationExppresion = /[-!"#$%&'()*+,./:;<=>?@[\\\]^`{|}~_]/;
// 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$5(value, identifier) {
- var length = value.length;
- var count = identifier.length;
- var result = [];
- var position = 0;
- var index = 0;
- var start;
+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;
+ start = index
while (index < length && !punctuationExppresion.test(value.charAt(index))) {
- index += 1;
+ index += 1
}
- result.push(value.slice(start, index));
+ result.push(value.slice(start, index))
// Advance `position` to the next punctuation character.
while (
position < count &&
!punctuationExppresion.test(identifier.charAt(position))
) {
- position += 1;
+ position += 1
}
// Take next punctuation characters from `identifier`.
- start = position;
+ start = position
while (
position < count &&
punctuationExppresion.test(identifier.charAt(position))
) {
- if (identifier.charAt(position) === ampersand$2) {
- position += entityPrefixLength(identifier.slice(position));
+ if (identifier.charAt(position) === ampersand) {
+ position += entityPrefixLength(identifier.slice(position))
}
- position += 1;
+ position += 1
}
- result.push(identifier.slice(start, position));
+ result.push(identifier.slice(start, position))
// Advance `index` to the next non-punctuation character.
while (index < length && punctuationExppresion.test(value.charAt(index))) {
- index += 1;
+ index += 1
}
}
return result.join('')
}
-var label_1 = label;
-var leftSquareBracket$8 = '[';
-var rightSquareBracket$8 = ']';
+/***/ }),
+/* 293 */
+/***/ (function(module, exports, __webpack_require__) {
-var shortcut$2 = 'shortcut';
-var collapsed$1 = 'collapsed';
+"use strict";
-// 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$2) {
- return ''
- }
+var label = __webpack_require__(92)
+module.exports = imageReference
+
+var leftSquareBracket = '['
+var rightSquareBracket = ']'
+var exclamationMark = '!'
+
+function imageReference(node) {
return (
- leftSquareBracket$8 +
- (type === collapsed$1 ? '' : node.label || node.identifier) +
- rightSquareBracket$8
+ exclamationMark +
+ leftSquareBracket +
+ (this.encode(node.alt, node) || '') +
+ rightSquareBracket +
+ label(node)
)
}
-var linkReference_1 = linkReference;
-
-var leftSquareBracket$9 = '[';
-var rightSquareBracket$9 = ']';
-
-var shortcut$3 = 'shortcut';
-var collapsed$2 = '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$3 || type === collapsed$2) {
- value = copyIdentifierEncoding(value, node.label || node.identifier);
- }
- return leftSquareBracket$9 + value + rightSquareBracket$9 + label_1(node)
-}
+/***/ }),
+/* 294 */
+/***/ (function(module, exports, __webpack_require__) {
-var imageReference_1 = imageReference;
+"use strict";
-var leftSquareBracket$10 = '[';
-var rightSquareBracket$10 = ']';
-var exclamationMark$5 = '!';
-function imageReference(node) {
- return (
- exclamationMark$5 +
- leftSquareBracket$10 +
- (this.encode(node.alt, node) || '') +
- rightSquareBracket$10 +
- label_1(node)
- )
-}
+var uri = __webpack_require__(43)
+var title = __webpack_require__(44)
-var definition_1$2 = definition$1;
+module.exports = definition
-var space$26 = ' ';
-var colon$6 = ':';
-var leftSquareBracket$11 = '[';
-var rightSquareBracket$11 = ']';
+var space = ' '
+var colon = ':'
+var leftSquareBracket = '['
+var rightSquareBracket = ']'
// Stringify an URL definition.
//
@@ -30196,31 +34681,42 @@ var rightSquareBracket$11 = ']';
// ```markdown
// [foo]: <foo at bar dot com> 'An "example" e-mail'
// ```
-function definition$1(node) {
- var content = encloseUri(node.url);
+function definition(node) {
+ var content = uri(node.url)
if (node.title) {
- content += space$26 + encloseTitle(node.title);
+ content += space + title(node.title)
}
return (
- leftSquareBracket$11 +
+ leftSquareBracket +
(node.label || node.identifier) +
- rightSquareBracket$11 +
- colon$6 +
- space$26 +
+ rightSquareBracket +
+ colon +
+ space +
content
)
}
-var image_1 = image$3;
-var space$27 = ' ';
-var leftParenthesis$6 = '(';
-var rightParenthesis$7 = ')';
-var leftSquareBracket$12 = '[';
-var rightSquareBracket$12 = ']';
-var exclamationMark$6 = '!';
+/***/ }),
+/* 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.
//
@@ -30233,313 +34729,422 @@ var exclamationMark$6 = '!';
//
// Supports named entities in `url`, `alt`, and `title` when in
// `settings.encode` mode.
-function image$3(node) {
- var self = this;
- var content = encloseUri(self.encode(node.url || '', node));
- var exit = self.enterLink();
- var alt = self.encode(self.escape(node.alt || '', node));
+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();
+ exit()
if (node.title) {
- content += space$27 + encloseTitle(self.encode(node.title, node));
+ content += space + title(self.encode(node.title, node))
}
return (
- exclamationMark$6 +
- leftSquareBracket$12 +
+ exclamationMark +
+ leftSquareBracket +
alt +
- rightSquareBracket$12 +
- leftParenthesis$6 +
+ rightSquareBracket +
+ leftParenthesis +
content +
- rightParenthesis$7
+ rightParenthesis
)
}
-var footnote_1 = footnote$1;
-var leftSquareBracket$13 = '[';
-var rightSquareBracket$13 = ']';
-var caret$3 = '^';
+/***/ }),
+/* 296 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+module.exports = footnote
+
+var leftSquareBracket = '['
+var rightSquareBracket = ']'
+var caret = '^'
-function footnote$1(node) {
+function footnote(node) {
return (
- leftSquareBracket$13 + caret$3 + this.all(node).join('') + rightSquareBracket$13
+ leftSquareBracket + caret + this.all(node).join('') + rightSquareBracket
)
}
-var footnoteReference_1 = footnoteReference;
-var leftSquareBracket$14 = '[';
-var rightSquareBracket$14 = ']';
-var caret$4 = '^';
+/***/ }),
+/* 297 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+module.exports = footnoteReference
+
+var leftSquareBracket = '['
+var rightSquareBracket = ']'
+var caret = '^'
function footnoteReference(node) {
return (
- leftSquareBracket$14 +
- caret$4 +
+ leftSquareBracket +
+ caret +
(node.label || node.identifier) +
- rightSquareBracket$14
+ rightSquareBracket
)
}
-var lineFeed$29 = '\n';
-var space$28 = ' ';
-var colon$7 = ':';
-var leftSquareBracket$15 = '[';
-var rightSquareBracket$15 = ']';
-var caret$5 = '^';
-var tabSize$7 = 4;
-var blank$5 = lineFeed$29 + lineFeed$29;
-var indent = repeatString(space$28, tabSize$7);
+/***/ }),
+/* 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 footnoteDefinition_1$2 = footnoteDefinition$1;
+var tabSize = 4
+var blank = lineFeed + lineFeed
+var indent = repeat(space, tabSize)
-function footnoteDefinition$1(node) {
- var content = this.all(node).join(blank$5 + indent);
+module.exports = footnoteDefinition
+
+function footnoteDefinition(node) {
+ var content = this.all(node).join(blank + indent)
return (
- leftSquareBracket$15 +
- caret$5 +
+ leftSquareBracket +
+ caret +
(node.label || node.identifier) +
- rightSquareBracket$15 +
- colon$7 +
- space$28 +
+ 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. */
-var markdownTable_1 = markdownTable;
+module.exports = markdownTable
/* Expressions. */
-var EXPRESSION_DOT = /\./;
-var EXPRESSION_LAST_DOT = /\.[^.]*$/;
+var EXPRESSION_DOT = /\./
+var EXPRESSION_LAST_DOT = /\.[^.]*$/
/* Allowed alignment values. */
-var LEFT = 'l';
-var RIGHT = 'r';
-var CENTER = 'c';
-var DOT = '.';
-var NULL = '';
+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;
+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';
+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() : [];
+ 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;
+ delimiter = SPACE + PIPE + SPACE
}
if (start === null || start === undefined) {
- start = PIPE + SPACE;
+ start = PIPE + SPACE
}
if (end === null || end === undefined) {
- end = SPACE + PIPE;
+ end = SPACE + PIPE
}
while (++rowIndex < rowLength) {
- row = table[rowIndex];
+ row = table[rowIndex]
- index = -1;
+ index = -1
if (row.length > cellCount) {
- cellCount = row.length;
+ cellCount = row.length
}
while (++index < cellCount) {
- position = row[index] ? dotindex$1(row[index]) : null;
+ position = row[index] ? dotindex(row[index]) : null
if (!sizes[index]) {
- sizes[index] = MIN_CELL_SIZE;
+ sizes[index] = MIN_CELL_SIZE
}
if (position > sizes[index]) {
- sizes[index] = position;
+ sizes[index] = position
}
}
}
if (typeof alignment === 'string') {
- alignment = pad$2(cellCount, alignment).split('');
+ alignment = pad(cellCount, alignment).split('')
}
/* Make sure only valid alignments are used. */
- index = -1;
+ index = -1
while (++index < cellCount) {
- align = alignment[index];
+ align = alignment[index]
if (typeof align === 'string') {
- align = align.charAt(0).toLowerCase();
+ align = align.charAt(0).toLowerCase()
}
if (ALLIGNMENT.indexOf(align) === -1) {
- align = NULL;
+ align = NULL
}
- alignment[index] = align;
+ alignment[index] = align
}
- rowIndex = -1;
- rows = [];
+ rowIndex = -1
+ rows = []
while (++rowIndex < rowLength) {
- row = table[rowIndex];
+ row = table[rowIndex]
- index = -1;
- cells = [];
+ index = -1
+ cells = []
while (++index < cellCount) {
- value = row[index];
+ value = row[index]
- value = stringify$6(value);
+ value = stringify(value)
if (alignment[index] === DOT) {
- position = dotindex$1(value);
+ position = dotindex(value)
size =
sizes[index] +
(EXPRESSION_DOT.test(value) ? 0 : 1) -
- (calculateStringLength(value) - position);
+ (calculateStringLength(value) - position)
- cells[index] = value + pad$2(size - 1);
+ cells[index] = value + pad(size - 1)
} else {
- cells[index] = value;
+ cells[index] = value
}
}
- rows[rowIndex] = cells;
+ rows[rowIndex] = cells
}
- sizes = [];
- rowIndex = -1;
+ sizes = []
+ rowIndex = -1
while (++rowIndex < rowLength) {
- cells = rows[rowIndex];
+ cells = rows[rowIndex]
- index = -1;
+ index = -1
while (++index < cellCount) {
- value = cells[index];
+ value = cells[index]
if (!sizes[index]) {
- sizes[index] = MIN_CELL_SIZE;
+ sizes[index] = MIN_CELL_SIZE
}
- size = calculateStringLength(value);
+ size = calculateStringLength(value)
if (size > sizes[index]) {
- sizes[index] = size;
+ sizes[index] = size
}
}
}
- rowIndex = -1;
+ rowIndex = -1
while (++rowIndex < rowLength) {
- cells = rows[rowIndex];
+ cells = rows[rowIndex]
- index = -1;
+ index = -1
if (settings.pad !== false) {
while (++index < cellCount) {
- value = cells[index];
+ value = cells[index]
- position = sizes[index] - (calculateStringLength(value) || 0);
- spacing = pad$2(position);
+ position = sizes[index] - (calculateStringLength(value) || 0)
+ spacing = pad(position)
if (alignment[index] === RIGHT || alignment[index] === DOT) {
- value = spacing + value;
+ value = spacing + value
} else if (alignment[index] === CENTER) {
- position /= 2;
+ position /= 2
if (position % 1 === 0) {
- before = position;
- after = position;
+ before = position
+ after = position
} else {
- before = position + 0.5;
- after = position - 0.5;
+ before = position + 0.5
+ after = position - 0.5
}
- value = pad$2(before) + value + pad$2(after);
+ value = pad(before) + value + pad(after)
} else {
- value += spacing;
+ value += spacing
}
- cells[index] = value;
+ cells[index] = value
}
}
- rows[rowIndex] = cells.join(delimiter);
+ rows[rowIndex] = cells.join(delimiter)
}
if (settings.rule !== false) {
- index = -1;
- rule = [];
+ 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$6(value));
- spacing = spacing > MIN_CELL_SIZE ? spacing : MIN_CELL_SIZE;
+ value = table[0][index]
+ spacing = calculateStringLength(stringify(value))
+ spacing = spacing > MIN_CELL_SIZE ? spacing : MIN_CELL_SIZE
} else {
- spacing = sizes[index];
+ spacing = sizes[index]
}
- align = alignment[index];
+ align = alignment[index]
/* When `align` is left, don't add colons. */
- value = align === RIGHT || align === NULL ? DASH : COLON;
- value += pad$2(spacing - 2, DASH);
- value += align !== LEFT && align !== NULL ? COLON : DASH;
+ value = align === RIGHT || align === NULL ? DASH : COLON
+ value += pad(spacing - 2, DASH)
+ value += align !== LEFT && align !== NULL ? COLON : DASH
- rule[index] = value;
+ rule[index] = value
}
- rows.splice(1, 0, rule.join(delimiter));
+ rows.splice(1, 0, rule.join(delimiter))
}
return start + rows.join(end + NEW_LINE + start) + end
}
-function stringify$6(value) {
+function stringify(value) {
return value === null || value === undefined ? '' : String(value)
}
@@ -30549,296 +35154,186 @@ function lengthNoop(value) {
}
/* Get a string consisting of `length` `character`s. */
-function pad$2(length, character) {
+function pad(length, character) {
return new Array(length + 1).join(character || SPACE)
}
/* Get the position of the last dot in `value`. */
-function dotindex$1(value) {
- var match = EXPRESSION_LAST_DOT.exec(value);
+function dotindex(value) {
+ var match = EXPRESSION_LAST_DOT.exec(value)
return match ? match.index + 1 : value.length
}
-var table_1$2 = table$2;
-
-var space$29 = ' ';
-var verticalBar$2 = '|';
-
-// 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$2(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();
+/***/ }),
+/* 301 */
+/***/ (function(module, exports, __webpack_require__) {
- if (loose) {
- start = '';
- end = '';
- } else if (spaced) {
- start = verticalBar$2 + space$29;
- end = space$29 + verticalBar$2;
- } else {
- start = verticalBar$2;
- end = verticalBar$2;
- }
+"use strict";
- return markdownTable_1(result, {
- align: node.align,
- pad: pad,
- start: start,
- end: end,
- stringLength: stringLength,
- delimiter: spaced ? space$29 + verticalBar$2 + space$29 : verticalBar$2
- })
-}
-var tableCell_1 = tableCell;
+module.exports = tableCell
function tableCell(node) {
return this.all(node).join('')
}
-var compiler = Compiler;
-// Construct a new compiler.
-function Compiler(tree, file) {
- this.inLink = false;
- this.inTable = false;
- this.tree = tree;
- this.file = file;
- this.options = immutable(this.options);
- this.setOptions({});
+/***/ }),
+/* 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 <tituswormer@gmail.com> (http://wooorm.com)","contributors":["Titus Wormer <tituswormer@gmail.com> (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 (`<!--lint ignore-->`).
+ * All rules are in their own packages and presets. */
+function lint() {
+ this.use(lintMessageControl)
}
-var proto$6 = Compiler.prototype;
+function lintMessageControl() {
+ return control({name: 'lint', source: 'remark-lint'})
+}
-// Enter and exit helpers. */
-proto$6.enterLink = stateToggle('inLink', false);
-proto$6.enterTable = stateToggle('inTable', false);
-proto$6.enterLinkReference = enterLinkReference;
-// Configuration.
-proto$6.options = defaults$5;
-proto$6.setOptions = setOptions_1$2;
+/***/ }),
+/* 306 */
+/***/ (function(module, exports, __webpack_require__) {
-proto$6.compile = compile_1;
-proto$6.visit = one_1;
-proto$6.all = all_1;
-proto$6.block = block_1;
-proto$6.visitOrderedItems = orderedItems_1;
-proto$6.visitUnorderedItems = unorderedItems_1;
+"use strict";
-// Expose visitors.
-proto$6.visitors = {
- root: root_1,
- text: text_1$2,
- heading: heading_1,
- paragraph: paragraph_1$2,
- blockquote: blockquote_1$2,
- list: list_1$2,
- listItem: listItem_1,
- inlineCode: inlineCode_1,
- code: code_1,
- html: html_1,
- thematicBreak: thematicBreak$1,
- strong: strong_1$2,
- emphasis: emphasis_1$2,
- break: _break$4,
- delete: _delete$4,
- link: link_1$2,
- linkReference: linkReference_1,
- imageReference: imageReference_1,
- definition: definition_1$2,
- image: image_1,
- footnote: footnote_1,
- footnoteReference: footnoteReference_1,
- footnoteDefinition: footnoteDefinition_1$2,
- table: table_1$2,
- tableCell: tableCell_1
-};
-var remarkStringify = stringify$7;
-stringify$7.Compiler = compiler;
+var control = __webpack_require__(307);
+var marker = __webpack_require__(308);
+var xtend = __webpack_require__(7);
-function stringify$7(options) {
- var Local = unherit_1(compiler);
- Local.prototype.options = immutable(
- Local.prototype.options,
- this.data('settings'),
- options
- );
- this.Compiler = Local;
-}
-
-var remark = unified_1()
- .use(remarkParse)
- .use(remarkStringify)
- .freeze();
-
-const _args = [["remark@10.0.0","/Users/daijiro/Developments/node/tools/node-lint-md-cli-rollup"]];
-const _from = "remark@10.0.0";
-const _id = "remark@10.0.0";
-const _inBundle = false;
-const _integrity = "sha512-0fZvVmd9CgDi1qHGsRTyhpJShw60r3/4OSdRpAx+I7CmE8/Jmt829T9KWHpw2Ygw3chRZ26sMorqb8aIolU9tQ==";
-const _location = "/remark";
-const _phantomChildren = {};
-const _requested = {"type":"version","registry":true,"raw":"remark@10.0.0","name":"remark","escapedName":"remark","rawSpec":"10.0.0","saveSpec":null,"fetchSpec":"10.0.0"};
-const _requiredBy = ["/"];
-const _resolved = "https://registry.npmjs.org/remark/-/remark-10.0.0.tgz";
-const _spec = "10.0.0";
-const _where = "/Users/daijiro/Developments/node/tools/node-lint-md-cli-rollup";
-const author = {"name":"Titus Wormer","email":"tituswormer@gmail.com","url":"http://wooorm.com"};
-const bugs = {"url":"https://github.com/remarkjs/remark/issues"};
-const contributors = [{"name":"Titus Wormer","email":"tituswormer@gmail.com","url":"http://wooorm.com"}];
-const dependencies = {"remark-parse":"^6.0.0","remark-stringify":"^6.0.0","unified":"^7.0.0"};
-const description = "Markdown processor powered by plugins";
-const devDependencies = {"tape":"^4.9.1"};
-const files = ["index.js"];
-const homepage = "http://remark.js.org";
-const keywords = ["markdown","abstract","syntax","tree","ast","parse","stringify","process"];
-const license = "MIT";
-const name = "remark";
-const repository = {"type":"git","url":"https://github.com/remarkjs/remark/tree/master/packages/remark"};
-const scripts = {"test":"tape test.js"};
-const version$1 = "10.0.0";
-const xo = false;
-var _package = {
- _args: _args,
- _from: _from,
- _id: _id,
- _inBundle: _inBundle,
- _integrity: _integrity,
- _location: _location,
- _phantomChildren: _phantomChildren,
- _requested: _requested,
- _requiredBy: _requiredBy,
- _resolved: _resolved,
- _spec: _spec,
- _where: _where,
- author: author,
- bugs: bugs,
- contributors: contributors,
- dependencies: dependencies,
- description: description,
- devDependencies: devDependencies,
- files: files,
- homepage: homepage,
- keywords: keywords,
- license: license,
- name: name,
- repository: repository,
- scripts: scripts,
- version: version$1,
- xo: xo
-};
+module.exports = messageControl;
-var _package$1 = Object.freeze({
- _args: _args,
- _from: _from,
- _id: _id,
- _inBundle: _inBundle,
- _integrity: _integrity,
- _location: _location,
- _phantomChildren: _phantomChildren,
- _requested: _requested,
- _requiredBy: _requiredBy,
- _resolved: _resolved,
- _spec: _spec,
- _where: _where,
- author: author,
- bugs: bugs,
- contributors: contributors,
- dependencies: dependencies,
- description: description,
- devDependencies: devDependencies,
- files: files,
- homepage: homepage,
- keywords: keywords,
- license: license,
- name: name,
- repository: repository,
- scripts: scripts,
- version: version$1,
- xo: xo,
- default: _package
-});
+function messageControl(options) {
+ var settings = options || {};
-const name$1 = "node-lint-md-cli-rollup";
-const description$1 = "remark packaged for node markdown linting";
-const version$2 = "1.0.0";
-const devDependencies$1 = {"rollup":"^0.55.5","rollup-plugin-commonjs":"^8.0.2","rollup-plugin-json":"^2.3.1","rollup-plugin-node-resolve":"^3.4.0"};
-const dependencies$1 = {"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"};
-const scripts$1 = {"build":"rollup -c","build-node":"npm run build && cp dist/* .."};
-var _package$2 = {
- name: name$1,
- description: description$1,
- version: version$2,
- devDependencies: devDependencies$1,
- dependencies: dependencies$1,
- scripts: scripts$1
-};
+ return control(xtend(options, {
+ marker: settings.marker || marker,
+ test: settings.test || 'html'
+ }));
+}
-var _package$3 = Object.freeze({
- name: name$1,
- description: description$1,
- version: version$2,
- devDependencies: devDependencies$1,
- dependencies: dependencies$1,
- scripts: scripts$1,
- default: _package$2
-});
+
+/***/ }),
+/* 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
-};
+}
-var unifiedMessageControl = messageControl;
+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;
+ 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 + '`')
@@ -30852,51 +35347,51 @@ function messageControl(options) {
throw new Error('Expected `test` in `options`, got `' + test + '`')
}
- known = options.known;
- reset = options.reset;
- enable = options.enable || [];
- disable = options.disable || [];
- sources = options.source;
+ known = options.known
+ reset = options.reset
+ enable = options.enable || []
+ disable = options.disable || []
+ sources = options.source
if (!sources) {
- sources = [name];
+ sources = [name]
} else if (typeof sources === 'string') {
- sources = [sources];
+ sources = [sources]
}
return transformer
function transformer(tree, file) {
- var toOffset = vfileLocation(file).toOffset;
- var initial = !reset;
- var gaps = detectGaps(tree, file);
- var scope = {};
- var globals = [];
+ var toOffset = location(file).toOffset
+ var initial = !reset
+ var gaps = detectGaps(tree, file)
+ var scope = {}
+ var globals = []
- unistUtilVisit(tree, test, visitor);
+ visit(tree, test, visitor)
- file.messages = file.messages.filter(filter);
+ 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;
+ 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;
+ 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(
@@ -30905,20 +35400,20 @@ function messageControl(options) {
'`: expected ' +
"`'enable'`, `'disable'`, or `'ignore'`",
mark.node
- );
+ )
}
- length = ruleIds.length;
- index = -1;
+ length = ruleIds.length
+ index = -1
while (++index < length) {
- ruleId = ruleIds[index];
+ ruleId = ruleIds[index]
if (isKnown(ruleId, verb, mark.node)) {
- toggle(pos, verb === 'enable', ruleId);
+ toggle(pos, verb === 'enable', ruleId)
if (verb === 'ignore') {
- toggle(tail, true, ruleId);
+ toggle(tail, true, ruleId)
}
}
}
@@ -30926,20 +35421,20 @@ function messageControl(options) {
/* Apply to all rules. */
if (!length) {
if (verb === 'ignore') {
- toggle(pos, false);
- toggle(tail, true);
+ toggle(pos, false)
+ toggle(tail, true)
} else {
- toggle(pos, verb === 'enable');
- reset = verb !== 'enable';
+ toggle(pos, verb === 'enable')
+ reset = verb !== 'enable'
}
}
}
function filter(message) {
- var gapIndex = gaps.length;
- var ruleId = message.ruleId;
- var ranges = scope[ruleId];
- var pos;
+ 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) {
@@ -30949,15 +35444,15 @@ function messageControl(options) {
/* We only ignore messages if they‘re disabled,
* *not* when they’re not in the document. */
if (!message.line) {
- message.line = 1;
+ message.line = 1
}
if (!message.column) {
- message.column = 1;
+ message.column = 1
}
/* Check whether the warning is inside a gap. */
- pos = toOffset(message);
+ pos = toOffset(message)
while (gapIndex--) {
if (gaps[gapIndex].start <= pos && gaps[gapIndex].end > pos) {
@@ -30971,10 +35466,10 @@ function messageControl(options) {
/* Helper to check (and possibly warn) if a ruleId is unknown. */
function isKnown(ruleId, verb, pos) {
- var result = known ? known.indexOf(ruleId) !== -1 : true;
+ var result = known ? known.indexOf(ruleId) !== -1 : true
if (!result) {
- file.warn('Unknown rule: cannot ' + verb + " `'" + ruleId + "'`", pos);
+ file.warn('Unknown rule: cannot ' + verb + " `'" + ruleId + "'`", pos)
}
return result
@@ -30982,7 +35477,7 @@ function messageControl(options) {
/* Get the latest state of a rule. When without `ruleId`, gets global state. */
function getState(ruleId) {
- var ranges = ruleId ? scope[ruleId] : globals;
+ var ranges = ruleId ? scope[ruleId] : globals
if (ranges && ranges.length !== 0) {
return ranges[ranges.length - 1].state
@@ -31001,26 +35496,26 @@ function messageControl(options) {
/* Handle a rule. */
function toggle(pos, state, ruleId) {
- var markers = ruleId ? scope[ruleId] : globals;
- var currentState;
- var previousState;
+ var markers = ruleId ? scope[ruleId] : globals
+ var currentState
+ var previousState
if (!markers) {
- markers = [];
- scope[ruleId] = markers;
+ markers = []
+ scope[ruleId] = markers
}
- previousState = getState(ruleId);
- currentState = state;
+ previousState = getState(ruleId)
+ currentState = state
if (currentState !== previousState) {
- markers.push({state: currentState, position: pos});
+ markers.push({state: currentState, position: pos})
}
/* Toggle all known rules. */
if (!ruleId) {
for (ruleId in scope) {
- toggle(pos, state, ruleId);
+ toggle(pos, state, ruleId)
}
}
}
@@ -31028,12 +35523,12 @@ function messageControl(options) {
/* 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;
+ var index = ranges && ranges.length
+ var length = -1
+ var range
while (--index > length) {
- range = ranges[index];
+ range = ranges[index]
/* istanbul ignore if - generated marker. */
if (!range.position || !range.position.line || !range.position.column) {
@@ -31062,13 +35557,13 @@ function messageControl(options) {
/* Detect gaps in `ast`. */
function detectGaps(tree, file) {
- var lastNode = tree.children[tree.children.length - 1];
- var offset = 0;
- var isGap = false;
- var gaps = [];
+ var lastNode = tree.children[tree.children.length - 1]
+ var offset = 0
+ var isGap = false
+ var gaps = []
/* Find all gaps. */
- unistUtilVisit(tree, one);
+ visit(tree, one)
/* Get the end of the document.
* This detects if the last node was the last node.
@@ -31079,31 +35574,31 @@ function detectGaps(tree, file) {
lastNode.position &&
lastNode.position.end &&
offset === lastNode.position.end.offset &&
- trim_1(file.toString().slice(offset)) !== ''
+ trim(file.toString().slice(offset)) !== ''
) {
- update();
+ update()
update(
tree && tree.position && tree.position.end && tree.position.end.offset - 1
- );
+ )
}
return gaps
function one(node) {
- var pos = node.position;
+ var pos = node.position
- update(pos && pos.start && pos.start.offset);
+ update(pos && pos.start && pos.start.offset)
if (!node.children) {
- update(pos && pos.end && pos.end.offset);
+ update(pos && pos.end && pos.end.offset)
}
}
/* Detect a new position. */
function update(latest) {
if (latest === null || latest === undefined) {
- isGap = true;
+ isGap = true
return
}
@@ -31112,22 +35607,30 @@ function detectGaps(tree, file) {
}
if (isGap) {
- gaps.push({start: offset, end: latest});
- isGap = false;
+ gaps.push({start: offset, end: latest})
+ isGap = false
}
- offset = latest;
+ offset = latest
}
}
+
+/***/ }),
+/* 308 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
/* Expose. */
-var mdastCommentMarker = marker$1;
+module.exports = marker
/* HTML type. */
-var T_HTML = 'html';
+var T_HTML = 'html'
/* Expression for eliminating extra spaces */
-var SPACES = /\s+/g;
+var SPACES = /\s+/g
/* Expression for parsing parameters. */
var PARAMETERS = new RegExp(
@@ -31168,7 +35671,7 @@ var PARAMETERS = new RegExp(
')' +
')?',
'gi'
-);
+)
var MARKER = new RegExp(
'(' +
@@ -31181,26 +35684,26 @@ var MARKER = new RegExp(
'-->' +
'\\s*' +
')'
-);
+)
/* Parse a comment marker */
-function marker$1(node) {
- var value;
- var match;
- var params;
+function marker(node) {
+ var value
+ var match
+ var params
if (!node || node.type !== T_HTML) {
return null
}
- value = node.value;
- match = value.match(MARKER);
+ value = node.value
+ match = value.match(MARKER)
if (!match || match[1].length !== value.length) {
return null
}
- params = parameters(match[3] || '');
+ params = parameters(match[3] || '')
if (!params) {
return null
@@ -31216,53 +35719,244 @@ function marker$1(node) {
/* Parse `value` into an object. */
function parameters(value) {
- var attributes = {};
- var rest = value.replace(PARAMETERS, replacer);
+ 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 || '';
+ var result = $2 || $3 || $4 || ''
if (result === 'true' || result === '') {
- result = true;
+ result = true
} else if (result === 'false') {
- result = false;
+ result = false
} else if (!isNaN(result)) {
- result = Number(result);
+ result = Number(result)
}
- attributes[$1] = result;
+ attributes[$1] = result
return ''
}
}
-var remarkMessageControl = messageControl$1;
-function messageControl$1(options) {
- var settings = options || {};
+/***/ }),
+/* 309 */
+/***/ (function(module, exports, __webpack_require__) {
- return unifiedMessageControl(immutable(options, {
- marker: settings.marker || mdastCommentMarker,
- test: settings.test || 'html'
- }));
+"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)
+ })
+ }
+ }
}
-var remarkLint = lint;
-/* `remark-lint`. This adds support for ignoring stuff from
- * messages (`<!--lint ignore-->`).
- * All rules are in their own packages and presets. */
-function lint() {
- this.use(lintMessageControl);
+/***/ }),
+/* 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;
}
-function lintMessageControl() {
- return remarkMessageControl({name: 'lint', source: 'remark-lint'})
+/**
+ * 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
*
@@ -31272,7 +35966,7 @@ function lintMessageControl() {
* @api public
*/
-var sliced = function (args, slice, sliceEnd) {
+module.exports = function (args, slice, sliceEnd) {
var ret = [];
var len = args.length;
@@ -31285,7 +35979,7 @@ var sliced = function (args, slice, sliceEnd) {
if (sliceEnd !== undefined) {
len = sliceEnd < 0
? sliceEnd + len
- : sliceEnd;
+ : sliceEnd
}
while (len-- > start) {
@@ -31293,19 +35987,26 @@ var sliced = function (args, slice, sliceEnd) {
}
return ret;
-};
+}
+
+
+
+/***/ }),
+/* 312 */
+/***/ (function(module, exports) {
+
/**
* slice() reference.
*/
-var slice$4 = Array.prototype.slice;
+var slice = Array.prototype.slice;
/**
* Expose `co`.
*/
-var co_1 = co;
+module.exports = co;
/**
* Wrap the given generator `fn` and
@@ -31330,7 +36031,7 @@ function co(fn) {
// we only need to parse the arguments
// if gen is a generator function.
if (isGenFun) {
- var args = slice$4.call(arguments), len = args.length;
+ 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);
@@ -31353,7 +36054,7 @@ function co(fn) {
var ret;
// multiple args
- if (arguments.length > 2) res = slice$4.call(arguments, 1);
+ if (arguments.length > 2) res = slice.call(arguments, 1);
// error
if (err) {
@@ -31432,7 +36133,7 @@ function toThunk(obj, ctx) {
return obj;
}
- if (isObject$3(obj) || Array.isArray(obj)) {
+ if (isObject(obj) || Array.isArray(obj)) {
return objectToThunk.call(ctx, obj);
}
@@ -31461,7 +36162,7 @@ function objectToThunk(obj){
if (!pending) {
setImmediate(function(){
- done(null, results);
+ done(null, results)
});
return;
}
@@ -31566,7 +36267,7 @@ function isGeneratorFunction(obj) {
* @api private
*/
-function isObject$3(val) {
+function isObject(val) {
return val && Object == val.constructor;
}
@@ -31589,404 +36290,240 @@ function error(err) {
});
}
-/**
- * Module Dependencies
- */
-
-
-var noop$2 = function(){};
-
-
-/**
- * Export `wrapped`
- */
-var wrapped_1 = wrapped;
+/***/ }),
+/* 313 */
+/***/ (function(module, exports, __webpack_require__) {
+"use strict";
/**
- * Wrap a function to support
- * sync, async, and gen functions.
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module definition-spacing
+ * @fileoverview
+ * Warn when consecutive white space is used in a definition.
*
- * @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$2;
-
- // nothing
- if (!fn) {
- return done.apply(ctx, [null].concat(args));
- }
-
- // generator
- if (generator(fn)) {
- return co_1(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$2(fn, done).apply(ctx, args);
- }
-
- return wrap;
-}
-
-/**
- * Wrap a synchronous function execution.
+ * @example {"name": "valid.md"}
*
- * @param {Function} fn
- * @param {Function} done
- * @return {Function}
- * @api private
- */
-
-function sync$2(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?
+ * [example domain]: http://example.com "Example Domain"
*
- * @param {Mixed} value
- * @return {Boolean}
- * @api private
- */
-
-function generator(value) {
- return value
- && value.constructor
- && 'GeneratorFunction' == value.constructor.name;
-}
-
-
-/**
- * Is `value` a promise?
+ * @example {"name": "invalid.md", "label": "input"}
*
- * @param {Mixed} value
- * @return {Boolean}
- * @api private
+ * [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
*/
-function promise(value) {
- return value && 'function' == typeof value.then;
-}
-
-var unifiedLintRule = factory$6;
-
-function factory$6(id, rule) {
- var parts = id.split(':');
- var source = parts[0];
- var ruleId = parts[1];
- var fn = wrapped_1(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++;
- }
+var rule = __webpack_require__(0)
+var visit = __webpack_require__(1)
+var position = __webpack_require__(3)
+var generated = __webpack_require__(2)
- next();
- }
- }
- }
-}
+module.exports = rule('remark-lint:definition-spacing', definitionSpacing)
-/* Coerce a value to a severity--options tuple. */
-function coerce(name, value) {
- var def = 1;
- var result;
- var level;
+var label = /^\s*\[((?:\\[\s\S]|[^[\]])+)]/
+var reason = 'Do not use consecutive white-space in definition labels'
- /* 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
-}
-
-var unistUtilPosition = createCommonjsModule(function (module, exports) {
-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
- }
- }
-}
-});
-
-/* Expose. */
-var unistUtilGenerated = 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 : {}
-}
-
-var remarkLintCheckboxContentIndent = unifiedLintRule(
- 'remark-lint:checkbox-content-indent',
- checkboxContentIndent
-);
-
-var start = unistUtilPosition.start;
-var end = unistUtilPosition.end;
-
-var reason = 'Checkboxes should be followed by a single character';
-
-function checkboxContentIndent(tree, file) {
- var contents = String(file);
- var location = vfileLocation(file);
-
- unistUtilVisit(tree, 'listItem', visitor);
-
- function visitor(node) {
- var initial;
- var final;
- var value;
-
- /* Exit early for items without checkbox. */
- if (typeof node.checked !== 'boolean' || unistUtilGenerated(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;
+function definitionSpacing(tree, file) {
+ var contents = String(file)
- while (/[^\S\n]/.test(contents.charAt(final))) {
- final++;
- }
+ visit(tree, ['definition', 'footnoteDefinition'], validate)
- /* 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);
+ function validate(node) {
+ var start = position.start(node).offset
+ var end = position.end(node).offset
- if (value.length !== 1) {
- file.message(reason, {
- start: location.toPosition(final - value.length + 1),
- end: location.toPosition(final)
- });
+ if (
+ !generated(node) &&
+ /[ \t\n]{2,}/.test(contents.slice(start, end).match(label)[1])
+ ) {
+ file.message(reason, node)
}
}
}
-var remarkLintDefinitionSpacing = unifiedLintRule('remark-lint:definition-spacing', definitionSpacing);
-var label$2 = /^\s*\[((?:\\[\s\S]|[^[\]])+)]/;
-var reason$1 = 'Do not use consecutive white-space in definition labels';
+/***/ }),
+/* 314 */
+/***/ (function(module, exports, __webpack_require__) {
-function definitionSpacing(tree, file) {
- var contents = String(file);
+"use strict";
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module fenced-code-flag
+ * @fileoverview
+ * Check fenced code-block flags.
+ *
+ * Options: `Array.<string>` 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
+ */
- unistUtilVisit(tree, ['definition', 'footnoteDefinition'], validate);
- function validate(node) {
- var start = unistUtilPosition.start(node).offset;
- var end = unistUtilPosition.end(node).offset;
- if (
- !unistUtilGenerated(node) &&
- /[ \t\n]{2,}/.test(contents.slice(start, end).match(label$2)[1])
- ) {
- file.message(reason$1, node);
- }
- }
-}
+var rule = __webpack_require__(0)
+var visit = __webpack_require__(1)
+var position = __webpack_require__(3)
+var generated = __webpack_require__(2)
-var remarkLintFencedCodeFlag = unifiedLintRule('remark-lint:fenced-code-flag', fencedCodeFlag);
+module.exports = rule('remark-lint:fenced-code-flag', fencedCodeFlag)
-var start$1 = unistUtilPosition.start;
-var end$1 = unistUtilPosition.end;
+var start = position.start
+var end = position.end
-var fence$2 = /^ {0,3}([~`])\1{2,}/;
-var reasonInvalid = 'Invalid code-language flag';
-var reasonMissing = 'Missing code-language flag';
+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 = [];
+ var contents = String(file)
+ var allowEmpty = false
+ var flags = []
if (typeof pref === 'object' && !('length' in pref)) {
- allowEmpty = Boolean(pref.allowEmpty);
- pref = pref.flags;
+ allowEmpty = Boolean(pref.allowEmpty)
+ pref = pref.flags
}
if (typeof pref === 'object' && 'length' in pref) {
- flags = String(pref).split(',');
+ flags = String(pref).split(',')
}
- unistUtilVisit(tree, 'code', visitor);
+ visit(tree, 'code', visitor)
function visitor(node) {
- var value;
+ var value
- if (!unistUtilGenerated(node)) {
+ if (!generated(node)) {
if (node.lang) {
if (flags.length !== 0 && flags.indexOf(node.lang) === -1) {
- file.message(reasonInvalid, node);
+ file.message(reasonInvalid, node)
}
} else {
- value = contents.slice(start$1(node).offset, end$1(node).offset);
+ value = contents.slice(start(node).offset, end(node).offset)
- if (!allowEmpty && fence$2.test(value)) {
- file.message(reasonMissing, node);
+ if (!allowEmpty && fence.test(value)) {
+ file.message(reasonMissing, node)
}
}
}
}
}
-var remarkLintFinalDefinition = unifiedLintRule('remark-lint:final-definition', finalDefinition);
-var start$2 = unistUtilPosition.start;
+/***/ }),
+/* 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;
+ var last = null
- unistUtilVisit(tree, visitor, true);
+ visit(tree, visitor, true)
function visitor(node) {
- var line = start$2(node).line;
+ var line = start(node).line
/* Ignore generated nodes. */
- if (node.type === 'root' || unistUtilGenerated(node)) {
+ if (node.type === 'root' || generated(node)) {
return
}
@@ -31997,581 +36534,253 @@ function finalDefinition(tree, file) {
last +
'`)',
node
- );
+ )
}
} else if (last === null) {
- last = line;
+ last = line
}
}
}
-var remarkLintFinalNewline = unifiedLintRule('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');
- }
-}
-
-var remarkLintHardBreakSpaces = unifiedLintRule('remark-lint:hard-break-spaces', hardBreakSpaces);
-
-var reason$2 = 'Use two spaces for hard line breaks';
-function hardBreakSpaces(tree, file) {
- var contents = String(file);
+/***/ }),
+/* 316 */
+/***/ (function(module, exports, __webpack_require__) {
- unistUtilVisit(tree, 'break', visitor);
+"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
+ * ```
+ */
- function visitor(node) {
- var value;
- if (!unistUtilGenerated(node)) {
- value = contents
- .slice(unistUtilPosition.start(node).offset, unistUtilPosition.end(node).offset)
- .split('\n', 1)[0]
- .replace(/\r$/, '');
- if (value.length > 2) {
- file.message(reason$2, node);
- }
- }
- }
-}
-
-const addendum = "addenda";
-const aircraft = "aircraft";
-const alga = "algae";
-const alumna = "alumnae";
-const alumnus = "alumni";
-const amoeba = "amoebae";
-const analysis = "analyses";
-const antenna = "antennae";
-const antithesis = "antitheses";
-const apex = "apices";
-const appendix = "appendices";
-const automaton = "automata";
-const axis = "axes";
-const bacillus = "bacilli";
-const bacterium = "bacteria";
-const barracks = "barracks";
-const basis = "bases";
-const beau = "beaux";
-const bison = "bison";
-const buffalo = "buffalo";
-const bureau = "bureaus";
-const cactus = "cacti";
-const calf = "calves";
-const carp = "carp";
-const census = "censuses";
-const chassis = "chassis";
-const cherub = "cherubim";
-const child = "children";
-const cod = "cod";
-const codex = "codices";
-const concerto = "concerti";
-const corpus = "corpora";
-const crisis = "crises";
-const criterion = "criteria";
-const curriculum = "curricula";
-const datum = "data";
-const deer = "deer";
-const diagnosis = "diagnoses";
-const die$1 = "dice";
-const dwarf = "dwarfs";
-const echo = "echoes";
-const elf = "elves";
-const elk = "elk";
-const ellipsis = "ellipses";
-const embargo = "embargoes";
-const emphasis$4 = "emphases";
-const erratum = "errata";
-const fez = "fezes";
-const firmware = "firmware";
-const fish = "fish";
-const focus = "foci";
-const foot = "feet";
-const formula = "formulae";
-const fungus = "fungi";
-const gallows = "gallows";
-const genus = "genera";
-const goose = "geese";
-const graffito = "graffiti";
-const grouse = "grouse";
-const half$1 = "halves";
-const hero = "heroes";
-const hoof = "hooves";
-const hovercraft = "hovercraft";
-const hypothesis = "hypotheses";
-const index$6 = "indices";
-const kakapo = "kakapo";
-const knife = "knives";
-const larva = "larvae";
-const leaf = "leaves";
-const libretto = "libretti";
-const life = "lives";
-const loaf = "loaves";
-const locus = "loci";
-const louse = "lice";
-const man = "men";
-const matrix = "matrices";
-const means = "means";
-const medium = "media";
-const memorandum = "memoranda";
-const millennium = "millennia";
-const minutia = "minutiae";
-const moose = "moose";
-const mouse = "mice";
-const nebula = "nebulae";
-const nemesis = "nemeses";
-const neurosis = "neuroses";
-const news = "news";
-const nucleus = "nuclei";
-const oasis = "oases";
-const offspring = "offspring";
-const opus = "opera";
-const ovum = "ova";
-const ox = "oxen";
-const paralysis = "paralyses";
-const parenthesis = "parentheses";
-const person = "people";
-const phenomenon = "phenomena";
-const phylum = "phyla";
-const pike = "pike";
-const polyhedron = "polyhedra";
-const potato = "potatoes";
-const prognosis = "prognoses";
-const quiz = "quizzes";
-const radius = "radii";
-const referendum = "referenda";
-const salmon = "salmon";
-const scarf = "scarves";
-const self$1 = "selves";
-const series = "series";
-const sheep = "sheep";
-const shelf = "shelves";
-const shrimp = "shrimp";
-const spacecraft = "spacecraft";
-const species = "species";
-const spectrum = "spectra";
-const squid = "squid";
-const stimulus = "stimuli";
-const stratum = "strata";
-const swine = "swine";
-const syllabus = "syllabi";
-const symposium = "symposia";
-const synopsis = "synopses";
-const synthesis = "syntheses";
-const tableau = "tableaus";
-const that = "those";
-const thesis = "theses";
-const thief = "thieves";
-const tomato = "tomatoes";
-const tooth = "teeth";
-const trout = "trout";
-const tuna = "tuna";
-const vertebra = "vertebrae";
-const vertex = "vertices";
-const veto = "vetoes";
-const vita = "vitae";
-const vortex = "vortices";
-const watercraft = "watercraft";
-const wharf = "wharves";
-const wife = "wives";
-const wolf = "wolves";
-const woman = "women";
-var irregularPlurals = {
- addendum: addendum,
- aircraft: aircraft,
- alga: alga,
- alumna: alumna,
- alumnus: alumnus,
- amoeba: amoeba,
- analysis: analysis,
- antenna: antenna,
- antithesis: antithesis,
- apex: apex,
- appendix: appendix,
- automaton: automaton,
- axis: axis,
- bacillus: bacillus,
- bacterium: bacterium,
- barracks: barracks,
- basis: basis,
- beau: beau,
- bison: bison,
- buffalo: buffalo,
- bureau: bureau,
- cactus: cactus,
- calf: calf,
- carp: carp,
- census: census,
- chassis: chassis,
- cherub: cherub,
- child: child,
- cod: cod,
- codex: codex,
- concerto: concerto,
- corpus: corpus,
- crisis: crisis,
- criterion: criterion,
- curriculum: curriculum,
- datum: datum,
- deer: deer,
- diagnosis: diagnosis,
- die: die$1,
- dwarf: dwarf,
- echo: echo,
- elf: elf,
- elk: elk,
- ellipsis: ellipsis,
- embargo: embargo,
- emphasis: emphasis$4,
- erratum: erratum,
- fez: fez,
- firmware: firmware,
- fish: fish,
- focus: focus,
- foot: foot,
- formula: formula,
- fungus: fungus,
- gallows: gallows,
- genus: genus,
- goose: goose,
- graffito: graffito,
- grouse: grouse,
- half: half$1,
- hero: hero,
- hoof: hoof,
- hovercraft: hovercraft,
- hypothesis: hypothesis,
- index: index$6,
- kakapo: kakapo,
- knife: knife,
- larva: larva,
- leaf: leaf,
- libretto: libretto,
- life: life,
- loaf: loaf,
- locus: locus,
- louse: louse,
- man: man,
- matrix: matrix,
- means: means,
- medium: medium,
- memorandum: memorandum,
- millennium: millennium,
- minutia: minutia,
- moose: moose,
- mouse: mouse,
- nebula: nebula,
- nemesis: nemesis,
- neurosis: neurosis,
- news: news,
- nucleus: nucleus,
- oasis: oasis,
- offspring: offspring,
- opus: opus,
- ovum: ovum,
- ox: ox,
- paralysis: paralysis,
- parenthesis: parenthesis,
- person: person,
- phenomenon: phenomenon,
- phylum: phylum,
- pike: pike,
- polyhedron: polyhedron,
- potato: potato,
- prognosis: prognosis,
- quiz: quiz,
- radius: radius,
- referendum: referendum,
- salmon: salmon,
- scarf: scarf,
- self: self$1,
- series: series,
- sheep: sheep,
- shelf: shelf,
- shrimp: shrimp,
- spacecraft: spacecraft,
- species: species,
- spectrum: spectrum,
- squid: squid,
- stimulus: stimulus,
- stratum: stratum,
- swine: swine,
- syllabus: syllabus,
- symposium: symposium,
- synopsis: synopsis,
- synthesis: synthesis,
- tableau: tableau,
- that: that,
- thesis: thesis,
- thief: thief,
- tomato: tomato,
- tooth: tooth,
- trout: trout,
- tuna: tuna,
- vertebra: vertebra,
- vertex: vertex,
- veto: veto,
- vita: vita,
- vortex: vortex,
- watercraft: watercraft,
- wharf: wharf,
- wife: wife,
- wolf: wolf,
- woman: woman,
- "château": "châteaus",
- "faux pas": "faux pas",
- "this": "these"
-};
+var rule = __webpack_require__(0)
-var irregularPlurals$1 = Object.freeze({
- addendum: addendum,
- aircraft: aircraft,
- alga: alga,
- alumna: alumna,
- alumnus: alumnus,
- amoeba: amoeba,
- analysis: analysis,
- antenna: antenna,
- antithesis: antithesis,
- apex: apex,
- appendix: appendix,
- automaton: automaton,
- axis: axis,
- bacillus: bacillus,
- bacterium: bacterium,
- barracks: barracks,
- basis: basis,
- beau: beau,
- bison: bison,
- buffalo: buffalo,
- bureau: bureau,
- cactus: cactus,
- calf: calf,
- carp: carp,
- census: census,
- chassis: chassis,
- cherub: cherub,
- child: child,
- cod: cod,
- codex: codex,
- concerto: concerto,
- corpus: corpus,
- crisis: crisis,
- criterion: criterion,
- curriculum: curriculum,
- datum: datum,
- deer: deer,
- diagnosis: diagnosis,
- die: die$1,
- dwarf: dwarf,
- echo: echo,
- elf: elf,
- elk: elk,
- ellipsis: ellipsis,
- embargo: embargo,
- emphasis: emphasis$4,
- erratum: erratum,
- fez: fez,
- firmware: firmware,
- fish: fish,
- focus: focus,
- foot: foot,
- formula: formula,
- fungus: fungus,
- gallows: gallows,
- genus: genus,
- goose: goose,
- graffito: graffito,
- grouse: grouse,
- half: half$1,
- hero: hero,
- hoof: hoof,
- hovercraft: hovercraft,
- hypothesis: hypothesis,
- index: index$6,
- kakapo: kakapo,
- knife: knife,
- larva: larva,
- leaf: leaf,
- libretto: libretto,
- life: life,
- loaf: loaf,
- locus: locus,
- louse: louse,
- man: man,
- matrix: matrix,
- means: means,
- medium: medium,
- memorandum: memorandum,
- millennium: millennium,
- minutia: minutia,
- moose: moose,
- mouse: mouse,
- nebula: nebula,
- nemesis: nemesis,
- neurosis: neurosis,
- news: news,
- nucleus: nucleus,
- oasis: oasis,
- offspring: offspring,
- opus: opus,
- ovum: ovum,
- ox: ox,
- paralysis: paralysis,
- parenthesis: parenthesis,
- person: person,
- phenomenon: phenomenon,
- phylum: phylum,
- pike: pike,
- polyhedron: polyhedron,
- potato: potato,
- prognosis: prognosis,
- quiz: quiz,
- radius: radius,
- referendum: referendum,
- salmon: salmon,
- scarf: scarf,
- self: self$1,
- series: series,
- sheep: sheep,
- shelf: shelf,
- shrimp: shrimp,
- spacecraft: spacecraft,
- species: species,
- spectrum: spectrum,
- squid: squid,
- stimulus: stimulus,
- stratum: stratum,
- swine: swine,
- syllabus: syllabus,
- symposium: symposium,
- synopsis: synopsis,
- synthesis: synthesis,
- tableau: tableau,
- that: that,
- thesis: thesis,
- thief: thief,
- tomato: tomato,
- tooth: tooth,
- trout: trout,
- tuna: tuna,
- vertebra: vertebra,
- vertex: vertex,
- veto: veto,
- vita: vita,
- vortex: vortex,
- watercraft: watercraft,
- wharf: wharf,
- wife: wife,
- wolf: wolf,
- woman: woman,
- default: irregularPlurals
-});
+module.exports = rule('remark-lint:final-newline', finalNewline)
-var irregularPlurals$2 = ( irregularPlurals$1 && irregularPlurals ) || irregularPlurals$1;
+function finalNewline(tree, file) {
+ var contents = String(file)
+ var last = contents.length - 1
-var irregularPlurals_1 = createCommonjsModule(function (module) {
-const map = new Map();
-// TODO: Use Object.entries when targeting Node.js 8
-for (const key of Object.keys(irregularPlurals$2)) {
- map.set(key, irregularPlurals$2[key]);
+ if (last > -1 && contents.charAt(last) !== '\n') {
+ file.message('Missing newline character at end of file')
+ }
}
-// Ensure nobody can modify each others Map
-Object.defineProperty(module, 'exports', {
- get() {
- return map;
- }
-});
-});
-var plur = createCommonjsModule(function (module) {
-module.exports = (word, plural, count) => {
- if (typeof plural === 'number') {
- count = plural;
- }
+/***/ }),
+/* 317 */
+/***/ (function(module, exports, __webpack_require__) {
- if (irregularPlurals_1.has(word.toLowerCase())) {
- plural = irregularPlurals_1.get(word.toLowerCase());
+"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'`
+ */
- 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;
-};
-});
+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 remarkLintListItemIndent = unifiedLintRule('remark-lint:list-item-indent', listItemIndent);
+module.exports = rule('remark-lint:list-item-indent', listItemIndent)
-var start$3 = unistUtilPosition.start;
+var start = position.start
-var styles = {'tab-size': true, mixed: true, space: true};
+var styles = {'tab-size': true, mixed: true, space: true}
function listItemIndent(tree, file, pref) {
- var contents = String(file);
+ var contents = String(file)
- pref = typeof pref === 'string' ? pref : 'tab-size';
+ 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'`"
- );
+ )
}
- unistUtilVisit(tree, 'list', visitor);
+ visit(tree, 'list', visitor)
function visitor(node) {
- var spread = node.spread || node.loose;
+ var spread = node.spread || node.loose
- if (!unistUtilGenerated(node)) {
- node.children.forEach(visitItem);
+ if (!generated(node)) {
+ node.children.forEach(visitItem)
}
function visitItem(item) {
- var head = item.children[0];
- var final = start$3(head);
- var marker;
- var bulletSize;
- var style;
- var diff;
- var reason;
+ var head = item.children[0]
+ var final = start(head)
+ var marker
+ var bulletSize
+ var style
+ var diff
+ var reason
marker = contents
- .slice(start$3(item).offset, final.offset)
- .replace(/\[[x ]?]\s*$/i, '');
+ .slice(start(item).offset, final.offset)
+ .replace(/\[[x ]?]\s*$/i, '')
- bulletSize = marker.trimRight().length;
+ bulletSize = marker.trimRight().length
style =
pref === 'tab-size' || (pref === 'mixed' && spread)
? Math.ceil(bulletSize / 4) * 4
- : bulletSize + 1;
+ : bulletSize + 1
if (marker.length !== style) {
- diff = style - marker.length;
+ diff = style - marker.length
reason =
'Incorrect list-item indent: ' +
@@ -32579,39 +36788,171 @@ function listItemIndent(tree, file, pref) {
' ' +
Math.abs(diff) +
' ' +
- plur('space', diff);
+ plural('space', diff)
- file.message(reason, final);
+ file.message(reason, final)
}
}
}
}
-var remarkLintMaximumLineLength = unifiedLintRule('remark-lint:maximum-line-length', maximumLineLength);
-var start$4 = unistUtilPosition.start;
-var end$2 = unistUtilPosition.end;
+/***/ }),
+/* 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: <http://this-long-url-with-a-long-domain.co.uk/a-long-path?query=variables>
+ *
+ * <http://this-link-is-fine.com>
+ *
+ * `alphaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJuliettKiloLimaMikeNovemberOscarPapaQuebec.romeo()`
+ *
+ * [foo](http://this-long-url-with-a-long-domain-is-valid.co.uk/a-long-path?query=variables)
+ *
+ * <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.
+ *
+ * <http://this-long-url-with-a-long-domain-is-invalid.co.uk/a-long-path?query=variables>.
+ *
+ * In addition, definitions are also fine:
+ *
+ * [foo]: <http://this-long-url-with-a-long-domain-is-invalid.co.uk/a-long-path?query=variables>
+ *
+ * @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: <http://line.com>
+ *
+ * <http://this-long-url-with-a-long-domain-is-invalid.co.uk/a-long-path?query=variables> 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;
+ 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
- unistUtilVisit(tree, ['heading', 'table', 'code', 'definition'], ignore);
- unistUtilVisit(tree, ['link', 'image', 'inlineCode'], inline);
+ 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;
+ lineLength = lines[index].length
if (lineLength > style) {
file.message('Line must be at most ' + style + ' characters', {
line: index + 1,
column: lineLength + 1
- });
+ })
}
}
@@ -32619,17 +36960,17 @@ function maximumLineLength(tree, file, pref) {
* 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;
+ var next = parent.children[pos + 1]
+ var initial
+ var final
/* istanbul ignore if - Nothing to whitelist when generated. */
- if (unistUtilGenerated(node)) {
+ if (generated(node)) {
return
}
- initial = start$4(node);
- final = end$2(node);
+ initial = start(node)
+ final = end(node)
/* No whitelisting when starting after the border, or ending before it. */
if (initial.column > style || final.column < style) {
@@ -32640,124 +36981,197 @@ function maximumLineLength(tree, file, pref) {
* the link. */
if (
next &&
- start$4(next).line === initial.line &&
+ start(next).line === initial.line &&
(!next.value || /^(.+?[ \t].+?)/.test(next.value))
) {
return
}
- whitelist(initial.line - 1, final.line);
+ 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 (!unistUtilGenerated(node)) {
- whitelist(start$4(node).line - 1, end$2(node).line);
+ 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++] = '';
+ lines[initial++] = ''
}
}
}
-var mdastUtilToString = toString$6;
-/* 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$6(node) {
- return (
- valueOf$1(node) ||
- (node.children && node.children.map(toString$6).join('')) ||
- ''
- )
-}
+/***/ }),
+/* 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"}
+ *
+ * <http://www.example.com>
+ * <mailto:foo@bar.com>
+ *
+ * Most markdown vendors don’t recognize the following as a link:
+ * <www.example.com>
+ *
+ * @example {"name": "invalid.md", "label": "input"}
+ *
+ * <foo@bar.com>
+ *
+ * @example {"name": "invalid.md", "label": "output"}
+ *
+ * 1:1-1:14: All automatic links must start with a protocol
+ */
-/* Get the value of `node`. Checks, `value`,
- * `alt`, and `title`, in that order. */
-function valueOf$1(node) {
- return (
- (node && node.value ? node.value : node.alt ? node.alt : node.title) || ''
- )
-}
-var remarkLintNoAutoLinkWithoutProtocol = unifiedLintRule(
+
+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$5 = unistUtilPosition.start;
-var end$3 = unistUtilPosition.end;
+var start = position.start
+var end = position.end
/* Protocol expression. See:
* http://en.wikipedia.org/wiki/URI_scheme#Generic_syntax */
-var protocol$2 = /^[a-z][a-z+.-]+:\/?/i;
+var protocol = /^[a-z][a-z+.-]+:\/?/i
-var reason$3 = 'All automatic links must start with a protocol';
+var reason = 'All automatic links must start with a protocol'
function noAutoLinkWithoutProtocol(tree, file) {
- unistUtilVisit(tree, 'link', visitor);
+ visit(tree, 'link', visitor)
function visitor(node) {
- var children;
+ var children
- if (!unistUtilGenerated(node)) {
- children = node.children;
+ if (!generated(node)) {
+ children = node.children
if (
- start$5(node).column === start$5(children[0]).column - 1 &&
- end$3(node).column === end$3(children[children.length - 1]).column + 1 &&
- !protocol$2.test(mdastUtilToString(node))
+ 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$3, node);
+ file.message(reason, node)
}
}
}
}
-var remarkLintNoBlockquoteWithoutMarker = unifiedLintRule(
+
+/***/ }),
+/* 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$4 = 'Missing marker in blockquote';
+var reason = 'Missing marker in blockquote'
function noBlockquoteWithoutMarker(tree, file) {
- var contents = String(file);
- var location = vfileLocation(file);
- var last = contents.length;
+ var contents = String(file)
+ var location = vfileLocation(file)
+ var last = contents.length
- unistUtilVisit(tree, 'blockquote', visitor);
+ 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 (unistUtilGenerated(node) || !indent || indent.length === 0) {
+ 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 = unistUtilPosition.start(node).line;
- length = indent.length;
- index = -1;
+ 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;
+ line = start + index + 1
+ pos = {line: line, column: indent[index]}
+ offset = location.toOffset(pos) - 1
while (++offset < last) {
- character = contents.charAt(offset);
+ character = contents.charAt(offset)
if (character === '>') {
break
@@ -32765,7 +37179,7 @@ function noBlockquoteWithoutMarker(tree, file) {
/* istanbul ignore else - just for safety */
if (character !== ' ' && character !== '\t') {
- file.message(reason$4, pos);
+ file.message(reason, pos)
break
}
}
@@ -32773,159 +37187,316 @@ function noBlockquoteWithoutMarker(tree, file) {
}
}
-var remarkLintNoDuplicateDefinitions = unifiedLintRule(
+
+/***/ }),
+/* 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$5 = 'Do not use definitions with the same identifier';
+var reason = 'Do not use definitions with the same identifier'
function noDuplicateDefinitions(tree, file) {
- var map = {};
+ var map = {}
- unistUtilVisit(tree, ['definition', 'footnoteDefinition'], validate);
+ visit(tree, ['definition', 'footnoteDefinition'], validate)
function validate(node) {
- var identifier;
- var duplicate;
+ var identifier
+ var duplicate
- if (!unistUtilGenerated(node)) {
- identifier = node.identifier;
- duplicate = map[identifier];
+ if (!generated(node)) {
+ identifier = node.identifier
+ duplicate = map[identifier]
if (duplicate && duplicate.type) {
file.message(
- reason$5 + ' (' + unistUtilStringifyPosition(unistUtilPosition.start(duplicate)) + ')',
+ reason + ' (' + stringify(position.start(duplicate)) + ')',
node
- );
+ )
}
- map[identifier] = node;
+ map[identifier] = node
}
}
}
-var remarkLintNoFileNameArticles = unifiedLintRule('remark-lint:no-file-name-articles', noFileNameArticles);
+
+/***/ }),
+/* 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);
+ var match = file.stem && file.stem.match(/^(the|teh|an?)\b/i)
if (match) {
- file.message('Do not start file names with `' + match[0] + '`');
+ file.message('Do not start file names with `' + match[0] + '`')
}
}
-var remarkLintNoFileNameConsecutiveDashes = unifiedLintRule(
+
+/***/ }),
+/* 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$6 = 'Do not use consecutive dashes in a file name';
+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$6);
+ file.message(reason)
}
}
-var remarkLintNoFileNameOuterDashes = unifiedLintRule(
+
+/***/ }),
+/* 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$7 = 'Do not use initial or final dashes in a file name';
+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$7);
+ file.message(reason)
}
}
-var mdastUtilHeadingStyle = 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'
- }
+/***/ }),
+/* 327 */
+/***/ (function(module, exports, __webpack_require__) {
- if (final.line + 1 === pos.line) {
- return 'setext'
- }
+"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
+ */
- 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
-}
+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)
-var remarkLintNoHeadingContentIndent = unifiedLintRule(
+module.exports = rule(
'remark-lint:no-heading-content-indent',
noHeadingContentIndent
-);
+)
-var start$6 = unistUtilPosition.start;
-var end$4 = unistUtilPosition.end;
+var start = position.start
+var end = position.end
function noHeadingContentIndent(tree, file) {
- var contents = String(file);
+ var contents = String(file)
- unistUtilVisit(tree, 'heading', visitor);
+ 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 (unistUtilGenerated(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 = mdastUtilHeadingStyle(node, 'atx');
+ depth = node.depth
+ children = node.children
+ type = style(node, 'atx')
if (type === 'atx' || type === 'atx-closed') {
- initial = start$6(node);
- index = initial.offset;
- char = contents.charAt(index);
+ initial = start(node)
+ index = initial.offset
+ char = contents.charAt(index)
while (char && char !== '#') {
- char = contents.charAt(++index);
+ char = contents.charAt(++index)
}
/* istanbul ignore if - CR/LF bug: remarkjs/remark#195. */
@@ -32933,15 +37504,15 @@ function noHeadingContentIndent(tree, file) {
return
}
- index = depth + (index - initial.offset);
- head = start$6(children[0]).column;
+ index = depth + (index - initial.offset)
+ head = start(children[0]).column
/* Ignore empty headings. */
if (!head) {
return
}
- diff = head - initial.column - 1 - index;
+ diff = head - initial.column - 1 - index
if (diff) {
reason =
@@ -32949,10 +37520,10 @@ function noHeadingContentIndent(tree, file) {
' ' +
Math.abs(diff) +
' ' +
- plur('space', diff) +
- ' before this heading’s content';
+ plural('space', diff) +
+ ' before this heading’s content'
- file.message(reason, start$6(children[0]));
+ file.message(reason, start(children[0]))
}
}
@@ -32960,123 +37531,319 @@ function noHeadingContentIndent(tree, file) {
* between their content and the final hashes,
* thus, there is no `add x spaces`. */
if (type === 'atx-closed') {
- final = end$4(children[children.length - 1]);
- diff = end$4(node).column - final.column - 1 - depth;
+ final = end(children[children.length - 1])
+ diff = end(node).column - final.column - 1 - depth
if (diff) {
reason =
'Remove ' +
diff +
' ' +
- plur('space', diff) +
- ' after this heading’s content';
+ plural('space', diff) +
+ ' after this heading’s content'
- file.message(reason, final);
+ file.message(reason, final)
}
}
}
}
-var remarkLintNoHeadingIndent = unifiedLintRule('remark-lint:no-heading-indent', noHeadingIndent);
-var start$7 = unistUtilPosition.start;
+/***/ }),
+/* 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;
+ var contents = String(file)
+ var length = contents.length
- unistUtilVisit(tree, 'heading', visitor);
+ visit(tree, 'heading', visitor)
function visitor(node) {
- var initial;
- var begin;
- var index;
- var character;
- var diff;
+ var initial
+ var begin
+ var index
+ var character
+ var diff
- if (unistUtilGenerated(node)) {
+ if (generated(node)) {
return
}
- initial = start$7(node);
- begin = initial.offset;
- index = begin - 1;
+ initial = start(node)
+ begin = initial.offset
+ index = begin - 1
while (++index < length) {
- character = contents.charAt(index);
+ character = contents.charAt(index)
if (character !== ' ' && character !== '\t') {
break
}
}
- diff = index - begin;
+ diff = index - begin
if (diff) {
file.message(
- 'Remove ' + diff + ' ' + plur('space', diff) + ' before this heading',
+ 'Remove ' + diff + ' ' + plural('space', diff) + ' before this heading',
{
line: initial.line,
column: initial.column + diff
}
- );
+ )
}
}
}
-var remarkLintNoInlinePadding = unifiedLintRule('remark-lint:no-inline-padding', noInlinePadding);
+
+/***/ }),
+/* 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) {
- unistUtilVisit(tree, ['emphasis', 'strong', 'delete', 'image', 'link'], visitor);
+ visit(tree, ['emphasis', 'strong', 'delete', 'image', 'link'], visitor)
function visitor(node) {
- var contents;
+ var contents
- if (!unistUtilGenerated(node)) {
- contents = mdastUtilToString(node);
+ 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);
+ file.message('Don’t pad `' + node.type + '` with inner spaces', node)
}
}
}
}
-var start$8 = unistUtilPosition.start;
+/***/ }),
+/* 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)
-var remarkLintNoMultipleToplevelHeadings = unifiedLintRule(
+module.exports = rule(
'remark-lint:no-multiple-toplevel-headings',
noMultipleToplevelHeadings
-);
+)
function noMultipleToplevelHeadings(tree, file, pref) {
- var style = pref ? pref : 1;
- var duplicate;
+ var style = pref ? pref : 1
+ var duplicate
- unistUtilVisit(tree, 'heading', visitor);
+ visit(tree, 'heading', visitor)
function visitor(node) {
- if (!unistUtilGenerated(node) && node.depth === style) {
+ if (!generated(node) && node.depth === style) {
if (duplicate) {
file.message(
'Don’t use multiple top level headings (' + duplicate + ')',
node
- );
+ )
} else {
- duplicate = unistUtilStringifyPosition(start$8(node));
+ duplicate = stringify(start(node))
}
}
}
}
-var remarkLintNoShellDollars = unifiedLintRule('remark-lint:no-shell-dollars', noShellDollars);
-var reason$8 = 'Do not use dollar signs before shell-commands';
+/***/ }),
+/* 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):
@@ -33093,102 +37860,268 @@ var flags = [
'tmux',
'tool',
'zsh'
-];
+]
function noShellDollars(tree, file) {
- unistUtilVisit(tree, 'code', visitor);
+ visit(tree, 'code', visitor)
function visitor(node) {
- var lines;
- var line;
- var length;
- var index;
+ var lines
+ var line
+ var length
+ var index
/* Check both known shell-code and unknown code. */
- if (!unistUtilGenerated(node) && node.lang && flags.indexOf(node.lang) !== -1) {
- lines = node.value.split('\n');
- length = lines.length;
- index = -1;
+ 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];
+ line = lines[index]
if (line.trim() && !line.match(/^\s*\$\s*/)) {
return
}
}
- file.message(reason$8, node);
+ file.message(reason, node)
}
}
}
-var remarkLintNoShortcutReferenceImage = unifiedLintRule(
+
+/***/ }),
+/* 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$9 = 'Use the trailing [] on reference images';
+var reason = 'Use the trailing [] on reference images'
function noShortcutReferenceImage(tree, file) {
- unistUtilVisit(tree, 'imageReference', visitor);
+ visit(tree, 'imageReference', visitor)
function visitor(node) {
- if (!unistUtilGenerated(node) && node.referenceType === 'shortcut') {
- file.message(reason$9, node);
+ if (!generated(node) && node.referenceType === 'shortcut') {
+ file.message(reason, node)
}
}
}
-var remarkLintNoTableIndentation = unifiedLintRule('remark-lint:no-table-indentation', noTableIndentation);
-var reason$10 = 'Do not indent table rows';
+/***/ }),
+/* 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);
+ var contents = String(file)
- unistUtilVisit(tree, 'table', visitor);
+ visit(tree, 'table', visitor)
function visitor(node) {
- if (!unistUtilGenerated(node)) {
- node.children.forEach(each);
+ if (!generated(node)) {
+ node.children.forEach(each)
}
- return unistUtilVisit.SKIP
+ return visit.SKIP
}
function each(row) {
var fence = contents.slice(
- unistUtilPosition.start(row).offset,
- unistUtilPosition.start(row.children[0]).offset
- );
+ position.start(row).offset,
+ position.start(row.children[0]).offset
+ )
if (fence.indexOf('|') > 1) {
- file.message(reason$10, row);
+ file.message(reason, row)
}
}
}
-var remarkLintNoTabs = unifiedLintRule('remark-lint:no-tabs', noTabs);
-var reason$11 = 'Use spaces instead of hard-tabs';
+/***/ }),
+/* 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 = vfileLocation(file).toPosition;
- var index = content.indexOf('\t');
+ var content = String(file)
+ var position = location(file).toPosition
+ var index = content.indexOf('\t')
while (index !== -1) {
- file.message(reason$11, position(index));
- index = content.indexOf('\t', index + 1);
+ file.message(reason, position(index))
+ index = content.indexOf('\t', index + 1)
}
}
-var remarkLintNoTrailingSpaces = unifiedLintRule('remark-lint:no-trailing-spaces', noTrailingSpaces);
+
+/***/ }),
+/* 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
@@ -33211,149 +38144,363 @@ function noTrailingSpaces(ast, file) {
}
}
-var remarkLintNoUnusedDefinitions = unifiedLintRule('remark-lint:no-unused-definitions', noUnusedDefinitions);
-var reason$12 = 'Found unused definition';
+/***/ }),
+/* 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;
+ var map = {}
+ var identifier
+ var entry
- unistUtilVisit(tree, ['definition', 'footnoteDefinition'], find);
- unistUtilVisit(tree, ['imageReference', 'linkReference', 'footnoteReference'], mark);
+ visit(tree, ['definition', 'footnoteDefinition'], find)
+ visit(tree, ['imageReference', 'linkReference', 'footnoteReference'], mark)
for (identifier in map) {
- entry = map[identifier];
+ entry = map[identifier]
if (!entry.used) {
- file.message(reason$12, entry.node);
+ file.message(reason, entry.node)
}
}
function find(node) {
- if (!unistUtilGenerated(node)) {
- map[node.identifier.toUpperCase()] = {node: node, used: false};
+ if (!generated(node)) {
+ map[node.identifier.toUpperCase()] = {node: node, used: false}
}
}
function mark(node) {
- var info = map[node.identifier.toUpperCase()];
+ var info = map[node.identifier.toUpperCase()]
- if (!unistUtilGenerated(node) && info) {
- info.used = true;
+ if (!generated(node) && info) {
+ info.used = true
}
}
}
-var rule$1 = unifiedLintRule;
+/***/ }),
+/* 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 remarkLintRuleStyle = rule$1('remark-lint:rule-style', ruleStyle);
-var start$9 = unistUtilPosition.start;
-var end$5 = unistUtilPosition.end;
+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);
+ var contents = String(file)
- pref = typeof pref === 'string' && pref !== 'consistent' ? pref : null;
+ 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'`"
- );
+ )
}
- unistUtilVisit(tree, 'thematicBreak', visitor);
+ visit(tree, 'thematicBreak', visitor)
function visitor(node) {
- var initial = start$9(node).offset;
- var final = end$5(node).offset;
- var rule;
+ var initial = start(node).offset
+ var final = end(node).offset
+ var rule
- if (!unistUtilGenerated(node)) {
- rule = contents.slice(initial, final);
+ if (!generated(node)) {
+ rule = contents.slice(initial, final)
if (pref) {
if (rule !== pref) {
- file.message('Rules should use `' + pref + '`', node);
+ file.message('Rules should use `' + pref + '`', node)
}
} else {
- pref = rule;
+ pref = rule
}
}
}
}
-var remarkLintTablePipes = unifiedLintRule('remark-lint:table-pipes', tablePipes);
-var start$10 = unistUtilPosition.start;
-var end$6 = unistUtilPosition.end;
+/***/ }),
+/* 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 reasonStart = 'Missing initial pipe in table fence';
-var reasonEnd = '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);
+ var contents = String(file)
- unistUtilVisit(tree, 'table', visitor);
+ 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;
+ 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];
+ row = rows[index]
- if (!unistUtilGenerated(row)) {
- cells = row.children;
- head = cells[0];
- tail = cells[cells.length - 1];
- initial = contents.slice(start$10(row).offset, start$10(head).offset);
- final = contents.slice(end$6(tail).offset, end$6(row).offset);
+ 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$10(row));
+ file.message(reasonStart, start(row))
}
if (final.indexOf('|') === -1) {
- file.message(reasonEnd, end$6(row));
+ file.message(reasonEnd, end(row))
}
}
}
}
}
-var remarkLintBlockquoteIndentation = unifiedLintRule(
+
+/***/ }),
+/* 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;
+ pref = typeof pref === 'number' && !isNaN(pref) ? pref : null
- unistUtilVisit(tree, 'blockquote', visitor);
+ visit(tree, 'blockquote', visitor)
function visitor(node) {
- var diff;
- var reason;
+ var diff
+ var reason
- if (unistUtilGenerated(node) || node.children.length === 0) {
+ if (generated(node) || node.children.length === 0) {
return
}
if (pref) {
- diff = pref - check$3(node);
+ diff = pref - check(node)
if (diff !== 0) {
reason =
@@ -33361,53 +38508,137 @@ function blockquoteIndentation(tree, file, pref) {
' ' +
Math.abs(diff) +
' ' +
- plur('space', diff) +
- ' between blockquote and content';
+ plural('space', diff) +
+ ' between blockquote and content'
- file.message(reason, unistUtilPosition.start(node.children[0]));
+ file.message(reason, position.start(node.children[0]))
}
} else {
- pref = check$3(node);
+ pref = check(node)
}
}
}
-function check$3(node) {
- var head = node.children[0];
- var indentation = unistUtilPosition.start(head).column - unistUtilPosition.start(node).column;
- var padding = mdastUtilToString(head).match(/^ +/);
+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;
+ indentation += padding[0].length
}
return indentation
}
-var remarkLintCheckboxCharacterStyle = unifiedLintRule(
+
+/***/ }),
+/* 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$11 = unistUtilPosition.start;
-var end$7 = unistUtilPosition.end;
+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'};
+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);
+ var contents = String(file)
+ var location = vfileLocation(file)
- pref = typeof pref === 'object' ? pref : {};
+ 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) {
@@ -33415,38 +38646,38 @@ function checkboxCharacterStyle(tree, file, pref) {
'Invalid checked checkbox marker `' +
pref.checked +
"`: use either `'x'`, or `'X'`"
- );
+ )
}
- unistUtilVisit(tree, 'listItem', visitor);
+ visit(tree, 'listItem', visitor)
function visitor(node) {
- var type;
- var initial;
- var final;
- var value;
- var style;
- var character;
- var reason;
+ 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' || unistUtilGenerated(node)) {
+ if (typeof node.checked !== 'boolean' || generated(node)) {
return
}
- type = types[node.checked];
- initial = start$11(node).offset;
- final = (node.children.length ? start$11(node.children[0]) : end$7(node)).offset;
+ 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);
+ .slice(0, -1)
/* The checkbox character is behind a square bracket. */
- character = value.charAt(value.length - 1);
- style = pref[type];
+ character = value.charAt(value.length - 1)
+ style = pref[type]
if (style) {
if (character !== style) {
@@ -33455,59 +38686,165 @@ function checkboxCharacterStyle(tree, file, pref) {
type.slice(1) +
' checkboxes should use `' +
style +
- '` as a marker';
+ '` as a marker'
file.message(reason, {
start: location.toPosition(initial + value.length - 1),
end: location.toPosition(initial + value.length)
- });
+ })
}
} else {
- pref[type] = character;
+ pref[type] = character
}
}
}
-var remarkLintCodeBlockStyle = unifiedLintRule('remark-lint:code-block-style', codeBlockStyle);
-var start$12 = unistUtilPosition.start;
-var end$8 = unistUtilPosition.end;
+/***/ }),
+/* 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 styles$1 = {null: true, fenced: true, indented: true};
+
+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);
+ var contents = String(file)
- pref = typeof pref === 'string' && pref !== 'consistent' ? pref : null;
+ pref = typeof pref === 'string' && pref !== 'consistent' ? pref : null
- if (styles$1[pref] !== true) {
+ if (styles[pref] !== true) {
file.fail(
'Invalid code block style `' +
pref +
"`: use either `'consistent'`, `'fenced'`, or `'indented'`"
- );
+ )
}
- unistUtilVisit(tree, 'code', visitor);
+ visit(tree, 'code', visitor)
function visitor(node) {
- var current = check(node);
+ var current = check(node)
if (current) {
if (!pref) {
- pref = current;
+ pref = current
} else if (pref !== current) {
- file.message('Code blocks should be ' + pref, node);
+ file.message('Code blocks should be ' + pref, node)
}
}
}
/* Get the style of `node`. */
function check(node) {
- var initial = start$12(node).offset;
- var final = end$8(node).offset;
+ var initial = start(node).offset
+ var final = end(node).offset
- if (unistUtilGenerated(node)) {
+ if (generated(node)) {
return null
}
@@ -33517,37 +38854,118 @@ function codeBlockStyle(tree, file, pref) {
}
}
-var remarkLintFencedCodeMarker = unifiedLintRule('remark-lint:fenced-code-marker', fencedCodeMarker);
+
+/***/ }),
+/* 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);
+ var contents = String(file)
- pref = typeof pref === 'string' && pref !== 'consistent' ? pref : null;
+ pref = typeof pref === 'string' && pref !== 'consistent' ? pref : null
if (markers[pref] !== true) {
file.fail(
'Invalid fenced code marker `' +
pref +
"`: use either `'consistent'`, `` '`' ``, or `'~'`"
- );
+ )
}
- unistUtilVisit(tree, 'code', visitor);
+ visit(tree, 'code', visitor)
function visitor(node) {
- var marker;
+ var marker
- if (!unistUtilGenerated(node)) {
+ if (!generated(node)) {
marker = contents
- .substr(unistUtilPosition.start(node).offset, 4)
+ .substr(position.start(node).offset, 4)
.trimLeft()
- .charAt(0);
+ .charAt(0)
/* Ignore unfenced code blocks. */
if (markers[marker] === true) {
@@ -33556,86 +38974,301 @@ function fencedCodeMarker(tree, file, pref) {
file.message(
'Fenced code should use ' + pref + ' as a marker',
node
- );
+ )
}
} else {
- pref = marker;
+ pref = marker
}
}
}
}
}
-var remarkLintFileExtension = unifiedLintRule('remark-lint:file-extension', fileExtension);
+
+/***/ }),
+/* 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;
+ var ext = file.extname
- pref = typeof pref === 'string' ? pref : 'md';
+ pref = typeof pref === 'string' ? pref : 'md'
if (ext && ext.slice(1) !== pref) {
- file.message('Invalid extension: use `' + pref + '`');
+ file.message('Invalid extension: use `' + pref + '`')
}
}
-var remarkLintFirstHeadingLevel = unifiedLintRule('remark-lint:first-heading-level', firstHeadingLevel);
-var re$3 = /<h([1-6])/;
+/***/ }),
+/* 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"}
+ *
+ * <h1>An HTML heading is also seen by this rule.</h1>
+ *
+ * @example {"name": "valid-delayed.md"}
+ *
+ * You can use markdown content before the heading.
+ *
+ * <div>Or non-heading HTML</div>
+ *
+ * <h1>So the first heading, be it HTML or markdown, is checked</h1>
+ *
+ * @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"}
+ *
+ * <h2>Charlie</h2>
+ *
+ * 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}
+ *
+ * <h2>Echo</h2>
+ *
+ * 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"}
+ *
+ * <h1>Golf</h1>
+ *
+ * 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 = /<h([1-6])/
function firstHeadingLevel(tree, file, pref) {
- var style = pref && pref !== true ? pref : 1;
+ var style = pref && pref !== true ? pref : 1
- unistUtilVisit(tree, visitor);
+ visit(tree, visitor)
function visitor(node) {
- var depth;
+ var depth
- if (!unistUtilGenerated(node)) {
+ if (!generated(node)) {
if (node.type === 'heading') {
- depth = node.depth;
+ depth = node.depth
} else if (node.type === 'html') {
- depth = infer(node);
+ depth = infer(node)
}
if (depth !== undefined) {
if (depth !== style) {
- file.message('First heading level should be `' + style + '`', node);
+ file.message('First heading level should be `' + style + '`', node)
}
- return unistUtilVisit.EXIT
+ return visit.EXIT
}
}
}
}
function infer(node) {
- var results = node.value.match(re$3);
+ var results = node.value.match(re)
return results ? Number(results[1]) : undefined
}
-var remarkLintHeadingStyle = unifiedLintRule('remark-lint:heading-style', headingStyle);
-var types$1 = ['atx', 'atx-closed', 'setext'];
+/***/ }),
+/* 345 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module heading-style
+ * @fileoverview
+ * Warn when a heading does not conform to a given style.
+ *
+ * Options: `'consistent'`, `'atx'`, `'atx-closed'`, or `'setext'`,
+ * default: `'consistent'`.
+ *
+ * `'consistent'` detects the first used heading style and warns when
+ * subsequent headings use different styles.
+ *
+ * ## Fix
+ *
+ * [`remark-stringify`](https://github.com/remarkjs/remark/tree/master/packages/remark-stringify)
+ * formats headings as ATX by default. This can be configured with the
+ * [`setext`](https://github.com/remarkjs/remark/tree/master/packages/remark-stringify#optionssetext)
+ * and [`closeAtx`](https://github.com/remarkjs/remark/tree/master/packages/remark-stringify#optionscloseatx)
+ * options.
+ *
+ * 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": "atx"}
+ *
+ * # Alpha
+ *
+ * ## Bravo
+ *
+ * ### Charlie
+ *
+ * @example {"name": "valid.md", "setting": "atx-closed"}
+ *
+ * # Delta ##
+ *
+ * ## Echo ##
+ *
+ * ### Foxtrot ###
+ *
+ * @example {"name": "valid.md", "setting": "setext"}
+ *
+ * Golf
+ * ====
+ *
+ * Hotel
+ * -----
+ *
+ * ### India
+ *
+ * @example {"name": "invalid.md", "label": "input"}
+ *
+ * Juliett
+ * =======
+ *
+ * ## Kilo
+ *
+ * ### Lima ###
+ *
+ * @example {"name": "invalid.md", "label": "output"}
+ *
+ * 4:1-4:8: Headings should use setext
+ * 6:1-6:13: Headings should use setext
+ */
+
+
+
+var rule = __webpack_require__(0)
+var visit = __webpack_require__(1)
+var style = __webpack_require__(94)
+var generated = __webpack_require__(2)
+
+module.exports = rule('remark-lint:heading-style', headingStyle)
+
+var types = ['atx', 'atx-closed', 'setext']
function headingStyle(tree, file, pref) {
- pref = types$1.indexOf(pref) === -1 ? null : pref;
+ pref = types.indexOf(pref) === -1 ? null : pref
- unistUtilVisit(tree, 'heading', visitor);
+ visit(tree, 'heading', visitor)
function visitor(node) {
- if (!unistUtilGenerated(node)) {
+ if (!generated(node)) {
if (pref) {
- if (mdastUtilHeadingStyle(node, pref) !== pref) {
- file.message('Headings should use ' + pref, node);
+ if (style(node, pref) !== pref) {
+ file.message('Headings should use ' + pref, node)
}
} else {
- pref = mdastUtilHeadingStyle(node, pref);
+ pref = style(node, pref)
}
}
}
}
-var remarkLintProhibitedStrings = unifiedLintRule('remark-lint:prohibited-strings', prohibitedStrings);
+
+/***/ }),
+/* 346 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+const rule = __webpack_require__(0);
+const visit = __webpack_require__(1);
+
+module.exports = rule('remark-lint:prohibited-strings', prohibitedStrings);
function testProhibited(val, content) {
const re = new RegExp(`(\\.|@[a-z0-9/-]*)?${val.no}(\\.\\w)?`, 'g');
@@ -33651,7 +39284,7 @@ function testProhibited(val, content) {
}
function prohibitedStrings(ast, file, strings) {
- unistUtilVisit(ast, 'text', checkText);
+ visit(ast, 'text', checkText);
function checkText(node) {
const content = node.value;
@@ -33664,156 +39297,388 @@ function prohibitedStrings(ast, file, strings) {
}
}
-var remarkLintStrongMarker = unifiedLintRule('remark-lint:strong-marker', strongMarker);
-var markers$1 = {'*': true, _: true, null: true};
+/***/ }),
+/* 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);
+ var contents = String(file)
- pref = typeof pref === 'string' && pref !== 'consistent' ? pref : null;
+ pref = typeof pref === 'string' && pref !== 'consistent' ? pref : null
- if (markers$1[pref] !== true) {
+ if (markers[pref] !== true) {
file.fail(
'Invalid strong marker `' +
pref +
"`: use either `'consistent'`, `'*'`, or `'_'`"
- );
+ )
}
- unistUtilVisit(tree, 'strong', visitor);
+ visit(tree, 'strong', visitor)
function visitor(node) {
- var marker = contents.charAt(unistUtilPosition.start(node).offset);
+ var marker = contents.charAt(position.start(node).offset)
- if (!unistUtilGenerated(node)) {
+ if (!generated(node)) {
if (pref) {
if (marker !== pref) {
- file.message('Strong should use `' + pref + '` as a marker', node);
+ file.message('Strong should use `' + pref + '` as a marker', node)
}
} else {
- pref = marker;
+ pref = marker
}
}
}
}
-var remarkLintTableCellPadding = unifiedLintRule('remark-lint:table-cell-padding', tableCellPadding);
-var start$13 = unistUtilPosition.start;
-var end$9 = unistUtilPosition.end;
+/***/ }),
+/* 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"}
+ *
+ * <!-- Empty cells are OK, but those surrounding them may not be. -->
+ *
+ * | | 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"}
+ *
+ * <!-- Missing cells are fine as well. -->
+ *
+ * | Alpha | Bravo | Charlie |
+ * | ----- | -------- | ------- |
+ * | Delta |
+ * | Echo | Foxtrott |
+ */
+
-var styles$2 = {null: true, padded: true, compact: true};
+
+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);
+ var contents = String(file)
- pref = typeof pref === 'string' && pref !== 'consistent' ? pref : null;
+ pref = typeof pref === 'string' && pref !== 'consistent' ? pref : null
- if (styles$2[pref] !== true) {
- file.fail('Invalid table-cell-padding style `' + pref + '`');
+ if (styles[pref] !== true) {
+ file.fail('Invalid table-cell-padding style `' + pref + '`')
}
- unistUtilVisit(tree, 'table', visitor);
+ visit(tree, 'table', visitor)
function visitor(node) {
- var rows = node.children;
- var sizes = new Array(node.align.length);
- var length = unistUtilGenerated(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;
+ 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;
+ 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];
+ cell = next
+ next = cells[column + 1]
fence = contents.slice(
- cell ? end$9(cell).offset : start$13(row).offset,
- next ? start$13(next).offset : end$9(row).offset
- );
+ cell ? end(cell).offset : start(row).offset,
+ next ? start(next).offset : end(row).offset
+ )
- pos = fence.indexOf('|');
+ pos = fence.indexOf('|')
if (cell && cell.children.length !== 0 && final !== undefined) {
- entries.push({node: cell, start: final, end: pos, index: column});
+ entries.push({node: cell, start: final, end: pos, index: column})
/* Detect max space per column. */
- sizes[column] = Math.max(sizes[column] || 0, size(cell));
+ sizes[column] = Math.max(sizes[column] || 0, size(cell))
} else {
- final = undefined;
+ final = undefined
}
if (next && next.children.length !== 0) {
- final = fence.length - pos - 1;
+ final = fence.length - pos - 1
} else {
- final = undefined;
+ final = undefined
}
}
}
if (pref) {
- style = pref === 'padded' ? 1 : 0;
+ style = pref === 'padded' ? 1 : 0
} else {
- style = entries[0] && (!entries[0].start || !entries[0].end) ? 0 : 1;
+ style = entries[0] && (!entries[0].start || !entries[0].end) ? 0 : 1
}
- index = -1;
- length = entries.length;
+ index = -1
+ length = entries.length
while (++index < length) {
- entry = entries[index];
- checkSide('start', entry, style, sizes);
- checkSide('end', entry, style, sizes);
+ entry = entries[index]
+ checkSide('start', entry, style, sizes)
+ checkSide('end', entry, style, sizes)
}
- return unistUtilVisit.SKIP
+ return visit.SKIP
}
function checkSide(side, entry, style, sizes) {
- var cell = entry.node;
- var spacing = entry[side];
- var index = entry.index;
- var reason;
+ var cell = entry.node
+ var spacing = entry[side]
+ var index = entry.index
+ var reason
if (spacing === undefined || spacing === style) {
return
}
- reason = 'Cell should be ';
+ reason = 'Cell should be '
if (style === 0) {
- reason += 'compact';
+ reason += 'compact'
/* Ignore every cell except the biggest in the column. */
if (size(cell) < sizes[index]) {
return
}
} else {
- reason += 'padded';
+ reason += 'padded'
if (spacing > style) {
- reason += ' with 1 space, not ' + spacing;
+ reason += ' with 1 space, not ' + spacing
/* May be right or center aligned. */
if (size(cell) < sizes[index]) {
@@ -33822,103 +39687,15 @@ function tableCellPadding(tree, file, pref) {
}
}
- file.message(reason, cell.position[side]);
+ file.message(reason, cell.position[side])
}
}
function size(node) {
- return end$9(node).offset - start$13(node).offset
-}
-
-var plugins$1 = [
- remarkLint,
- remarkLintCheckboxContentIndent,
- remarkLintDefinitionSpacing,
- remarkLintFencedCodeFlag,
- remarkLintFinalDefinition,
- remarkLintFinalNewline,
- remarkLintHardBreakSpaces,
- remarkLintHardBreakSpaces,
- [
- remarkLintListItemIndent,
- 'space'
- ],
- remarkLintMaximumLineLength,
- remarkLintNoAutoLinkWithoutProtocol,
- remarkLintNoBlockquoteWithoutMarker,
- remarkLintNoDuplicateDefinitions,
- remarkLintNoFileNameArticles,
- remarkLintNoFileNameConsecutiveDashes,
- remarkLintNoFileNameOuterDashes,
- remarkLintNoHeadingContentIndent,
- remarkLintNoHeadingIndent,
- remarkLintNoInlinePadding,
- remarkLintNoMultipleToplevelHeadings,
- remarkLintNoShellDollars,
- remarkLintNoShortcutReferenceImage,
- remarkLintNoTableIndentation,
- remarkLintNoTabs,
- remarkLintNoTrailingSpaces,
- remarkLintNoUnusedDefinitions,
- remarkLintRuleStyle,
- remarkLintTablePipes,
- [remarkLintBlockquoteIndentation, 2],
- [
- remarkLintCheckboxCharacterStyle,
- {
- 'checked': 'x', 'unchecked': ' '
- }
- ],
- [remarkLintCodeBlockStyle, 'fenced'],
- [remarkLintFencedCodeMarker, '`'],
- [remarkLintFileExtension, 'md'],
- [remarkLintFirstHeadingLevel, 1],
- [remarkLintHeadingStyle, 'atx'],
- [
- remarkLintProhibitedStrings,
- [
- { no: 'Github', yes: 'GitHub' },
- { no: 'Javascript', yes: 'JavaScript' },
- { no: 'Node.JS', yes: 'Node.js' },
- { no: 'v8', yes: 'V8' }
- ]
- ],
- [remarkLintStrongMarker, '*'],
- [remarkLintTableCellPadding, 'padded']
-];
-
-var remarkPresetLintNode = {
- plugins: plugins$1
-};
-
-var proc = ( _package$1 && _package ) || _package$1;
-
-var cli = ( _package$3 && _package$2 ) || _package$3;
-
-const { plugins: plugins$2 } = remarkPresetLintNode;
-
-const args = {
- processor: remark,
- name: proc.name,
- description: cli.description,
- version: [
- proc.name + ': ' + proc.version,
- cli.name + ': ' + cli.version
- ].join(', '),
- ignoreName: '.' + proc.name + 'ignore',
- extensions: markdownExtensions$2
-};
-const config = options_1(process.argv.slice(2), args);
-config.detectConfig = false;
-config.plugins = plugins$2;
-
-lib$2(config, function done(err, code) {
- if (err) console.error(err);
- process.exit(code);
-});
-
-var cliEntry = {
+ return end(node).offset - start(node).offset
+}
-};
-module.exports = cliEntry;
+/***/ })
+/******/ ]);
+//# sourceMappingURL=index.js.map \ No newline at end of file
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-02 10:52:36 +0000